cg-code-graph 0.15.0__tar.gz → 0.17.0__tar.gz

cg_code_graph-0.17.0/MANIFEST.in

@@ -0,0 +1,8 @@
+graft cg_code_graph
+prune cg_code_graph/plugins/ts/extractor/node_modules
+prune cg_code_graph/plugins/php/extractor/vendor
+prune cg_code_graph/plugins/dart/extractor/.bin
+prune cg_code_graph/plugins/dart/extractor/.dart_tool
+prune cg_code_graph/viz/tools/node_modules
+prune cg_code_graph/viz/tools/screenshots
+global-exclude __pycache__ *.py[cod] *.db *.db-wal *.db-shm

{cg_code_graph-0.15.0/cg_code_graph.egg-info → cg_code_graph-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.15.0
+Version: 0.17.0
 Summary: cg: a code graph of routes, calls, data access and platform boundaries for agents and humans (CLI + MCP server)
 Author: cyberchronos00
 License-Expression: MIT
@@ -45,6 +45,7 @@ For you and your AI agent (CLI + MCP). No LLM in the graph.
 ```bash
 pipx install cg-code-graph          # or: uv tool install cg-code-graph
 cg index . --db out/graph.db        # prints starter queries for your repo
+cg install --host cursor    # or claude, codex, vscode, …: registers the MCP server
 cg reaches table:orders --db out/graph.db   # any table, connection or config key
 ```
 

{cg_code_graph-0.15.0 → cg_code_graph-0.17.0}/README.md

@@ -19,6 +19,7 @@ For you and your AI agent (CLI + MCP). No LLM in the graph.
 ```bash
 pipx install cg-code-graph          # or: uv tool install cg-code-graph
 cg index . --db out/graph.db        # prints starter queries for your repo
+cg install --host cursor    # or claude, codex, vscode, …: registers the MCP server
 cg reaches table:orders --db out/graph.db   # any table, connection or config key
 ```
 

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/__init__.py

@@ -1,2 +1,2 @@
 """code-graph: deterministic code knowledge graph (beta)."""
-__version__ = "0.15.0"
+__version__ = "0.17.0"

cg_code_graph-0.17.0/cg_code_graph/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/agent_rules.py

@@ -53,7 +53,7 @@ def document() -> str:
 
 
 def pin() -> str:
-    """Published package floor: ``cg-code-graph>=MAJOR.MINOR`` from ``codegraph.__version__``."""
+    """Published package floor: ``cg-code-graph>=MAJOR.MINOR`` from ``cg_code_graph.__version__``."""
     import re
 
     from . import __version__

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/agents.py

@@ -2,11 +2,10 @@
 project's AGENTS.md / CLAUDE.md / Cursor rules. It only ever writes a clearly marked block and
 never writes silently: every run previews the exact changes and asks before writing (--dry-run
 previews without writing, --yes skips the prompt). Re-running replaces the block in place; remove
-deletes it and restores the surrounding bytes. MCP changes touch only the `cg` server entry."""
+deletes it and restores the surrounding bytes. MCP changes affect only the `cg` server entry."""
 from __future__ import annotations
 
 import difflib
-import json
 import re
 from pathlib import Path
 
@@ -62,33 +61,11 @@ def plan_text(path: Path, remove: bool, body: str | None = None) -> dict:
 
 def plan_mcp(path: Path, remove: bool) -> dict:
     """Add / update / remove only the `cg` entry under mcpServers; every other entry and key is
-    kept. Returns action noop when there is nothing to change, or error when the file is not JSON."""
-    old = path.read_text(encoding="utf-8") if path.exists() else ""
-    if old.strip():
-        try:
-            data = json.loads(old)
-        except ValueError as ex:
-            return {"path": str(path), "kind": "mcp", "action": "error", "old": old, "new": old,
-                    "error": f"not valid JSON ({ex}); left unchanged"}
-    else:
-        data = {}
-    if not isinstance(data, dict):
-        return {"path": str(path), "kind": "mcp", "action": "error", "old": old, "new": old,
-                "error": "top level is not a JSON object; left unchanged"}
-    servers = data.get("mcpServers")
-    if not isinstance(servers, dict):
-        servers = {}
-    if remove:
-        if "cg" not in servers:
-            return {"path": str(path), "kind": "mcp", "action": "noop", "old": old, "new": old}
-        servers = {k: v for k, v in servers.items() if k != "cg"}
-        action = "remove"
-    else:
-        action = "update" if "cg" in servers else "insert"
-        servers = {**servers, "cg": MCP_ENTRY}
-    data = {**data, "mcpServers": servers}
-    new = json.dumps(data, indent=2) + "\n"
-    return {"path": str(path), "kind": "mcp", "action": action, "old": old, "new": new}
+    kept. The edit affects only that member's text. Returns action noop when there is nothing to
+    change, or error when the file is not JSON."""
+    from .mcp_install import plan_file
+    return plan_file(path, kind="json", path_keys=["mcpServers"], entry=None if remove else MCP_ENTRY,
+                     remove=remove, delete_empty=False)
 
 
 def preview(plan: dict) -> str:
@@ -96,8 +73,11 @@ def preview(plan: dict) -> str:
     if plan["action"] == "noop" and plan.get("current"):
         return f"{plan['path']}: no change (block up to date)"
     if plan["action"] == "noop":
-        return f"{plan['path']}: no change (block not present)" if plan["kind"] == "text" \
-            else f"{plan['path']}: no change (no cg entry)"
+        if plan["kind"] == "text":
+            return f"{plan['path']}: no change (block not present)"
+        if plan.get("registered"):
+            return f"{plan['path']}: no change (cg already registered)"
+        return f"{plan['path']}: no change (no cg entry)"
     if plan["action"] == "error":
         return f"{plan['path']}: {plan['error']}"
     diff = difflib.unified_diff(plan["old"].splitlines(True), plan["new"].splitlines(True),

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/blindspots.py

@@ -34,7 +34,7 @@ KINDS = {
     "nuxt_unevaluable_import_dirs": ("handler", "typescript",
                                      "Nuxt imports.dirs entry that is not a literal path or glob"),
     "vue_unresolved_navigation": ("route", "typescript",
-                                  "Nuxt / Vue navigation target that matches no page or several pages"),
+                                  "Nuxt / Vue / Astro navigation target that matches no page or several pages"),
 }
 
 

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/bridges.py

@@ -16,7 +16,7 @@ It is modelled with the protocol endpoint model of #31 (epic #29), so the bridge
                 (android/ ios/ macos/ directories, else Kotlin / Java = android, Swift / ObjC = ios), so `--platform ios`
                 drops the Android receivers and `impact` / `reaches` cross the bridge in both directions
 
-The send side comes from the language plugins (TypeScript extractor facts, codegraph/plugins/dart/bridges.py); the
+The send side comes from the language plugins (TypeScript extractor facts, cg_code_graph/plugins/dart/bridges.py); the
 receive side is a source-text pass over the native files run here, after the language plugins (Java and ObjC have no
 language plugin: their receivers become stub method nodes with attrs.bridge_stub). `finalize` then records per
 endpoint which platforms receive it and the checks: missing_on (sent, received on some mobile targets of the project

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/cli.py

@@ -1,25 +1,25 @@
 """code-graph CLI.
 
-  python -m codegraph.cli index   <project_root> --db out/x.db [--scip index.scip] [--gates config/x.gates.json]
-  python -m codegraph.cli reaches <spec>... --db out/x.db [--min-confidence resolved] [--json] [--no-paths]
-  python -m codegraph.cli siblings <symbol> --db ...
-  python -m codegraph.cli writers <table> --db ...
-  python -m codegraph.cli impact <Class::method> --db ...
-  python -m codegraph.cli stats --db ...
-  python -m codegraph.cli detect <project_root>
-  python -m codegraph.cli link --backend out/api.db --frontend out/web.db --db out/combined.db [--report out/x]
-  python -m codegraph.cli downstream <spec> --db out/combined.db        (forward: page -> ... -> routes/tables)
-  python -m codegraph.cli api-calls <all|unmatched|substring|glob*> --db out/combined.db
-  python -m codegraph.cli plan list|load|validate|check|baseline [<name>] --db out/combined.db [--verify] [--summary] [--json]
-  python -m codegraph.cli routes --db ... [--writes [TABLE]] [--reaches SPEC...] [--missing NAME] [--unguarded]
-  python -m codegraph.cli search <name> --db ... [--kind route]
-  python -m codegraph.cli channels [PATTERN] --db ...   (who can join, which events publish, which client code listens)
-  python -m codegraph.cli tests <spec> --db ...          (tests covering a symbol / route / table: direct + transitive)
-  python -m codegraph.cli bridges [PATTERN] --db ... [--protocol capacitor] [--unmatched]   (web / native bridge calls)
-  python -m codegraph.cli external [PATTERN] --db ... [--protocol P] [--source S] [--tls-off]   (databases, caches, brokers, mail ... and who reaches them)
-  python -m codegraph.cli tools [PATTERN] --db ... [--framework F] [--agent A] [--unmatched]   (LLM / MCP tools: handler, tables, agents, checks)
-  python -m codegraph.cli protocols [PATTERN] --db ... [--protocol P] [--side send|receive] [--unmatched] [--listeners]   (every protocol endpoint: senders, receivers, checks; listening sockets)
-  python -m codegraph.cli platforms [summary|divergence] --db ... [--target ios]   (platform-specific code, gaps between variants)
+  python -m cg_code_graph.cli index   <project_root> --db out/x.db [--scip index.scip] [--gates config/x.gates.json]
+  python -m cg_code_graph.cli reaches <spec>... --db out/x.db [--min-confidence resolved] [--json] [--no-paths]
+  python -m cg_code_graph.cli siblings <symbol> --db ...
+  python -m cg_code_graph.cli writers <table> --db ...
+  python -m cg_code_graph.cli impact <Class::method> --db ...
+  python -m cg_code_graph.cli stats --db ...
+  python -m cg_code_graph.cli detect <project_root>
+  python -m cg_code_graph.cli link --backend out/api.db --frontend out/web.db --db out/combined.db [--report out/x]
+  python -m cg_code_graph.cli downstream <spec> --db out/combined.db        (forward: page -> ... -> routes/tables)
+  python -m cg_code_graph.cli api-calls <all|unmatched|substring|glob*> --db out/combined.db
+  python -m cg_code_graph.cli plan list|load|validate|check|baseline [<name>] --db out/combined.db [--verify] [--summary] [--json]
+  python -m cg_code_graph.cli routes --db ... [--writes [TABLE]] [--reaches SPEC...] [--missing NAME] [--unguarded]
+  python -m cg_code_graph.cli search <name> --db ... [--kind route]
+  python -m cg_code_graph.cli channels [PATTERN] --db ...   (who can join, which events publish, which client code listens)
+  python -m cg_code_graph.cli tests <spec> --db ...          (tests covering a symbol / route / table: direct + transitive)
+  python -m cg_code_graph.cli bridges [PATTERN] --db ... [--protocol capacitor] [--unmatched]   (web / native bridge calls)
+  python -m cg_code_graph.cli external [PATTERN] --db ... [--protocol P] [--source S] [--tls-off]   (databases, caches, brokers, mail ... and who reaches them)
+  python -m cg_code_graph.cli tools [PATTERN] --db ... [--framework F] [--agent A] [--unmatched]   (LLM / MCP tools: handler, tables, agents, checks)
+  python -m cg_code_graph.cli protocols [PATTERN] --db ... [--protocol P] [--side send|receive] [--unmatched] [--listeners]   (every protocol endpoint: senders, receivers, checks; listening sockets)
+  python -m cg_code_graph.cli platforms [summary|divergence] --db ... [--target ios]   (platform-specific code, gaps between variants)
   reaches / impact / downstream / path / routes / search take --platform TARGET: only code built for that target
 spec forms: table.column | connection:<name> (glob *) | env:<KEY*> | config:<a.b> | Class.method or Class::method (either
   separator, every language) | Class
@@ -54,6 +54,27 @@ def _parse_repo(spec: str) -> tuple[str, str, str]:
     return name, rest, role
 
 
+def _add_install_parser(sub, uninstall: bool):
+    from .mcp_install import HOSTS
+    name = "uninstall" if uninstall else "install"
+    help_ = ("remove the cg MCP server entry from a host config" if uninstall else
+             "register the cg MCP server (key cg) in a host config; previews and asks first")
+    p = sub.add_parser(name, help=help_)
+    p.add_argument("--host", action="append", choices=[*HOSTS, "all"],
+                   help="MCP host (repeatable). Default: hosts already present for this scope")
+    g = p.add_mutually_exclusive_group()
+    g.add_argument("--project", action="store_true", help="project config (default)")
+    g.add_argument("--global", dest="glob", action="store_true", help="user / global config (needs --db)")
+    p.add_argument("--dir", default=".", help="project root (default: current directory)")
+    p.add_argument("--db", help="graph DB. Default for --project: <dir>/out/graph.db. Required for --global")
+    p.add_argument("--tools", help="tool allowlist written as --tools (CG_MCP_TOOLS grammar)")
+    p.add_argument("--portable", action="store_true",
+                   help="write command cg-mcp and --db out/graph.db (for a config committed to git)")
+    p.add_argument("--uninstall", action="store_true", help="remove the entry instead of writing it")
+    p.add_argument("--dry-run", action="store_true", help="print the exact changes and write nothing")
+    p.add_argument("--yes", action="store_true", help="skip the confirmation prompt")
+
+
 def main(argv=None):
     from . import __version__
     ap = argparse.ArgumentParser(prog="cg")
@@ -259,6 +280,8 @@ def main(argv=None):
     p.add_argument("--mcp-file", help="MCP config path (default: <dir>/.cursor/mcp.json)")
     p.add_argument("--dry-run", action="store_true", help="print the exact changes and write nothing")
     p.add_argument("--yes", action="store_true", help="skip the confirmation prompt")
+    _add_install_parser(sub, uninstall=False)
+    _add_install_parser(sub, uninstall=True)
     p = sub.add_parser("hooks", help="opt-in: git hooks that refresh the index in the background after commit, checkout and merge")
     p.add_argument("action", choices=["install", "uninstall", "status"])
     p.add_argument("--dir", default=".", help="project root (default: current directory)")
@@ -347,6 +370,10 @@ def main(argv=None):
         except C.CacheError as ex:
             print(f"cg clean: {ex}", file=sys.stderr)
             return 2
+        old = C.legacy_root()
+        if old is not None:
+            print(f"note: the old cache {old} still exists ({C.human(C._size(old))}); "
+                  "delete it when you no longer need it", file=sys.stderr)
         errors = [] if a.dry_run else C.execute(pl)
         if a.json:
             print(json.dumps({"root": str(pl.root), "dry_run": a.dry_run, "bytes": pl.bytes, "projects": pl.projects,
@@ -442,6 +469,11 @@ def main(argv=None):
         from . import agents as AG
         return AG.run(a.action, root=a.dir, targets=a.target, all_targets=a.all, mcp=a.mcp,
                       mcp_file=a.mcp_file, dry_run=a.dry_run, assume_yes=a.yes)
+    if a.cmd in ("install", "uninstall"):
+        from .mcp_install import run as run_install
+        return run_install(a.host, scope="global" if a.glob else "project", root=a.dir, db=a.db,
+                           tools=a.tools, portable=a.portable, remove=a.cmd == "uninstall" or a.uninstall,
+                           dry_run=a.dry_run, assume_yes=a.yes)
     if a.cmd == "hooks":
         from . import hooks as HK
         return HK.run(a.action, root=a.dir, db=a.db, dry_run=a.dry_run, assume_yes=a.yes)

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/config.py

@@ -60,7 +60,7 @@ APP_ROLES = ("backend", "frontend")
 KNOWN_KEYS = set(SCHEMA)
 PYTHON_KEYS = SCHEMA["python"]
 VIZ_MODES = ("reaches", "impact", "downstream", "path", "plan")
-# framework plugins of codegraph/indexer.py FRAMEWORK_PLUGINS (frameworks.add / remove also take preset names)
+# framework plugins of cg_code_graph/indexer.py FRAMEWORK_PLUGINS (frameworks.add / remove also take preset names)
 FRAMEWORK_PLUGIN_NAMES = ("laravel", "nuxt", "django", "fastapi", "flask", "flutter", "nest", "nextjs", "express", "astro")
 
 
@@ -371,7 +371,7 @@ def app_pairs(apps: list[dict]) -> list[tuple[dict, dict]]:
 
 def rust_targets(v, where: str) -> str:
     """`rust.targets`: extra rust-analyzer runs per target (#56). `auto` (default), `off` / false, or a list of
-    platforms / target triples; returned in the CODEGRAPH_RUST_TARGETS form."""
+    platforms / target triples; returned in the CG_RUST_TARGETS form."""
     if v is False or (isinstance(v, str) and v.strip().lower() in ("off", "none", "0", "false")):
         return "off"
     if isinstance(v, str) and v.strip().lower() == "auto":
@@ -466,7 +466,7 @@ def effective(root: str | Path, python_roots: list[str] | None = None, gates: st
         row("frameworks", f, f"{fname} frameworks.add" if how == ".cg.yaml" else "detected")
     for f in plan["removed"]:
         row("frameworks", f"{f} (removed)", f"{fname} frameworks.remove")
-    row("presets", plan["presets"], "built-in (codegraph/presets), picked by detection")
+    row("presets", plan["presets"], "built-in (cg_code_graph/presets), picked by detection")
     if python_roots:
         row("python.source_roots", [norm_root(r, "--python-root") for r in python_roots], "flag --python-root")
     elif (cfg.get("python") or {}).get("source_roots"):

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/core/cache.py

@@ -1,8 +1,10 @@
 """The per-user cache: where it lives, what is in it, and `cg clean`.
 
 Root (one lookup for every user: extractors, SCIP outputs, parse caches, the Swift build directory):
-$CODEGRAPH_CACHE, else $CODEGRAPH_CACHE_DIR (older name, still read), else %LOCALAPPDATA%\\codegraph on Windows, else
-$XDG_CACHE_HOME/codegraph, else ~/.cache/codegraph.
+$CG_CACHE (older names still work through 0.17.x; see core/env.py), else
+%LOCALAPPDATA%\\cg on Windows, else $XDG_CACHE_HOME/cg, else ~/.cache/cg. The first use of that
+default moves a leftover `codegraph` directory to `cg` and drops `swift-build/` (SwiftPM build
+directories embed absolute paths). An explicit cache path is used as given and is not moved.
 
 Layout below the root (`v<N>` is fsutil.CACHE_VERSION, `<rkey>` the first 12 hex digits of sha256 of the resolved
 project root):
@@ -26,11 +28,17 @@ import hashlib
 import os
 import re
 import shutil
+import sys
 import time
 from dataclasses import dataclass, field
+import pathlib
 from pathlib import Path
 
-from . import fsutil
+from . import env, fsutil
+
+# The concrete class for this process. pathlib.Path follows os.name at each call, so a test
+# that sets os.name to "nt" on another platform cannot construct Path(); this class still can.
+_Path = pathlib.WindowsPath if os.name == "nt" else pathlib.PosixPath
 
 try:
     import fcntl
@@ -45,14 +53,106 @@ class CacheError(Exception):
     pass
 
 
-def root() -> Path:
-    """The cache root (not created)."""
-    env = os.environ.get("CODEGRAPH_CACHE") or os.environ.get("CODEGRAPH_CACHE_DIR")
-    if env:
-        return Path(env).expanduser()
+_migrated = False
+_legacy_failure: str | None = None
+
+
+def _default_root() -> Path:
+    """The cache root when no cache override is set (not created)."""
     if os.name == "nt" and os.environ.get("LOCALAPPDATA"):
-        return Path(os.environ["LOCALAPPDATA"]) / "codegraph"
-    return Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache") / "codegraph"
+        return _Path(os.environ["LOCALAPPDATA"]) / "cg"
+    return _Path(os.environ.get("XDG_CACHE_HOME") or _Path.home() / ".cache") / "cg"
+
+
+def _legacy_path(new: Path) -> Path:
+    """`<parent>/codegraph`. A root with an empty final component cannot use `with_name`."""
+    try:
+        return new.with_name("codegraph")
+    except ValueError:
+        return new.parent / "codegraph"
+
+
+def _seen(path: Path, *, directory: bool) -> bool | None:
+    """True or False, or None when the path cannot be stat'ed (unreadable parent)."""
+    try:
+        return path.is_dir() if directory else path.exists()
+    except OSError:
+        return None
+
+
+def _remember_move_failure(legacy: Path, new: Path, ex: object) -> None:
+    """Leave a fresh `new` when the move did not happen, and a note for `cg doctor`."""
+    global _legacy_failure
+    try:
+        new.mkdir(parents=True, exist_ok=True)
+    except OSError:
+        pass
+    _legacy_failure = f"could not move {legacy} to {new} ({ex})"
+
+
+def _migrate_legacy(new: Path) -> None:
+    """Move `<parent>/codegraph` to `new` once per process. No override is in effect.
+
+    A target that already exists is left as it is. An unreadable legacy directory, or a
+    rename that loses a race to another process, does not clobber `new` and does not raise.
+    The one status line goes to stderr.
+    """
+    global _migrated
+    if _migrated:
+        return
+    _migrated = True
+    legacy = _legacy_path(new)
+    legacy_is_dir = _seen(legacy, directory=True)
+    new_exists = _seen(new, directory=False)
+    if new_exists:
+        return
+    if legacy_is_dir is None or new_exists is None:
+        _remember_move_failure(legacy, new, "unreadable")
+        return
+    if not legacy_is_dir:
+        return
+    try:
+        os.rename(legacy, new)
+    except OSError as ex:
+        if _seen(new, directory=False):
+            return
+        _remember_move_failure(legacy, new, ex)
+        return
+    print(f"cg: moved the cache {legacy} -> {new}", file=sys.stderr)
+    shutil.rmtree(new / "swift-build", ignore_errors=True)
+
+
+def root() -> Path:
+    """The cache root (not created, except when a failed move leaves a fresh directory)."""
+    override = env.get("CACHE")
+    if override:
+        return _Path(override).expanduser()
+    new = _default_root()
+    _migrate_legacy(new)
+    return new
+
+
+def legacy_root() -> Path | None:
+    """The previous `codegraph` cache directory, when it is still there."""
+    legacy = _legacy_path(_default_root())
+    try:
+        return legacy if legacy.is_dir() else None
+    except OSError:
+        return None
+
+
+def legacy_note() -> str | None:
+    """Why the automatic move did not happen, when `root` tried and failed."""
+    return _legacy_failure
+
+
+def legacy_report() -> dict | None:
+    """Path, size and move-failure note for doctor, or None when there is nothing to say."""
+    path = legacy_root()
+    note = legacy_note()
+    if path is None and not note:
+        return None
+    return {"path": str(path) if path else None, "size": _size(path) if path else 0, "note": note}
 
 
 def subdir(name: str, create: bool = False) -> Path:
@@ -96,8 +196,8 @@ def check_root(r: Path | None = None) -> Path:
         raise CacheError(f"cannot resolve the cache root {r}: {e}")
     home = Path.home().resolve()
     if rr == Path(rr.anchor) or rr == home or rr in home.parents:
-        raise CacheError(f"refusing to clean: the cache root resolves to {rr} (set CODEGRAPH_CACHE to a directory of "
-                         "its own, e.g. ~/.cache/codegraph)")
+        raise CacheError(f"refusing to clean: the cache root resolves to {rr} (set CG_CACHE to a directory of "
+                         "its own, e.g. ~/.cache/cg)")
     return rr
 
 
@@ -139,7 +239,7 @@ def _size(p: Path) -> int:
 
 
 def _tmp_age_limit() -> float:
-    return float(os.environ.get("CODEGRAPH_INDEXER_TIMEOUT", "3600")) + 600
+    return float(env.get("INDEXER_TIMEOUT", "3600")) + 600
 
 
 def entries(r: Path | None = None) -> list[Entry]:
@@ -195,11 +295,16 @@ def entries(r: Path | None = None) -> list[Entry]:
                     e.rkey, e.stale = n[:12], "name from an older cache layout (no cache version)"
             elif name == "swift-build":
                 e.swift_key = n
-                try:
-                    import json
-                    v = json.loads((p / "codegraph-stamp.json").read_text()).get("cache_version")
-                except (OSError, ValueError, AttributeError):
-                    v = None
+                import json
+                v = None
+                for stamp_name in ("cg-stamp.json", "codegraph-stamp.json"):
+                    try:
+                        parsed = json.loads((p / stamp_name).read_text())
+                    except (OSError, ValueError, AttributeError):
+                        continue
+                    if isinstance(parsed, dict) and parsed.get("cache_version") is not None:
+                        v = parsed.get("cache_version")
+                        break
                 if v is not None and v != cur:
                     e.stale = f"cache version {v} (current {cur})"
             elif name == "projects":

cg_code_graph-0.17.0/cg_code_graph/core/env.py

@@ -0,0 +1,83 @@
+"""Process environment: ``CG_*`` names, with ``CODEGRAPH_*`` aliases through 0.17.x.
+
+``get`` reads ``os.environ`` on every call. A legacy name that is set produces one stderr
+warning per name per process. ``CG_*`` wins when both are set. ``MCP_TOOLS`` has no legacy
+name (``CODEGRAPH_MCP_TOOLS`` belongs to another project).
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+# Suffixes this project reads. ``CACHE`` also accepts the older ``CODEGRAPH_CACHE_DIR``.
+SUFFIXES = (
+    "CACHE", "CACHE_DIR", "CARGO", "CFAMILY", "COMPDB", "C_MASK_ANNOTATIONS", "C_MAX_MACRO_REFS",
+    "C_SCIP", "C_SCIP_FILE", "EXCLUDE_DIRS", "INCLUDE_DIRS", "INDEXER_TIMEOUT", "JOBS",
+    "KOTLIN_SCIP", "KOTLIN_SCIP_FILE", "LIBINDEXSTORE", "MAX_FILE_BYTES", "NODE", "NO_CACHE",
+    "NO_CARGO", "NO_HOOKS", "NO_STALE_CHECK", "RUST_ANALYZER", "RUST_BUILD_SCRIPTS", "RUST_SCIP",
+    "RUST_SCIP_FILE", "RUST_TARGETS", "SCIP_CLANG", "SCIP_JAVA", "SWIFT", "SWIFT_INDEX",
+    "SWIFT_INDEX_STORE",
+)
+LEGACY = {"CACHE": ("CODEGRAPH_CACHE", "CODEGRAPH_CACHE_DIR")}
+_NO_LEGACY = frozenset({"MCP_TOOLS"})
+_warned: set[str] = set()
+
+
+def _legacy_names(name: str) -> tuple[str, ...]:
+    if name in _NO_LEGACY:
+        return ()
+    return LEGACY.get(name, ("CODEGRAPH_" + name,))
+
+
+def _warn(old: str, new: str, *, both: bool) -> None:
+    if old in _warned:
+        return
+    _warned.add(old)
+    if both:
+        extra = f"{new} is set too and wins; the CODEGRAPH_* names are removed in 0.18.0"
+    else:
+        extra = "the CODEGRAPH_* names are removed in 0.18.0"
+    print(f"cg: {old} is deprecated, use {new} ({extra})", file=sys.stderr)
+
+
+def get(name: str, default=None) -> str | None:
+    """``CG_<name>``, else the legacy ``CODEGRAPH_*`` value, else ``default``."""
+    new = "CG_" + name
+    legacy = _legacy_names(name)
+    if new in os.environ:
+        for old in legacy:
+            if old in os.environ:
+                _warn(old, new, both=True)
+        return os.environ[new]
+    found = None
+    for old in legacy:
+        if old in os.environ:
+            _warn(old, new, both=False)
+            if found is None:
+                found = os.environ[old]
+    return default if found is None else found
+
+
+def is_set(name: str) -> bool:
+    """True when ``CG_<name>`` or a legacy alias is present in the environment."""
+    if ("CG_" + name) in os.environ:
+        return True
+    return any(old in os.environ for old in _legacy_names(name))
+
+
+def flag(name: str) -> bool:
+    """True when the value is set and not a false-like token (``0``, ``false``, ``no``, ``off``)."""
+    val = get(name)
+    return val is not None and val.strip().lower() not in ("", "0", "false", "no", "off")
+
+
+def legacy_in_env() -> list[str]:
+    """``CODEGRAPH_*`` names from this project that are present (for ``cg doctor``)."""
+    found: list[str] = []
+    seen: set[str] = set()
+    for name in SUFFIXES:
+        for old in _legacy_names(name):
+            if old in os.environ and old not in seen:
+                seen.add(old)
+                found.append(old)
+    return found

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/core/extractors.py

@@ -1,6 +1,6 @@
 """Where the Node / PHP / Dart extractors run from, and their dependency installs.
 
-The extractor sources ship inside the package (codegraph/plugins/{ts,php,dart}/extractor). Their dependencies
+The extractor sources ship inside the package (cg_code_graph/plugins/{ts,php,dart}/extractor). Their dependencies
 (npm `node_modules`, Composer `vendor/`, `dart pub get` + the compiled Dart extractor) are not part of the package:
 
 - a checkout whose extractor directory already has them (`npm ci` run there) keeps using that directory;
@@ -8,8 +8,8 @@ The extractor sources ship inside the package (codegraph/plugins/{ts,php,dart}/e
   use or by `cg setup`. The directory is keyed by the lock file, so an update that only changes the extractor source
   reuses the installed dependencies, and one that changes the lock file installs into a fresh directory.
 
-Cache root (core/cache.py): $CODEGRAPH_CACHE, else $CODEGRAPH_CACHE_DIR, else %LOCALAPPDATA%\\codegraph on Windows,
-else $XDG_CACHE_HOME/codegraph or ~/.cache/codegraph; the extractors live in <root>/extractors.
+Cache root (core/cache.py): $CG_CACHE, else %LOCALAPPDATA%\\cg on Windows,
+else $XDG_CACHE_HOME/cg or ~/.cache/cg; the extractors live in <root>/extractors.
 """
 from __future__ import annotations
 
@@ -24,6 +24,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from . import cache
+from .env import get as cg_env
 
 try:
     import fcntl
@@ -105,7 +106,7 @@ def status(lang: str) -> dict:
 
 JS_RUNTIME_MISSING = (
     "node not installed (the TypeScript extractor needs Node.js 20+ or Bun on PATH, "
-    "or CODEGRAPH_NODE=/path/to/node)"
+    "or CG_NODE=/path/to/node)"
 )
 
 
@@ -116,21 +117,21 @@ def _runtime_kind(path: str) -> str:
 
 
 def _override() -> str | None:
-    v = (os.environ.get("CODEGRAPH_NODE") or "").strip()
+    v = (cg_env("NODE") or "").strip()
     return os.path.expanduser(v) if v else None
 
 
 def js_runtime() -> dict | None:
     """Node.js or Bun for the TypeScript extractor.
 
-    ``CODEGRAPH_NODE`` (a name on PATH or a path) wins, then ``node`` on PATH, then ``bun``.
+    ``CG_NODE`` (a name on PATH or a path) wins, then ``node`` on PATH, then ``bun``.
     """
     override = _override()
     if override:
         path = shutil.which(override)
         if not path:
             return None
-        return {"path": path, "kind": _runtime_kind(path), "source": "CODEGRAPH_NODE"}
+        return {"path": path, "kind": _runtime_kind(path), "source": "CG_NODE"}
     node = shutil.which("node")
     if node:
         return {"path": node, "kind": _runtime_kind(node), "source": "PATH"}
@@ -144,7 +145,7 @@ def js_runtime_problem() -> str | None:
     """Why the TypeScript extractor cannot start, or None when a runtime resolves."""
     override = _override()
     if override and not shutil.which(override):
-        return (f"CODEGRAPH_NODE={os.environ.get('CODEGRAPH_NODE')} is not an executable on PATH or a path to one "
+        return (f"CG_NODE={cg_env('NODE')} is not an executable on PATH or a path to one "
                 "(set it to a node or bun binary, or unset it to use node / bun from PATH)")
     if js_runtime() is None:
         return JS_RUNTIME_MISSING

{cg_code_graph-0.15.0/codegraph → cg_code_graph-0.17.0/cg_code_graph}/core/generated.py

@@ -11,7 +11,7 @@ recognised, from (first match wins, in this order):
      `cap sync` writes), Cordova's `www/` copied into `platforms/<platform>/www/`; each copied file maps back to its
      source (`copy_of`)
   4. files listed in `.openapi-generator/FILES` (OpenAPI Generator output)
-  5. framework build output and generator file names (codegraph/presets/common.yaml `generated`): `.nuxt/`, `.next/`,
+  5. framework build output and generator file names (cg_code_graph/presets/common.yaml `generated`): `.nuxt/`, `.next/`,
      `*.g.dart`, `*_pb2.py`, `*.pb.go`, `GeneratedPluginRegistrant.java` ...
   6. a generator banner in the file's leading comment block: `@generated`, `Code generated ... DO NOT EDIT.`,
      `GENERATED CODE - DO NOT MODIFY BY HAND`, `<auto-generated>`, `This file is automatically generated`, protoc /