toji 0.1.2__tar.gz

toji-0.1.2/.github/workflows/release.yml

@@ -0,0 +1,56 @@
+name: release
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write        # semantic-release: version commit + tag + GitHub release
+  id-token: write        # PyPI trusted publishing (OIDC)
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0            # full history: PSR needs tags to compute the next version
+          token: ${{ secrets.GH_RELEASE_TOKEN || github.token }}
+
+      - uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.13"
+
+      - name: Install
+        run: uv sync --dev
+
+      - name: Test
+        run: uv run pytest -q
+      - name: Semantic release
+        env:
+          GH_TOKEN: ${{ secrets.GH_RELEASE_TOKEN || github.token }}
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          uv run semantic-release version
+          if git describe --tags --exact-match HEAD 2>/dev/null; then
+            uv build
+            if [ -n "$PYPI_TOKEN" ]; then
+              uv publish --token "$PYPI_TOKEN"
+            else
+              echo "PYPI_TOKEN not set - skipping PyPI publish"
+            fi
+          else
+            echo "No version change - skipping build/publish"
+          fi
+
+      - name: Upload dist artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 14

toji-0.1.2/.gitignore

@@ -0,0 +1,14 @@
+# python
+__pycache__/
+*.pyc
+.venv/
+dist/
+build/
+*.egg-info/
+
+# tooling
+.pytest_cache/
+.ruff_cache/
+
+# toji's own index
+.toji/

toji-0.1.2/CHANGELOG.md

@@ -0,0 +1,43 @@
+# CHANGELOG
+
+
+
+## v0.1.2 (2026-08-22)
+
+### Fix
+
+* fix(release): pass pypi token to uv publish ([`894aac2`](https://github.com/mr-jones123/toji/commit/894aac2ea83946b5f22ccf62e0ab4b3660aa0e59))
+
+
+## v0.1.1 (2026-08-22)
+
+### Fix
+
+* fix(release): enable pypi publishing ([`943119b`](https://github.com/mr-jones123/toji/commit/943119bf4705226ef8d9f846611a0807b779ab5b))
+
+### Unknown
+
+* Update README.md ([`bf76e79`](https://github.com/mr-jones123/toji/commit/bf76e7942080e1b92a881acc64e282af017e5704))
+
+
+## v0.1.0 (2026-08-22)
+
+### Chore
+
+* chore: restore version field clobbered during packaging edits ([`0ef59ab`](https://github.com/mr-jones123/toji/commit/0ef59abbe09433e6fe843ca199b202de8f6d3864))
+
+### Ci
+
+* ci: fix invalid semantic-release flag, skip publish without token ([`bb71603`](https://github.com/mr-jones123/toji/commit/bb71603119aef854772bc29a4303b5c55e30fca7))
+
+### Documentation
+
+* docs: add README with badges and usage; package readme for PyPI ([`1be5cd0`](https://github.com/mr-jones123/toji/commit/1be5cd03f0ec12433a7bef1fad686bf83e3ac8a5))
+
+### Feature
+
+* feat: codebase graph memory with evidence CLI (v0.1.0) ([`8d84931`](https://github.com/mr-jones123/toji/commit/8d849311a70d396ab7e8cbc68bb3cea7bcfe84ba))
+
+### Fix
+
+* fix(release): use angular commit parser name for python-semantic-release ([`0af8d30`](https://github.com/mr-jones123/toji/commit/0af8d30c645d7933890d11c74bcecd2a8fedf24e))

toji-0.1.2/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: toji
+Version: 0.1.2
+Requires-Python: >=3.11
+Requires-Dist: pathspec>=0.12
+Requires-Dist: rich>=15.0.0
+Requires-Dist: tree-sitter-javascript>=0.23
+Requires-Dist: tree-sitter-python>=0.23
+Requires-Dist: tree-sitter-typescript>=0.23
+Requires-Dist: tree-sitter<0.26,>=0.23
+Description-Content-Type: text/markdown
+
+# toji
+
+> Codebase graph memory: index structure once, answer with evidence forever.
+
+[![PyPI](https://img.shields.io/pypi/v/toji)](https://pypi.org/project/toji/)
+[![Python](https://img.shields.io/pypi/pyversions/toji)](https://pypi.org/project/toji/)
+[![Release](https://github.com/mr-jones123/toji/actions/workflows/release.yml/badge.svg)](https://github.com/mr-jones123/toji/actions/workflows/release.yml)
+[![License](https://img.shields.io/badge/license-unreleased-lightgrey)]()
+
+toji parses your codebase (Python, TypeScript, TSX, JavaScript) into a queryable
+graph — symbols, signatures, docstrings, call/import/inherit edges — stored in
+SQLite. No source is stored; `read` always fetches live lines from disk. Awesome no?
+
+Built for AI reviewers and anyone tired of skimming ten files to answer
+"who calls this?": every answer carries exact `path:line` evidence, ambiguous
+names are surfaced instead of guessed, and unresolved calls are reported as
+unknown rather than invented.
+
+## Install
+
+```bash
+pip install toji            # or: uv tool install toji
+```
+
+Or install as an agent skill (instructions for AI coding agents):
+
+```bash
+npx skills add mr-jones123/toji
+```
+
+## Quickstart
+
+```bash
+toji index .                # index current directory -> .toji/graph.db
+toji map src/               # skeleton of a module: symbols, signatures, docstrings
+toji find "classify"        # regex search over symbol names
+toji callers classify_change    # who calls it, with file:line evidence
+toji blast classify_change  # BFS blast radius: what a change affects, hop-ranked
+toji read classify_change   # the symbol's actual source lines
+```
+
+Reindexing is incremental and content-hashed: only changed files re-parse.
+A full 12k-file monorepo indexes in ~40s; unchanged reindex scans are sub-second.
+
+## Commands
+
+| Command | Evidence returned |
+|---|---|
+| `index [PATH] [--force]` | build/rebuild the graph (incremental by content hash) |
+| `map [FILE\|SYM]` | file skeleton or symbol detail |
+| `find <regex>` | matching symbols |
+| `calls <sym>` | forward call edges + unresolved callees |
+| `callers <sym>` | reverse call edges (1 hop) |
+| `blast <sym> [--depth N] [--forward]` | affected symbols across calls/contains/inherits |
+| `deps <file>` | import edges both directions, resolved to files |
+| `read <sym>` | the symbol's live source lines from disk |
+| `stats` | index size, resolution quality metrics |
+
+Every command accepts `--json` for stable machine-readable output.
+
+## How resolution works
+
+Call edges store the callee *as written* (`obj.method`, `helper`). At query
+time they resolve through file-local scopes, the importing file's own imports,
+then global unique suffix/bare-name matches:
+
+- **Confident** matches resolve with the exact call-site line attached.
+- **Ambiguous** names list every candidate instead of guessing.
+- **Unresolved** calls (stdlib, dynamic dispatch) are counted and shown —
+  never fabricated. `toji stats` reports the ratio so you know what the graph
+  is confident about.
+
+`blast` and `callers` merge same-named definitions (e.g. a method implemented
+by several cloud adapters) and traverse from all of them, reporting the count;
+`read`, `calls`, and `map` require a single symbol and will ask you to
+disambiguate instead.
+
+## Releasing
+
+Conventional Commits drive versions automatically on push to `main`
+(`fix:` → patch, `feat:` → minor, `BREAKING CHANGE:` → major). The release
+workflow tests, bumps the version, generates the changelog, tags, builds, and
+publishes to PyPI. Configure either PyPI trusted publishing or a `PYPI_TOKEN`
+secret to enable publishing.
+
+## License
+
+TBD.

toji-0.1.2/README.md

@@ -0,0 +1,88 @@
+# toji
+
+> Codebase graph memory: index structure once, answer with evidence forever.
+
+[![PyPI](https://img.shields.io/pypi/v/toji)](https://pypi.org/project/toji/)
+[![Python](https://img.shields.io/pypi/pyversions/toji)](https://pypi.org/project/toji/)
+[![Release](https://github.com/mr-jones123/toji/actions/workflows/release.yml/badge.svg)](https://github.com/mr-jones123/toji/actions/workflows/release.yml)
+[![License](https://img.shields.io/badge/license-unreleased-lightgrey)]()
+
+toji parses your codebase (Python, TypeScript, TSX, JavaScript) into a queryable
+graph — symbols, signatures, docstrings, call/import/inherit edges — stored in
+SQLite. No source is stored; `read` always fetches live lines from disk. Awesome no?
+
+Built for AI reviewers and anyone tired of skimming ten files to answer
+"who calls this?": every answer carries exact `path:line` evidence, ambiguous
+names are surfaced instead of guessed, and unresolved calls are reported as
+unknown rather than invented.
+
+## Install
+
+```bash
+pip install toji            # or: uv tool install toji
+```
+
+Or install as an agent skill (instructions for AI coding agents):
+
+```bash
+npx skills add mr-jones123/toji
+```
+
+## Quickstart
+
+```bash
+toji index .                # index current directory -> .toji/graph.db
+toji map src/               # skeleton of a module: symbols, signatures, docstrings
+toji find "classify"        # regex search over symbol names
+toji callers classify_change    # who calls it, with file:line evidence
+toji blast classify_change  # BFS blast radius: what a change affects, hop-ranked
+toji read classify_change   # the symbol's actual source lines
+```
+
+Reindexing is incremental and content-hashed: only changed files re-parse.
+A full 12k-file monorepo indexes in ~40s; unchanged reindex scans are sub-second.
+
+## Commands
+
+| Command | Evidence returned |
+|---|---|
+| `index [PATH] [--force]` | build/rebuild the graph (incremental by content hash) |
+| `map [FILE\|SYM]` | file skeleton or symbol detail |
+| `find <regex>` | matching symbols |
+| `calls <sym>` | forward call edges + unresolved callees |
+| `callers <sym>` | reverse call edges (1 hop) |
+| `blast <sym> [--depth N] [--forward]` | affected symbols across calls/contains/inherits |
+| `deps <file>` | import edges both directions, resolved to files |
+| `read <sym>` | the symbol's live source lines from disk |
+| `stats` | index size, resolution quality metrics |
+
+Every command accepts `--json` for stable machine-readable output.
+
+## How resolution works
+
+Call edges store the callee *as written* (`obj.method`, `helper`). At query
+time they resolve through file-local scopes, the importing file's own imports,
+then global unique suffix/bare-name matches:
+
+- **Confident** matches resolve with the exact call-site line attached.
+- **Ambiguous** names list every candidate instead of guessing.
+- **Unresolved** calls (stdlib, dynamic dispatch) are counted and shown —
+  never fabricated. `toji stats` reports the ratio so you know what the graph
+  is confident about.
+
+`blast` and `callers` merge same-named definitions (e.g. a method implemented
+by several cloud adapters) and traverse from all of them, reporting the count;
+`read`, `calls`, and `map` require a single symbol and will ask you to
+disambiguate instead.
+
+## Releasing
+
+Conventional Commits drive versions automatically on push to `main`
+(`fix:` → patch, `feat:` → minor, `BREAKING CHANGE:` → major). The release
+workflow tests, bumps the version, generates the changelog, tags, builds, and
+publishes to PyPI. Configure either PyPI trusted publishing or a `PYPI_TOKEN`
+secret to enable publishing.
+
+## License
+
+TBD.

toji-0.1.2/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: toji
+description: 'Use when you need to understand a codebase, answer questions about callers, callees, imports, estimate blast radius of a change, or review code with evidence instead of guessing. toji indexes code structure (symbols, signatures, docstrings, call/import/inherit edges) into a queryable graph; no source is stored. Triggers: "who calls X", "what breaks if I change X", "map this module", "review this PR with evidence", "how do A and B connect".'
+---
+
+# toji — codebase graph memory
+
+Index a codebase once, then answer structural questions with exact `file:line`
+evidence — no file-by-file skimming.
+
+## When to use
+
+Use toji instead of reading files directly when the question is structural:
+where a symbol is defined, who calls it, what it calls, what imports what, or
+what a change breaks. After toji narrows you to the relevant lines, use
+`toji read` (or the file) for the actual source.
+
+## CLI availability
+
+The `toji` command must be installed on the machine:
+
+```bash
+pip install toji          # published package
+uv tool install toji      # or as a standalone tool
+```
+
+If the command is missing, run one of the above (or build from source with
+`uv tool install .`).
+
+## Workflow
+
+1. **Index first.** If `<root>/.toji/graph.db` does not exist (or code changed
+   since), run:
+
+   ```bash
+   toji index [PATH]       # default: current directory
+   ```
+
+   Reindexing is incremental and content-hashed: only changed files re-parse.
+   The index lives at `<PATH>/.toji/graph.db`; pass `--db <path>` to point
+   any query at a specific index.
+
+2. **Find the symbol** (regex over symbol names/qualnames):
+
+   ```bash
+   toji find <regex>        # -> path:line kind qualname rows
+   ```
+
+3. **Answer structural questions:**
+
+   | Command | Evidence returned |
+   |---|---|
+   | `toji map [FILE\|SYM]` | file skeleton (signatures + docstrings) or symbol detail |
+   | `toji callers <sym>` | who calls it (1 hop, reverse) |
+   | `toji calls <sym>` | what it calls + unresolved callees |
+   | `toji blast <sym> [--depth N] [--forward]` | BFS blast radius: affected symbols, hop-ranked, each with the exact call-site line |
+   | `toji deps <file>` | import edges both directions, resolved to files |
+   | `toji read <sym>` | the symbol's actual source lines from disk (def line highlighted) |
+   | `toji stats` | index size + unresolved-call count |
+
+4. **Read only what matters.** `toji read <sym> [--context N]` prints the exact
+   line range; that is the source of truth for behavior claims.
+
+## Evidence contract
+
+- **Cite what you verified.** Every `calls`/`callers`/`blast`/`deps` result
+  carries `path:line` — when you make a claim from it, keep that reference.
+  When you need the body, `read` it before asserting behavior.
+- **Unresolved means unknown.** toji stores callees as written text and
+  resolves them heuristically (exact name -> unique suffix -> unique bare
+  name). Calls it cannot resolve are listed explicitly as `unresolved` —
+  never treat them as facts, and never invent what they might be.
+- **Ambiguity handling.** `read`, `calls`, and `map` require a single symbol:
+  an ambiguous name errors and lists every candidate with `path:line` —
+  disambiguate with the full qualname or a `find` result. `blast` and
+  `callers` instead merge all same-named definitions (e.g. a method
+  implemented by several adapters) and traverse from every one, reporting
+  the count in the header (`across N definitions`). Same-name merging is
+  exhaustive, never a guess.
+- **`--json` for machine use.** Every command supports `--json` and emits
+  stable structured output (`{path, line, kind, qualname, ...}`) suitable for
+  parsing; omit it for human-readable rich tables.
+- **Blast radius direction.** `blast` is reverse by default (callers,
+  containers, subclasses — what a change affects). `--forward` adds callees.
+  `--depth` caps hops; large graphs truncate at `--max-nodes` (default 200)
+  with an explicit notice.
+- **No source is stored.** Signatures and docstrings yes; bodies no. `read`
+  always fetches live source — if the file changed since indexing, reindex
+  (`toji index`) to refresh line numbers.
+
+## Model limitations (state them, don't hide them)
+
+- Call resolution is name-based, not type-aware. Dynamic dispatch, factories,
+  and same-named symbols in different modules are handled conservatively:
+  unresolved or ambiguous, never guessed.
+- TS/JS docstrings are not captured (Python only).
+- `import * as X` (TS namespace imports) and star re-exports resolve as
+  module edges, not per-symbol edges.

toji-0.1.2/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "toji"
+readme = "README.md"
+version = "0.1.2"
+requires-python = ">=3.11"
+dependencies = [
+    "tree-sitter>=0.23,<0.26",
+    "tree-sitter-python>=0.23",
+    "tree-sitter-javascript>=0.23",
+    "tree-sitter-typescript>=0.23",
+    "pathspec>=0.12",
+    "rich>=15.0.0",
+]
+
+[project.scripts]
+toji = "toji.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/toji"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/toji/queries/python.scm" = "toji/queries/python.scm"
+"src/toji/queries/tsjs.scm" = "toji/queries/tsjs.scm"
+"src/toji/queries/js.scm" = "toji/queries/js.scm"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "python-semantic-release>=9.3.1",
+    "twine>=7.0.0",
+]
+
+[tool.semantic_release]
+version_toml = ["pyproject.toml:project.version"]
+tag_format = "v{version}"
+commit_parser = "angular"
+changelog_file = "CHANGELOG.md"
+build_command = "uv build"
+allow_zero_version = true
+
+[tool.semantic_release.branches.main]
+match = "main"
+
+[tool.semantic_release.publish]
+dist_glob_patterns = ["dist/*"]
+upload_to_vcs_release = true
+

toji-0.1.2/src/toji/__init__.py

@@ -0,0 +1,3 @@
+"""toji — codebase graph memory for AI reviewers."""
+
+__version__ = "0.1.0"