Metadata-Version: 2.4
Name: eforge
Version: 1.0.14
Summary: Codebase observation graph and mapping tools - lightweight node system for developer notes
Project-URL: Repository, https://github.com/NT9V/forge
License: MIT
Keywords: codebase,developer-tools,graph,mapping,observation
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.12
Requires-Python: >=3.12
Requires-Dist: click>=8.1
Requires-Dist: duckdb>=0.9.0
Requires-Dist: pydantic>=2.0
Requires-Dist: pyyaml>=6.0
Requires-Dist: ruamel-yaml>=0.18
Provides-Extra: board
Requires-Dist: fastapi>=0.100; extra == 'board'
Requires-Dist: httpx>=0.24; extra == 'board'
Requires-Dist: uvicorn>=0.23; extra == 'board'
Provides-Extra: compiler
Provides-Extra: dev
Requires-Dist: build>=1.0; extra == 'dev'
Requires-Dist: pytest-asyncio; extra == 'dev'
Requires-Dist: pytest>=7.0; extra == 'dev'
Provides-Extra: mcp
Requires-Dist: mcp>=1.0; extra == 'mcp'
Description-Content-Type: text/markdown

# eforge

Codebase observation graph for developers.
Map your codebase. Track concepts. Find relationships.

**Trust:** PyPI `eforge` is the observation face, not the full monorepo
compiler. See [docs/TRUST.md](docs/TRUST.md) and [docs/WORKFLOWS.md](docs/WORKFLOWS.md).

## Install

```bash
pip install eforge
```

That installs **three packages only**: `eforge`, `click`, and `PyYAML`.

| Install | What you get |
|---------|----------------|
| `pip install eforge` | Standalone CLI: `init`, `task`, `node`, `schema`, `error`, `config` |
| Monorepo checkout | Adds runtime commands: `orient`, `search`, `declare`, `inspect`, … via ActionRegistry; `forge` keeps the full legacy compiler CLI |
| `pip install eforge[compiler]` | Reserved for a future full graph runtime on PyPI (not published yet) |

## Project bootstrap

**Two storage domains** — do not conflate them:

| Domain | Directory | Created by |
|--------|-----------|------------|
| eforge (observation) | `.eforge/schemas/`, `.eforge/observations/` | `eforge init` |
| Declaration (manifest graph) | `.forge/manifest.yaml`, `.forge/tasks/` | `eforge declare`, `eforge console`, or legacy `forge init` |

```bash
cd your-project
eforge init                    # .eforge/ only
eforge node add "Auth" -y      # observation graph
eforge task add --title "..." -y   # creates .forge/tasks/ on first use

# With compiler runtime (monorepo):
eforge declare -y                # bootstraps .forge/ if needed
eforge console
```

Legacy repos may still have observations under `.eforge/observations/`; new
projects use that path. Older `.forge/observations/` layouts are read as fallback.

## No setup needed

After `eforge init`, add nodes anytime:

```bash
eforge node add "AuthSystem" --kind concept/feature -y
eforge node add "auth.py" --kind core/file \
  --file src/auth.py -y
eforge node link "AuthSystem" "auth.py" \
  --rel housed-in \
  --note "core auth logic" -y
eforge node show "AuthSystem"
```

## Commands

```text
eforge init     create .eforge/ observation storage
eforge node     add, show, list, find, link,
                note, tag, mark, edit, inspect
eforge schema   list, show, create, edit,
                validate, copy, restore
eforge task     list, add, done, show, update
eforge config   get, set, show, validate, reset
eforge error    lookup (<CODE>), --list, --search, --stats
```

Workflows for external users: [docs/WORKFLOWS.md](docs/WORKFLOWS.md).
Trust ladder: [docs/TRUST.md](docs/TRUST.md).

## Your own schemas

eforge ships with built-in schemas for common node types.
Add project-specific schemas without touching forge:

```bash
eforge schema create game/canvas
```

This creates `.eforge/schemas/domain/game/canvas.yaml`.
Your schema is immediately available:

```bash
eforge node add "PixelCanvas" --kind game/canvas
# SchemaPrompt uses YOUR schema properties
```

Schema search order:

1. `.eforge/schemas/` (your project)
2. forge built-ins

Built-in kinds: `concept/feature`, `core/file`, `ui/screen`, `ui/variant`,
`ui/component`, `architecture/session`, `architecture/boundary`, `data/model`,
`data/table`, `data/rpc`, `code/class`, `code/function`, `code/module`

## Node types

```text
concept/feature planned features, systems, capabilities
core/file       source files
```

## Relationship types

```text
housed-in       concept → file
relates-to      concept → concept
depends-on      A needs B
implements      code implements concept
raises          code raises error
```

## Storage

```text
.eforge/schemas/              project type schemas
.eforge/observations/
  nodes/                      one yaml per node
  .cache/                     SQLite index (auto-rebuilt)
.forge/manifest.yaml          declaration graph (not created by eforge init)
.forge/tasks/                 work items (created on first task add)
```

## No AI required

Works without any AI assistant.
Map your codebase manually, one node at a time.
