cg-code-graph 0.19.0__tar.gz → 0.19.1__tar.gz

{cg_code_graph-0.19.0/cg_code_graph.egg-info → cg_code_graph-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.19.0
+Version: 0.19.1
 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

{cg_code_graph-0.19.0 → cg_code_graph-0.19.1}/cg_code_graph/__init__.py

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

{cg_code_graph-0.19.0 → cg_code_graph-0.19.1}/cg_code_graph/core/extractors.py

@@ -5,8 +5,9 @@ The extractor sources ship inside the package (cg_code_graph/plugins/{ts,php,dar
 
 - a checkout whose extractor directory already has them (`npm ci` run there) keeps using that directory;
 - otherwise the sources are copied into a per-user cache directory and the dependencies installed there, on first
-  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.
+  use or by `cg setup`. The directory is keyed by the lock file and the extractor sources (names and contents), so a
+  release that adds or edits a module installs into a fresh directory. A cache directory that is missing a listed
+  source is incomplete and is rebuilt.
 
 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.
@@ -46,7 +47,8 @@ class Spec:
 
 
 SPECS = {
-    "typescript": Spec("typescript", PLUGINS / "ts" / "extractor", ("extract.mjs", "fw.mjs", "package.json", "package-lock.json"),
+    "typescript": Spec("typescript", PLUGINS / "ts" / "extractor", ("extract.mjs", "fw.mjs", "rr.mjs", "package.json",
+                                                                  "package-lock.json"),
                        "package-lock.json", ("node_modules/typescript/package.json",), "npm", "TypeScript / JavaScript"),
     "php": Spec("php", PLUGINS / "php" / "extractor", ("extract.php", "composer.json", "composer.lock"), "composer.lock",
                 ("vendor/autoload.php",), "composer", "PHP"),
@@ -63,20 +65,42 @@ def _installed(d: Path, spec: Spec) -> bool:
     return any((d / m).exists() for m in spec.markers)
 
 
+def _missing_sources(spec: Spec, d: Path) -> list[str]:
+    """Listed sources that exist in the package but not in the cache directory."""
+    return [rel for rel in spec.sources if (spec.pkg / rel).exists() and not (d / rel).exists()]
+
+
+def _cache_key(spec: Spec) -> str:
+    """Lock file plus every source path and its bytes, so a new or edited module does not reuse an old install."""
+    h = hashlib.sha256()
+    lock = spec.pkg / spec.lock
+    h.update(lock.read_bytes() if lock.exists() else b"")
+    for rel in spec.sources:
+        h.update(b"\0")
+        h.update(rel.encode())
+        src = spec.pkg / rel
+        h.update(b"\0")
+        h.update(src.read_bytes() if src.exists() else b"")
+    return h.hexdigest()[:12]
+
+
 def cache_dir(lang: str) -> Path:
     spec = SPECS[lang]
-    lock = spec.pkg / spec.lock
-    key = hashlib.sha256(lock.read_bytes() if lock.exists() else b"").hexdigest()[:12]
-    return cache_root() / f"{lang}-{key}"
+    return cache_root() / f"{lang}-{_cache_key(spec)}"
 
 
 def workdir(lang: str) -> Path:
     """The directory the extractor runs from: the package's own one when its dependencies are installed there (a
-    development checkout), else the cache directory (sources synced into it; dependencies maybe not yet installed)."""
+    development checkout), else the cache directory (sources synced into it; dependencies maybe not yet installed).
+    A cache directory missing a listed source is rebuilt from the package sources."""
     spec = SPECS[lang]
     if _installed(spec.pkg, spec):
         return spec.pkg
     d = cache_dir(lang)
+    if d.exists() and _missing_sources(spec, d):
+        # Incomplete copy (for example a 0.19.0 typescript cache that predates a module): drop it and start over
+        # when the key still matches, otherwise cache_dir already points at a fresh directory.
+        shutil.rmtree(d, ignore_errors=True)
     _sync(spec, d)
     return d
 
@@ -101,7 +125,8 @@ def status(lang: str) -> dict:
     if _installed(spec.pkg, spec):
         return {"installed": True, "dir": str(spec.pkg), "where": "package"}
     d = cache_dir(lang)
-    return {"installed": _installed(d, spec), "dir": str(d), "where": "cache"}
+    ready = _installed(d, spec) and not _missing_sources(spec, d)
+    return {"installed": ready, "dir": str(d), "where": "cache"}
 
 
 JS_RUNTIME_MISSING = (

{cg_code_graph-0.19.0 → cg_code_graph-0.19.1/cg_code_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.19.0
+Version: 0.19.1
 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

{cg_code_graph-0.19.0 → cg_code_graph-0.19.1}/tests/test_packaging.py

@@ -15,6 +15,21 @@ from cg_code_graph.core import extractors
 
 ROOT = Path(__file__).resolve().parent.parent
 
+_RUNTIME_SUFFIXES = {".mjs", ".js", ".php", ".dart"}
+_SKIP_DIRS = {"node_modules", "vendor", ".dart_tool", ".bin"}
+
+
+def _runtime_sources(pkg: Path) -> list[str]:
+    """Extractor modules that must be listed on Spec.sources (lockfiles and dependency trees are not runtime modules)."""
+    found = []
+    for p in pkg.rglob("*"):
+        if not p.is_file() or p.suffix not in _RUNTIME_SUFFIXES:
+            continue
+        if any(part in _SKIP_DIRS for part in p.relative_to(pkg).parts):
+            continue
+        found.append(p.relative_to(pkg).as_posix())
+    return found
+
 
 def test_pyproject_metadata():
     meta = tomllib.loads((ROOT / "pyproject.toml").read_text())
@@ -34,6 +49,10 @@ def test_pyproject_metadata():
     for spec in extractors.SPECS.values():
         for rel in spec.sources:
             assert (spec.pkg / rel).exists(), rel
+    # every runtime module in the plugin folder is copied into the cache, or a pip install fails with ERR_MODULE_NOT_FOUND
+    for spec in extractors.SPECS.values():
+        for rel in _runtime_sources(spec.pkg):
+            assert rel in spec.sources, (spec.lang, rel)
 
 
 def _fake_spec(tmp_path, monkeypatch):
@@ -55,22 +74,75 @@ def test_extractor_runs_from_user_cache_without_deps_in_package(tmp_path, monkey
     assert (d / "extract.mjs").read_text() == "// v1\n" and not (d / "fw.mjs").exists()
     st = extractors.status("typescript")
     assert st == {"installed": False, "dir": str(d), "where": "cache"}
-    # dependencies installed there: reused; a newer extractor source with the same lock file is synced into it
+    # dependencies installed there: reused while the sources are unchanged
     (d / "node_modules" / "typescript").mkdir(parents=True)
     (d / "node_modules" / "typescript" / "package.json").write_text("{}")
-    (pkg / "extract.mjs").write_text("// v2\n")
     assert extractors.ensure("typescript") == d          # no install command run: the marker is there
-    assert (d / "extract.mjs").read_text() == "// v2\n"
     assert extractors.status("typescript")["installed"]
+    # edited extractor source: a new cache key, so the broken or stale directory is not reused
+    (pkg / "extract.mjs").write_text("// v2\n")
+    d_src = extractors.workdir("typescript")
+    assert d_src != d and (d_src / "extract.mjs").read_text() == "// v2\n"
     # a new lock file: a fresh directory
     (pkg / "package-lock.json").write_text('{"lockfileVersion": 3, "x": 1}\n')
-    assert extractors.workdir("typescript") != d
+    assert extractors.workdir("typescript") != d_src
     # a checkout with the dependencies in the package directory keeps using it
     (pkg / "node_modules" / "typescript").mkdir(parents=True)
     (pkg / "node_modules" / "typescript" / "package.json").write_text("{}")
     assert extractors.workdir("typescript") == pkg and extractors.status("typescript")["where"] == "package"
 
 
+def test_cache_missing_listed_source_is_rebuilt(tmp_path, monkeypatch):
+    """A cache directory that lost a listed source is not treated as installed and is rebuilt with that file."""
+    pkg = _fake_spec(tmp_path, monkeypatch)
+    (pkg / "rr.mjs").write_text("export const rr = 1\n")
+    spec = extractors.SPECS["typescript"]
+    spec = extractors.Spec(spec.lang, pkg, spec.sources + ("rr.mjs",), spec.lock, spec.markers, spec.tool, spec.label)
+    monkeypatch.setitem(extractors.SPECS, "typescript", spec)
+    d = extractors.workdir("typescript")
+    (d / "node_modules" / "typescript").mkdir(parents=True)
+    (d / "node_modules" / "typescript" / "package.json").write_text("{}")
+    assert extractors.status("typescript")["installed"]
+    (d / "rr.mjs").unlink()
+    assert not extractors.status("typescript")["installed"]
+    rebuilt = extractors.workdir("typescript")
+    assert rebuilt == d
+    assert (rebuilt / "rr.mjs").read_text() == "export const rr = 1\n"
+    assert (rebuilt / "extract.mjs").read_text() == "// v1\n"
+    assert not (rebuilt / "node_modules").exists()          # the incomplete install was removed, not patched in place
+
+
+def test_typescript_cache_index_without_network(tmp_path, monkeypatch):
+    """Pip-style install: package dir has no node_modules, so indexing uses the cache and a local node_modules link."""
+    nm = extractors.SPECS["typescript"].pkg / "node_modules"
+    if not (nm / "typescript" / "package.json").exists():
+        pytest.skip("typescript extractor node_modules is not installed")
+    from cg_code_graph.indexer import index_project
+    monkeypatch.setenv("CG_CACHE", str(tmp_path / "cgcache"))
+    real = extractors._installed
+
+    def installed(d, spec):
+        if spec.lang == "typescript" and d == spec.pkg:
+            return False
+        return real(d, spec)
+
+    def run(cmd, d, spec):
+        assert spec.lang == "typescript", cmd
+        link = d / "node_modules"
+        if not link.exists():
+            link.symlink_to(nm, target_is_directory=True)
+
+    monkeypatch.setattr(extractors, "_installed", installed)
+    monkeypatch.setattr(extractors, "_run", run)
+    root = ROOT / "examples" / "bookstore-react-router"
+    stats = index_project(root, tmp_path / "rr.db", root.name)
+    assert stats["nodes"] > 0
+    import sqlite3
+    routes = sqlite3.connect(tmp_path / "rr.db").execute(
+        "SELECT id FROM nodes WHERE kind IN ('route', 'page')").fetchall()
+    assert routes
+
+
 def test_extractor_install_failure_names_the_tool(tmp_path, monkeypatch):
     _fake_spec(tmp_path, monkeypatch)
     monkeypatch.setattr(extractors, "install_command", lambda lang, dart=None: ["cg-no-such-npm", "ci"])