scip-cli 2.4.0__tar.gz → 2.6.0__tar.gz

scip_cli-2.6.0/.agents/commands/migration-problems.md

@@ -0,0 +1,82 @@
+# Document migration problems
+
+Review this session (and any ports you just touched) and append **only** language / tooling walls to `migration-problems.md`.
+
+## Where to write
+
+| Repo | File |
+|------|------|
+| `scip-cli-go` | `migration-problems.md` |
+| `scip-cli-rust` | `migration-problems.md` |
+| `scip-cli-zig` | `migration-problems.md` |
+| `scip-cli` (Python) | Usually **none** — Python is the reference, not a port. Only add a note if the user asks. |
+
+If the workspace is one of the ports, edit that repo’s file. If several ports were touched, update each relevant file. Match existing numbering and section style in that file.
+
+Do **not** invent entries from first principles — only document walls you (or a subagent) actually hit in this work.
+
+---
+
+## Why this file exists
+
+These repos are an experiment: **which language is better for AI to code in?**
+
+`migration-problems.md` is evidence for that question. A reader should learn something about the **language, compiler, stdlib, or ecosystem tooling** — not about scip-cli product bugs or “we forgot a branch.”
+
+Ask before writing:
+
+> *If we ported a different CLI tomorrow, would this entry still teach something about coding in this language with an AI?*
+
+If **no** → do not add it.
+
+---
+
+## What TO put (include)
+
+Fundamental friction that slows or confuses an AI agent because of the **language or its tools**:
+
+| Category | Examples |
+|----------|----------|
+| **Compiler / type system** | Borrow checker traps; Zig shadowing rules; Go’s `module/v2` path rules; errors that force many tiny fix loops |
+| **Stdlib / API drift** | Zig 0.17 removed `std.fs.cwd`; training data assumes older APIs; crate APIs that don’t match Python intuition (`regex` no lookbehind) |
+| **Tooling loop cost** | Full `zig build -Doptimize=ReleaseFast` ~25s+ → fewer AI iterations; `gofmt`/`cargo fmt` rewrite every commit; clippy/rustc so strict the agent flails for N cycles |
+| **Ecosystem surprises** | CGO vs pure-Go SQLite; `anyhow::bail!` prefixes user errors; package name vs import path traps |
+| **Agent × language interaction** | Persistent shell + language-specific env scripts hanging; test runners with no skip → vacuously green |
+
+Entry shape (adapt to the file’s existing voice):
+
+- **Symptom** — what the agent saw (compile error, hang, parity fail)
+- **Cause** — language/tooling root cause (not “we missed a line of business logic”)
+- **Lesson** — what an AI (or human) should remember next time in this language
+- Optional: time sink / iteration count if it was large
+
+Prefer **one sharp entry** over a dump of every compile error.
+
+---
+
+## What NOT to put (exclude)
+
+| Do not document | Why |
+|-----------------|-----|
+| Product / logic bugs (“search printed duplicates”, “forgot DER fallback”) | Same bug in any language; says nothing about Go vs Rust vs Zig |
+| “We forgot to port X” / incomplete ports | Process failure, not language |
+| TODOs, wishlists, backlog | Wrong file (`todo.md` / docs) |
+| One-off typos, wrong SQL, missed edge cases in *our* code | Not language-fundamental |
+| Parity mismatches that are just divergent implementations | Unless caused by a real language constraint |
+| Generic “AI made a mistake” | Only if the language *systematically* induces that mistake (e.g. trained on old Zig stdlib) |
+
+**Litmus test:** Removing scip-cli from the story — does the entry still make sense?
+- ✅ “Zig ReleaseFast builds dominate the edit–compile loop”
+- ❌ “Search must dedupe Prisma typeLiterals by file:line”
+
+---
+
+## How to run this command
+
+1. Skim the conversation / diffs for walls that burned time.
+2. Open the target `migration-problems.md`; read the last few entries so style and numbers match.
+3. For each candidate, apply the litmus test. Drop application-logic noise.
+4. Append new entries (or fix an existing entry if you previously wrote the wrong *kind* of note).
+5. Do **not** commit unless the user asks. Briefly tell the user what you added (or that nothing qualified).
+
+If nothing in the session qualifies, say so — **empty is better than polluting the experiment.**

{scip_cli-2.4.0/.cursor → scip_cli-2.6.0/.agents}/rules/agent.mdc

@@ -28,15 +28,18 @@ Node.js + `npx` required for integration tests (`scip-typescript`). Optional: `S
 
 ## Lint / test
 
-| Task | Command |
-|------|---------|
-| Full suite | `pytest` |
-| E2e loop | `pytest tests/test_e2e.py tests/test_e2e_analyze_patterns.py` |
-| Lint / format | `ruff check .` / `ruff format .` |
-| Typecheck | `basedpyright scip_cli/` |
+|Task|Command|
+|---|---|
+|**All checks**|`scripts/test.sh` (lint + format + types + tests)|
+|Full suite|`pytest`|
+|E2e loop|`pytest tests/test_e2e.py tests/test_e2e_analyze_patterns.py`|
+|Lint / format|`ruff check .` / `ruff format .`|
+|Typecheck|`basedpyright scip_cli/`|
 
 Pre-commit: ruff + ruff-format + basedpyright + full pytest. E2e before commit on command changes.
 
+**Use `scripts/test.sh`** before committing to catch all issues (lint, format, types, tests). This matches what pre-commit runs.
+
 ## Improving this repo (do this before review subagents)
 
 **Dogfood on the repo itself** — faster and more honest than spawning reviewers:
@@ -51,12 +54,12 @@ scip-cli analyze scip_cli/queries.py --limit 20   # file (+ scoped project)
 
 Interpretation: README § *Finding easy wins with analyze*. Target = omit (project), directory, file, or symbol — not `--path` for scope.
 
-| Priority | Section | Action |
-|----------|---------|--------|
-| 1 | **Cycles** | Break production file dependency cycles (`cache`↔`scope` was one) |
-| 2 | **Unreferenced / dead exports** | No ref usage / no external refs — verify with `rg`, delete or `_` prefix |
-| 3 | **Same-file only** | Module-private by usage — rename to `_` |
-| 4 | **Stale types** | Low-consumer classes — merge or justify |
+|Priority|Section|Action|
+|---|---|---|
+|1|**Cycles**|Break production file dependency cycles (`cache`↔`scope` was one)|
+|2|**Unreferenced / dead exports**|No ref usage / no external refs — verify with `rg`, delete or `_` prefix|
+|3|**Same-file only**|Module-private by usage — rename to `_`|
+|4|**Stale types**|Low-consumer classes — merge or justify|
 
 `analyze` skips test paths by default (`tests/`, `*.test.*`, `*.spec.*`); `--include-tests` to include. Reindex after large edits.
 
@@ -79,19 +82,19 @@ Only skip step 1 when the issue is **outside the index** (runtime, CLI UX, docs
 
 ### Retrospective: caught manually, SQLite already had it
 
-| Issue we hit | Index signal | Analyze today | Gap / next check |
-|--------------|--------------|---------------|------------------|
-| `cache` ↔ `scope` import cycle | cross-file `mentions` edges | `[high] Cycles` | **Caught** — keep dogfooding cycles |
-| Cross-file dead export (`get_refs_for_symbols`) | def with no external `mentions` | `[high] Dead exports` | **Caught** |
-| Same-file-only dead code | def, `role=0` only in def file | `[high] Unreferenced` or `[medium] Same-file only` | **Caught** (since extended) |
-| Same-file helper without `_` (`run_with_fallback`) | same-file `role=0` or none | `[medium] Same-file only` / unreferenced | **Caught** — rename to `_` |
-| Typing-only dataclasses (`ProjectSettings`, `IndexScope`) | type `#` symbol, 0 consumer files | `[high] Stale types` + `stale_type_noise` | **Filtered** — index can't see annotations; document or optional `--types` |
-| `analyze/*` section runners “dead” | no external refs | noise filter in `common.py` | **Filtered** — framework pattern |
-| Unused import | `role=2` mention, no in-file use | `[high] Unused imports` (per file) | **Caught** on file target |
-| Hub before editing (`resolve_symbol`, `queries.py`) | fan-in / consumer count | `[medium] Change surface` / `[low] Hotspots` | **Caught** on file target; project hubs are low tier |
-| Symbol only used from tests | consumers all under `tests/` | `[low] Test-only consumers` | **Partial** — Python index often omits same-file `role=0`; verify with `rg` |
-| Indexer omits same-file Python calls | no `role=0` for in-module use | unreferenced / test-only false positives | **Index gap** — not fixable in SQL alone; demoted test-only to low |
-| Duplicate / parallel helpers | — | — | **Not in index** — `rg`, not analyze |
+|Issue we hit|Index signal|Analyze today|Gap / next check|
+|---|---|---|---|
+|`cache` ↔ `scope` import cycle|cross-file `mentions` edges|`[high] Cycles`|**Caught** — keep dogfooding cycles|
+|Cross-file dead export (`get_refs_for_symbols`)|def with no external `mentions`|`[high] Dead exports`|**Caught**|
+|Same-file-only dead code|def, `role=0` only in def file|`[high] Unreferenced` or `[medium] Same-file only`|**Caught** (since extended)|
+|Same-file helper without `_` (`run_with_fallback`)|same-file `role=0` or none|`[medium] Same-file only` / unreferenced|**Caught** — rename to `_`|
+|Typing-only dataclasses (`ProjectSettings`, `IndexScope`)|type `#` symbol, 0 consumer files|`[high] Stale types` + `stale_type_noise`|**Filtered** — index can't see annotations; document or optional `--types`|
+|`analyze/*` section runners “dead”|no external refs|noise filter in `common.py`|**Filtered** — framework pattern|
+|Unused import|`role=2` mention, no in-file use|`[high] Unused imports` (per file)|**Caught** on file target|
+|Hub before editing (`resolve_symbol`, `queries.py`)|fan-in / consumer count|`[medium] Change surface` / `[low] Hotspots`|**Caught** on file target; project hubs are low tier|
+|Symbol only used from tests|consumers all under `tests/`|`[low] Test-only consumers`|**Partial** — Python index often omits same-file `role=0`; verify with `rg`|
+|Indexer omits same-file Python calls|no `role=0` for in-module use|unreferenced / test-only false positives|**Index gap** — not fixable in SQL alone; demoted test-only to low|
+|Duplicate / parallel helpers|—|—|**Not in index** — `rg`, not analyze|
 
 Add new rows to `dogfood.md` when you find another gap; implement the SQL check before the next manual review pass.
 
@@ -99,15 +102,15 @@ Add new rows to `dogfood.md` when you find another gap; implement the SQL check
 
 SQLite has **line ranges** (`defn_enclosing_ranges`) so LOC is cheap. That does **not** mean “big function” belongs next to dead exports.
 
-| Idea | In index? | Verdict |
-|------|-----------|---------|
-| **LOC ≥ N** alone | Yes | **LOW at best** — noisy (`main`, argparse, legitimate parsers). Not a nuke candidate. |
-| **LOC + fan-in** (large hub) | Yes | **Already covered** by `[low] Bottlenecks` (fan-in × fan-out). Add `loc=` to that output if helpful; don’t duplicate as medium. |
-| **LOC + consumers** on file target | Yes | **Change surface** (medium) already sorts by consumers with line ranges — drill there. |
-| **Symbol pressure** | Yes | **Per-symbol** `analyze Foo` shows `loc × fan_in × fan_out`. |
-| **God class / many members** | Yes | Use `members Class` — not analyze. |
-| **File byte size / cyclomatic complexity** | No | Out of scope for SCIP index. |
-| **Fat file (many symbols)** | Yes | Low value; coupling/hotspots approximate module heat. |
+|Idea|In index?|Verdict|
+|---|---|---|
+|**LOC ≥ N** alone|Yes|**LOW at best** — noisy (`main`, argparse, legitimate parsers). Not a nuke candidate.|
+|**LOC + fan-in** (large hub)|Yes|**Already covered** by `[low] Bottlenecks` (fan-in × fan-out). Add `loc=` to that output if helpful; don’t duplicate as medium.|
+|**LOC + consumers** on file target|Yes|**Change surface** (medium) already sorts by consumers with line ranges — drill there.|
+|**Symbol pressure**|Yes|**Per-symbol** `analyze Foo` shows `loc × fan_in × fan_out`.|
+|**God class / many members**|Yes|Use `members Class` — not analyze.|
+|**File byte size / cyclomatic complexity**|No|Out of scope for SCIP index.|
+|**Fat file (many symbols)**|Yes|Low value; coupling/hotspots approximate module heat.|
 
 **Rule:** size-only checks stay **low or file-drill-down**; never high/medium unless paired with a **structural smell** (cycle, dead export, zero production consumers). Prefer enriching existing low-tier lines (e.g. show `loc` on bottlenecks) over a new dashboard section.
 
@@ -115,33 +118,55 @@ SQLite has **line ranges** (`defn_enclosing_ranges`) so LOC is cheap. That does
 
 The e2e fixture and this repo's own index are **small** — every query looks fast here. That hides blowups on real projects (40MB+ indexes, dense graphs).
 
-**Before merging new or heavily changed SQL** (`queries.py`, `analyze/*`):
-
-1. Time it against **1–2 existing checks** on a **large cached index** you already have (not the fixture):
-   ```bash
-   python3 -u -c "
-   import sqlite3, time, sys
-   from pathlib import Path
-   sys.path.insert(0, '.')
-   from scip_cli.analyze import project as p
-   from scip_cli.sql import configure_read_connection
-   db_path = Path.home() / '.cache/scip-cli/projects/<project-slug>/index.db'
-   db = sqlite3.connect(f'file:{db_path}?mode=ro', uri=True)
-   configure_read_connection(db)
-   for name, fn in [('hotspots', p.hotspots), ('cycles', p.cycles), ('dead_exports', p.dead_exports)]:
-       t = time.perf_counter(); fn(db, limit=25); print(f'{name}: {(time.perf_counter()-t)*1000:.0f}ms')
-   "
-   ```
-2. Flag anything **notably slower** than peers — orders of magnitude or multi-second, not a few ms drift.
-3. Swap in your new/changed check for one of the rows; keep a fast peer (e.g. `hotspots`) and a heavy peer (e.g. `dead_exports`).
-
-**In CI:** `tests/test_e2e_perf.py` (whole commands) and `tests/test_analyze_perf.py` (per-check on mini DB) catch gross regressions on the tiny fixture only — they **will not** catch large-repo OOMs. Use the manual benchmark above for that.
+### Scaled :memory: benchmark (primary)
+
+`tests/bench_db.py` generates a deterministic 1000-file / ~15K-symbol / ~100K-mention DB in `:memory:`. `tests/test_bench_queries.py` times all key queries on it.
+
+**Before/after comparison flow:**
+
+```bash
+# 1. Before changes — save baseline
+scripts/bench.sh --baseline
+
+# 2. Make your SQL/query changes
+
+# 3. Compare — runs current, diffs against baseline
+scripts/bench.sh --compare
+
+# Or just run current without comparison
+scripts/bench.sh
+```
+
+Output per query: `BENCH:<name>:<elapsed_ms>`. The compare table shows ratio (>1.0 = regression, <1.0 = improvement).
+
+**When to use:** Any change to `queries.py`, `analyze/*`, `symbols.py` SQL clauses, or `sql.py` pragmas. Run `scripts/bench.sh --compare` before committing.
+
+### Large cached index benchmark (secondary)
+
+For queries that behave differently on real 40MB+ indexes vs the synthetic DB:
+
+```bash
+python3 -u -c "
+import sqlite3, time, sys
+from pathlib import Path
+sys.path.insert(0, '.')
+from scip_cli.analyze import project as p
+from scip_cli.sql import configure_read_connection
+db_path = Path.home() / '.cache/scip-cli/projects/<project-slug>/index.db'
+db = sqlite3.connect(f'file:{db_path}?mode=ro', uri=True)
+configure_read_connection(db)
+for name, fn in [('hotspots', p.hotspots), ('cycles', p.cycles), ('dead_exports', p.dead_exports)]:
+    t = time.perf_counter(); fn(db, limit=25); print(f'{name}: {(time.perf_counter()-t)*1000:.0f}ms')
+"
+```
+
+**In CI:** `tests/test_e2e_perf.py` (whole commands) and `tests/test_analyze_perf.py` (per-check on mini DB) catch gross regressions on the tiny fixture only — they **will not** catch large-repo OOMs. Use `scripts/bench.sh --compare` for that.
 
 ## TDD
 
 ### Default: extend the shared fixture
 
-**One indexed TS project** — `tests/fixtures/sample-project/` — indexed once per session via `indexed_fixture` (`conftest.py`). Stable names live in `tests/fixture_catalog.py`.
+**One indexed TS project** — `tests/fixtures/typescript-project/` — indexed once per session via `indexed_fixture` (`conftest.py`). Stable names live in `tests/fixture_catalog.py`.
 
 1. **Red** — add a **minimal** `.ts` file (or tweak an existing one) that reproduces the SCIP shape; assert in `tests/test_e2e.py` or `tests/test_e2e_analyze_patterns.py` using `cli` / `open_index_db` + analyze helpers.
 2. **Green** — fix `scip_cli/` (commands, `analyze/*`, `queries.py`, …).
@@ -156,29 +181,29 @@ The e2e fixture and this repo's own index are **small** — every query looks fa
 When dogfooding **another repo** surfaces a bug or false positive (analyze noise, dead-export mistake, cycle, stale type, refs mismatch):
 
 1. **Capture the pattern, not the project** — note the SCIP shape (module `/`, export alias `foo0:`, lazy import, `Props#`, barrel cycle, …). Do **not** copy real repo names, paths, or filenames into tests or docs.
-2. **Red on the fixture** — smallest TS repro under `tests/fixtures/sample-project/` with generic names (`LazyPanel`, `evictItem`, `OrphanWidget`, …). E2e test proves the bug against **real `scip-typescript`** output.
+2. **Red on the fixture** — smallest TS repro under `tests/fixtures/typescript-project/` with generic names (`LazyPanel`, `evictItem`, `OrphanWidget`, …). E2e test proves the bug against **real `scip-typescript`** output.
 3. **Green** — fix analyze heuristics / SQL / CLI; dogfood on this repo if applicable.
 4. **Verify** — `pytest tests/test_e2e_analyze_patterns.py` (or full `pytest`); only then trim redundant tests.
 
 **Prefer fixture e2e over fake SQLite graphs.** `tests/analyze_db.py` (`AnalyzeDbBuilder`, `:memory:`) is for SQL/dashboard **plumbing** and graph primitives (`test_analyze_graph.py`, `mini_codebase_db`) — not for reproducing production SCIP symbol shapes. Hand-built symbols often diverge from scip-typescript (path format, `0:` aliases, module rows) and can pass while production still breaks.
 
-| Use fixture e2e | Use `analyze_db` unit |
-|-----------------|----------------------|
-| False positives / analyze checks from real projects | Tarjan, edge-type SQL, `run_all` section wiring |
-| Any behavior that depends on indexer symbol strings | Noise filters with one or two synthetic rows |
-| CLI commands (`refs`, `search`, `analyze` output) | Merge/index prune tests |
+|Use fixture e2e|Use `analyze_db` unit|
+|---|---|
+|False positives / analyze checks from real projects|Tarjan, edge-type SQL, `run_all` section wiring|
+|Any behavior that depends on indexer symbol strings|Noise filters with one or two synthetic rows|
+|CLI commands (`refs`, `search`, `analyze` output)|Merge/index prune tests|
 
 If both layers help during development, **keep both until e2e passes**, then delete duplicate in-memory repros — fixture is the source of truth.
 
 ## Codebase map (contributors)
 
-| Area | Path | Notes |
-|------|------|-------|
-| Commands | `scip_cli/commands/` | Thin; SQL in `queries.py` / `analyze/` |
-| Index build | `scip_cli/indexing.py` | `index.db.next` → promote; flock; `>10` tsconfigs log progress |
-| Variable prune | postprocess + `merge.py` | Omit const/let/var on **COPY**, not DELETE — no `variable` kind |
-| Session | `scip_cli/session.py` | `setup()`, `resolve_one_symbol` (limit 2 for ambiguity) |
-| Analyze filters | `scip_cli/analyze/common.py` | `is_test_path`, `analyze_noise` (`_` helpers) |
+|Area|Path|Notes|
+|---|---|---|
+|Commands|`scip_cli/commands/`|Thin; SQL in `queries.py` / `analyze/`|
+|Index build|`scip_cli/indexing.py`|`index.db.next` → promote; flock; `>10` tsconfigs log progress|
+|Variable prune|postprocess + `merge.py`|Omit const/let/var on **COPY**, not DELETE — no `variable` kind|
+|Session|`scip_cli/session.py`|`setup()`, `resolve_one_symbol` (limit 2 for ambiguity)|
+|Analyze filters|`scip_cli/analyze/common.py`|`is_test_path`, `analyze_noise` (`_` helpers)|
 
 `todo.md` = tracked work; `dogfood.md` = future ideas only. Wishlist/backlog in `docs/` per workspace rules.
 
@@ -187,3 +212,20 @@ If both layers help during development, **keep both until e2e passes**, then del
 - User install + analyze guide → `README.md`
 - Agent/user CLI reference → `scip_cli/SKILL.md` (must match `__main__.py` flags)
 - After flag changes: update SKILL + README command list; run `scip-cli skill` to verify output
+
+
+## Dogfood Notes
+
+Future improvements from using the CLI on real projects.
+
+### Workflow
+
+Requires bare `scip-cli` mapped to local (`pip install -e ".[dev]"` from repo root).
+
+```bash
+scip-cli reindex
+scip-cli analyze --limit 25
+scip-cli analyze scip_cli/queries.py --limit 20   # drill into hubs
+```
+
+Project-wide analyze skips test paths by default; `--include-tests` to include. See README **Finding easy wins with analyze**.

scip_cli-2.6.0/.github/workflows/ci.yml

@@ -0,0 +1,45 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        id: setup_python
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Restore cached virtualenv
+        uses: actions/cache/restore@v4
+        with:
+          key: venv-${{ runner.os }}-${{ steps.setup_python.outputs.python-version }}-${{ hashFiles('pyproject.toml') }}
+          path: .venv
+
+      - name: Create venv and install dependencies
+        run: |
+          python -m venv .venv
+          source .venv/bin/activate
+          pip install -e ".[dev]"
+          npm install -g @sourcegraph/scip-typescript
+          mkdir -p ~/.local/bin
+          curl -sL https://github.com/scip-code/scip/releases/download/v0.9.0/scip-linux-amd64.tar.gz | tar xz -C ~/.local/bin
+          echo "$VIRTUAL_ENV/bin" >> $GITHUB_PATH
+          echo "VIRTUAL_ENV=$VIRTUAL_ENV" >> $GITHUB_ENV
+
+      - name: Save cached virtualenv
+        uses: actions/cache/save@v4
+        with:
+          key: venv-${{ runner.os }}-${{ steps.setup_python.outputs.python-version }}-${{ hashFiles('pyproject.toml') }}
+          path: .venv
+
+      - name: Run publish gate
+        run: ./scripts/test.sh

{scip_cli-2.4.0 → scip_cli-2.6.0}/.gitignore

@@ -10,8 +10,6 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
-lib64/
 parts/
 sdist/
 var/
@@ -19,6 +17,7 @@ wheels/
 *.egg-info/
 .installed.cfg
 *.egg
+.ruff_cache/
 
 # Virtual environments
 venv/
@@ -51,3 +50,4 @@ dogfood.md
 # Local-only dev scripts (repo-specific smoke harnesses)
 scripts/deep-smoke.sh
 tmp/
+*.db

{scip_cli-2.4.0 → scip_cli-2.6.0}/.pre-commit-config.yaml

@@ -15,5 +15,6 @@ repos:
         name: pytest
         entry: pytest
         language: python
+        additional_dependencies: [pytest>=7]
         pass_filenames: false
         always_run: true

scip_cli-2.6.0/AGENTS.md

@@ -0,0 +1 @@
+.cursor/rules/agent.mdc

{scip_cli-2.4.0 → scip_cli-2.6.0}/CODE_OF_CONDUCT.md

@@ -60,7 +60,7 @@ representative at an online or offline event.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-ariel.flesler@gmail.com.
+aflesler@gmail.com.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the

{scip_cli-2.4.0 → scip_cli-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scip-cli
-Version: 2.4.0
+Version: 2.6.0
 Summary: Fast code intelligence via SCIP indexes
 Project-URL: Homepage, https://github.com/flesler/scip-cli
 Author: Ariel Flesler
@@ -24,7 +24,7 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://badge.fury.io/py/scip-cli.svg)](https://badge.fury.io/py/scip-cli)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Token-efficient code intelligence for AI agents. Precise refs, definitions, and repo health analysis via SCIP indexes — TypeScript/JavaScript and Python.
+Python CLI for AI agents. Queries SCIP indexes for precise refs, definitions, and repo health analysis — TypeScript/JavaScript, Python, Go, Rust.
 
 ## Why
 
@@ -38,6 +38,17 @@ AI agents waste tokens on grep and file scanning. scip-cli gives them precise, t
 - **`analyze`**: Find dead exports, import cycles, stale types, coupling hotspots — actionable health dashboards at project, file, or symbol scope
 - **Auto-indexing**: Indexes on first query, caches in SQLite, zero config
 
+## Ports
+
+CLI/output parity ports of this project (Python is the reference):
+
+| Language           | Repository                                                        |
+| ------------------ | ----------------------------------------------------------------- |
+| Python (reference) | [flesler/scip-cli](https://github.com/flesler/scip-cli)           |
+| Go                 | [flesler/scip-cli-go](https://github.com/flesler/scip-cli-go)     |
+| Rust               | [flesler/scip-cli-rust](https://github.com/flesler/scip-cli-rust) |
+| Zig                | [flesler/scip-cli-zig](https://github.com/flesler/scip-cli-zig)   |
+
 ## For AI Agents
 
 Install as a reusable skill so your agent always knows how to navigate the codebase:
@@ -90,7 +101,7 @@ On **first index**, scip-cli runs language indexers and builds a SQLite cache. Y
 
 Install `scip-cli` and run it. On first index, scip-cli will:
 
-- Download `scip-typescript` / `scip-python` via `npx` when not already on PATH
+- Download `scip-typescript` / `scip-python` via `npx`, `scip-go` via `go install`, or `rust-analyzer` via `rustup` when not already on PATH
 - Download the `scip` converter binary from [GitHub releases](https://github.com/scip-code/scip/releases) into `~/.cache/scip-cli/bin/` when not already on PATH
 - Walk the repo for `tsconfig*.json` project roots (TypeScript monorepos), run `scip-typescript` per project (parallel by default), convert each partial index, then merge into one `index.db`
 
@@ -107,6 +118,12 @@ npm install -g @sourcegraph/scip-typescript
 # Python indexer
 npm install -g @sourcegraph/scip-python
 
+# Go indexer
+go install github.com/scip-code/scip-go/cmd/scip-go@latest
+
+# Rust indexer (rust-analyzer with SCIP support)
+rustup component add rust-analyzer
+
 # SCIP CLI for index conversion (GitHub release — not on npm)
 # https://github.com/scip-code/scip/releases  (v0.8.1+ recommended)
 ```
@@ -200,9 +217,9 @@ scip-cli deps greet --paths-only | sort -u
 
 ## How It Works
 
-1. On first query, automatically detects project language from `package.json` (TS/JS) or `pyproject.toml`/`setup.py` (Python)
+1. On first query, automatically detects project language from `package.json` (TS/JS), `pyproject.toml`/`setup.py` (Python), `go.mod` (Go), or `Cargo.toml` (Rust)
 2. For TypeScript monorepos, walks the repository for `tsconfig*.json` project roots (nested ancestors deduped; root included only when its `include` is broad)
-3. Runs `scip-typescript` per project (in parallel when there are multiple projects; set `SCIP_CLI_INDEX_WORKERS=1` to force serial), or `scip-python` for Python
+3. Runs `scip-typescript` per project (in parallel when there are multiple projects; set `SCIP_CLI_INDEX_WORKERS=1` to force serial), `scip-python` for Python, `scip-go` for Go, or `rust-analyzer scip` for Rust
 4. Converts each SCIP output to SQLite with `scip expt-convert`, then merges partial databases when needed
 5. Caches the result in `~/.cache/scip-cli/projects/<dirname>-<hash>/index.db` (e.g. `my-monorepo-1a3f7a`)
 6. Subsequent queries are SQLite lookups against that cache (not re-indexing)
@@ -219,11 +236,23 @@ Optional `.scip-cli.json` in the project root:
 }
 ```
 
-- `maxHeapMb` — Node heap for `scip-typescript` / `scip-python` (default **8192 MB** when omitted). Overridden by `SCIP_CLI_MAX_HEAP_MB`. This is the V8 heap cap, not total RAM usage.
+- `maxHeapMb` — Node heap for `scip-typescript` / `scip-python` (default **8192 MB** when omitted). Overridden by `SCIP_CLI_MAX_HEAP_MB`. This is the V8 heap cap, not total RAM usage. Does not affect `scip-go`.
 - `indexRoots` — extra TypeScript project directories to include on **first index**, merged with auto-discovered projects.
 - `onlyIndexRoots` — skip auto-discovery and index **only** `indexRoots` (smaller initial index when you only care about part of a monorepo).
 
-`SCIP_CLI_INDEX_WORKERS` controls parallel `scip-typescript` runs during first index (default: up to 8). Merge into one database is always serial.
+`SCIP_CLI_INDEX_WORKERS` controls parallel indexer runs during first index (default: up to 8). Merge into one database is always serial.
+
+Other environment variables:
+
+| Variable                       | Purpose                                                                                       |
+| ------------------------------ | --------------------------------------------------------------------------------------------- |
+| `SCIP_CLI_MAX_HEAP_MB`         | Node heap for `scip-typescript` / `scip-python` (overrides `maxHeapMb` in config)             |
+| `SCIP_CLI_TS_INDEX_BATCH_SIZE` | Split large TS repos into multiple `scip-typescript` runs (default: all tsconfigs in one run) |
+| `SCIP_CLI_MERGE_BATCH_SIZE`    | SQLite ATTACH batch size when merging part DBs (max 9)                                        |
+| `SCIP_CLI_MAX_DEF_LINES`       | Max definition lines in `code` output                                                         |
+| `SCIP_CLI_DEBUG`               | Log SQL queries to stderr                                                                     |
+
+**Version policy:** only the `scip` converter (`expt-convert`) is pinned to the 0.8.x release line because it defines the SQLite schema. Language indexers (`scip-typescript`, `scip-python` via `npx`; `scip-go` via `go install @latest`) install at latest on first use. `rust-analyzer` installs via `rustup component add`.
 
 Large monorepos (>10 tsconfig projects) log per-project progress to stderr during indexing; smaller repos stay quiet aside from the final `Indexed … (size)` line.
 
@@ -232,9 +261,13 @@ Scoped indexing without editing `.scip-cli.json`:
 ```bash
 scip-cli reindex --path packages/server
 scip-cli reindex --path packages/api --path packages/worker
+scip-cli reindex --tsconfig 'apps/api/tsconfig.*.json'
+scip-cli reindex --tsconfig tsconfig.app.json --tsconfig tsconfig.spec.json
 ```
 
-`--path` limits which discovered tsconfig projects are indexed (prefix match, same idea as query `--path`). The scope is saved as `index-scope.json` next to `index.db` and reused until you run a full `scip-cli reindex` with no `--path`.
+`--path` limits which discovered tsconfig **directories** are indexed (prefix match, same idea as query `--path`). `--tsconfig` skips discovery and indexes those `tsconfig*.json` **files** (repeatable; globs are expanded inside the tool). File-based runs default to one `scip-typescript` process per file so each gets its own heap (`SCIP_CLI_TS_INDEX_BATCH_SIZE` still overrides). Cannot combine `--path` and `--tsconfig`. **TypeScript only.** The scope is saved as `index-scope.json` next to `index.db` and reused until you run a full `scip-cli reindex` with no `--path`/`--tsconfig`.
+
+When a tsconfig (after `extends`) has `allowJs: true`, matching `.js`/`.jsx` files under that config's `include`/`files` are indexed too (same roots as `.ts`/`.tsx`). `allowJs: false` or unset leaves JavaScript out. JS-only repos with no `tsconfig.json` still use `--infer-tsconfig`.
 
 Run `scip-cli reindex` after changing scope, `.scip-cli.json` index settings, or when you want a fresh index.
 
@@ -251,24 +284,24 @@ scip-cli analyze --priority high --limit 25   # dead exports & cycles only
 
 Sections are tagged `[high]`, `[medium]`, `[low]` and listed in that order.
 
-| Tier | Project sections | Action |
-| ---- | ---------------- | ------ |
-| **high** | Cycles, unreferenced, dead exports, stale types | Nuke or fix cycles; delete unused; `_` prefix |
-| **medium** | Same-file only, change surface (file target) | Module-private by usage |
-| **low** | Test-only consumers, coupling, bottlenecks, hotspots | Noisy on Python (index omits many same-file calls); verify with `rg` |
+| Tier       | Project sections                                     | Action                                                               |
+| ---------- | ---------------------------------------------------- | -------------------------------------------------------------------- |
+| **high**   | Cycles, unreferenced, dead exports, stale types      | Nuke or fix cycles; delete unused; `_` prefix                        |
+| **medium** | Same-file only, change surface (file target)         | Module-private by usage                                              |
+| **low**    | Test-only consumers, coupling, bottlenecks, hotspots | Noisy on Python (index omits many same-file calls); verify with `rg` |
 
 Use `--priority high` for a quick gate; `--priority high,medium` adds context. File drill-down adds change surface and unused imports.
 
 **What to look at first**
 
-| Section | Easy pickings |
-| ------- | ------------- |
-| **Cycles** | Import/mention cycles between production files — break the edge or extract shared code |
-| **Unreferenced** | No usage in the index at all — delete |
-| **Dead exports** | No external refs — delete or `_` prefix |
-| **Stale types** | Classes/types with no external consumer in the index — verify in-file or type-only use before removing |
-| **Same-file only** | Used only inside defining file — rename to `_` |
-| **Test-only consumers** | Cross-file refs are all from tests — promote to e2e or accept as internal |
+| Section                 | Easy pickings                                                                                          |
+| ----------------------- | ------------------------------------------------------------------------------------------------------ |
+| **Cycles**              | Import/mention cycles between production files — break the edge or extract shared code                 |
+| **Unreferenced**        | No usage in the index at all — delete                                                                  |
+| **Dead exports**        | No external refs — delete or `_` prefix                                                                |
+| **Stale types**         | Classes/types with no external consumer in the index — verify in-file or type-only use before removing |
+| **Same-file only**      | Used only inside defining file — rename to `_`                                                         |
+| **Test-only consumers** | Cross-file refs are all from tests — promote to e2e or accept as internal                              |
 
 **Per-file or package drill-down** on hubs or suspects:
 
@@ -277,7 +310,7 @@ scip-cli analyze scip_cli/queries.py --limit 20   # file: scoped project + per-f
 scip-cli analyze scip_cli --limit 15              # directory: scoped project + each file under it
 ```
 
-`Dead exports in file` lists same-module symbols with no *external* refs — module-private `_helpers` are filtered out. Remaining rows are worth a manual `rg` check.
+`Dead exports in file` lists same-module symbols with no _external_ refs — module-private `_helpers` are filtered out. Remaining rows are worth a manual `rg` check.
 
 **Defaults:** project-wide and directory analyze skip `tests/`, `*.test.*`, `*.spec.*`, `conftest.py`, and `__tests__/`. Pass `--include-tests` to include them. File-target analyze always includes that file.
 
@@ -329,7 +362,7 @@ scip_cli/
 ```bash
 pip install -e ".[dev]"
 pytest tests/ -q
-pytest tests/ -m integration -q   # indexes tests/fixtures/sample-project (needs scip-typescript)
+pytest tests/ -m integration -q   # indexes tests/fixtures/typescript-project (needs scip-typescript)
 ```
 
 ### Debug Logging