cg-code-graph 0.23.12__tar.gz → 0.23.13__tar.gz

{cg_code_graph-0.23.12/cg_code_graph.egg-info → cg_code_graph-0.23.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.12
+Version: 0.23.13
 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.23.12 → cg_code_graph-0.23.13}/cg_code_graph/__init__.py

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

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13}/cg_code_graph/apps.py

@@ -56,7 +56,8 @@ def index_apps(root: str | Path, db: str | Path, cfg: dict, scip=None, python_ro
                            include_generated=include_generated)
         out["apps"].append({"name": a["name"], "root": a["root"] or ".", "role": a["role"], "db": str(per_app[a["name"]]),
                             "nodes": st.get("nodes"), "edges": st.get("edges"), "index_seconds": st.get("index_seconds"),
-                            "frameworks": sorted(((st.get("presets") or {}).get("frameworks") or {}))})
+                            "frameworks": sorted(((st.get("presets") or {}).get("frameworks") or {})),
+                            **({"incomplete": st["incomplete"]} if st.get("incomplete") else {})})
     if len(apps) == 1:
         shutil.copyfile(per_app[apps[0]["name"]], db)
         out["db_is"] = f"graph of app {apps[0]['name']}"

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13}/cg_code_graph/cli.py

@@ -120,7 +120,7 @@ def main(argv=None):
         return 0
     ap.add_argument("--version", action="version", version=f"cg {__version__}")
     sub = ap.add_subparsers(dest="cmd", required=True)
-    p = sub.add_parser("index", help="detect languages / frameworks under ROOT and build the graph DB (stats JSON on stdout, coverage on stderr)"); p.add_argument("root"); p.add_argument("--db", required=True); p.add_argument("--name"); p.add_argument("--scip", action="append"); p.add_argument("--gates", help="gate scenarios JSON (e.g. examples/bookstore.gates.json)")
+    p = sub.add_parser("index", help="detect languages / frameworks under ROOT and build the graph DB (stats JSON on stdout, coverage on stderr)"); p.add_argument("root"); p.add_argument("--db", required=True); p.add_argument("--name"); p.add_argument("--scip", action="append"); p.add_argument("--gates", help="gate scenarios JSON (e.g. examples/bookstore.gates.json)"); p.add_argument("--allow-incomplete", action="store_true", help="exit 0 even when most supported source files could not be indexed (missing PHP / Node / Dart toolchain); the WARNING / ERROR lines still print")
     p.add_argument("--python-root", action="append", metavar="DIR",
                    help="Python source root, relative to ROOT (repeatable); replaces detection and python.source_roots in .cg.yaml")
     p.add_argument("--no-apps", action="store_true",
@@ -413,7 +413,13 @@ def main(argv=None):
                                      include_generated=a.include_generated)
                 print(json.dumps({k: v for k, v in summary.items()}, indent=2, default=str))
                 print(render_apps(summary), file=sys.stderr)
-                return
+                from .coverage import incomplete_lines
+                fatal = False
+                for app in summary.get("apps") or ():
+                    for ln in incomplete_lines(app.get("incomplete"), allow=a.allow_incomplete, where=f"app {app['name']}"):
+                        print(ln, file=sys.stderr)
+                    fatal = fatal or bool((app.get("incomplete") or {}).get("fatal"))
+                return 3 if fatal and not a.allow_incomplete else None
             st = index_project(a.root, a.db, a.name, a.scip, gates=a.gates, python_roots=a.python_root,
                                include_generated=a.include_generated)
         except ConfigError as ex:
@@ -422,7 +428,12 @@ def main(argv=None):
         print(json.dumps(st, indent=2, default=str))
         from .coverage import render_summary
         print(render_summary({"": st.get("coverage")}, db=a.db), file=sys.stderr)  # stdout stays pure JSON
-        return
+        from .coverage import incomplete_lines
+        inc = st.get("incomplete")
+        for ln in incomplete_lines(inc, allow=a.allow_incomplete):
+            print(ln, file=sys.stderr)
+        # a mostly-unindexed project is an error, so `rc == 0 && nodes > 0` checks do not accept it (#239)
+        return 3 if inc and inc.get("fatal") and not a.allow_incomplete else None
     if a.cmd == "doctor":
         from .doctor import render, report
         r = report(a.root, scip=a.scip)

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13}/cg_code_graph/coverage.py

@@ -575,6 +575,40 @@ def syntax_error_lines(e: dict, all_files: bool = False, indent: str = "  ") ->
     return out
 
 
+def incomplete(cov: dict | None) -> dict | None:
+    """Supported languages that were not indexed at all (missing toolchain, extractor error), or None (#239).
+
+    `fatal` is true when those files are at least half of the supported source files: the graph is mostly empty.
+    """
+    if not cov:
+        return None
+    langs = [e for e in cov.get("languages") or () if e.get("status") != "unsupported" and e.get("files")]
+    skipped = [e for e in langs if e.get("status") == "skipped"]
+    if not skipped:
+        return None
+    n = sum(e["files"] for e in skipped)
+    total = sum(e["files"] for e in langs)
+    return {"fatal": n * 2 >= total, "skipped_files": n, "supported_files": total,
+            "languages": [{"language": e.get("label") or e["language"], "files": e["files"], "reason": e.get("reason"),
+                           "hint": e.get("hint")} for e in skipped]}
+
+
+def incomplete_lines(inc: dict | None, prog: str = "cg index", allow: bool = False, where: str = "") -> list[str]:
+    """stderr lines for `incomplete`: one WARNING per skipped language, plus an ERROR line when it is fatal."""
+    if not inc:
+        return []
+    at = f" ({where})" if where else ""
+    out = []
+    for e in inc["languages"]:
+        fix = f"; fix: {e['hint']}" if e.get("hint") else ""
+        out.append(f"{prog}: WARNING{at}: {e['language']} {e['files']} file{'s' if e['files'] != 1 else ''} not indexed: {e.get('reason') or 'skipped'}{fix}")
+    if inc.get("fatal"):
+        tail = " (--allow-incomplete: exit status kept at 0)" if allow else "; exit status 3 (--allow-incomplete keeps 0)"
+        out.append(f"{prog}: ERROR{at}: incomplete graph: {inc['skipped_files']} of {inc['supported_files']} supported "
+                   f"source files were not indexed{tail}")
+    return out
+
+
 def summary_line(cov: dict | None, repo: str | None = None) -> str:
     """One line: 'coverage: php 18 exact; typescript 9 exact | not fully covered: go 3 unsupported (...)'."""
     if not cov:

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13}/cg_code_graph/indexer.py

@@ -472,6 +472,10 @@ def index_project(root: str | Path, db_path: str | Path, name: str | None = None
     vc = value_counts(builder)
     if vc:       # enum cases / constants per language and the references resolved to them (#84)
         stats["coverage"]["values"] = vc
+    from .coverage import incomplete
+    inc = incomplete(stats["coverage"])
+    if inc:
+        stats["incomplete"] = inc       # a supported language was not indexed at all (#239)
     stats["completeness_seconds"] = round(t_tag - t_cov, 2)
     stats["scan_seconds"] = scan_seconds
     stats["nodes"] = len(builder.nodes)

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13/cg_code_graph.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.23.12
+Version: 0.23.13
 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.23.12 → cg_code_graph-0.23.13}/cg_code_graph.egg-info/SOURCES.txt

@@ -273,6 +273,7 @@ tests/test_generated.py
 tests/test_graphql.py
 tests/test_hooks.py
 tests/test_impact_overrides.py
+tests/test_incomplete_239.py
 tests/test_index_isolation.py
 tests/test_inherited_overrides.py
 tests/test_inline_guards.py

{cg_code_graph-0.23.12 → cg_code_graph-0.23.13}/tests/test_coverage.py

@@ -33,8 +33,15 @@ def test_missing_php_is_skipped_not_fatal(tmp_path):
     empty = tmp_path / "bin"
     empty.mkdir()
     r = cg("index", API, "--name", "bookstore-api", "--db", tmp_path / "api.db", path=str(empty))
-    assert r.returncode == 0, r.stderr[-800:]
+    # the graph is still written, but a mostly-unindexed project exits 3 (#239)
+    assert r.returncode == 3, r.stderr[-800:]
     st = json.loads(r.stdout)
+    inc = st["incomplete"]
+    assert inc["fatal"] and inc["skipped_files"] == 32 and inc["languages"][0]["language"] == "php"
+    assert "cg index: WARNING: php 32 files not indexed: php not installed" in r.stderr
+    assert "cg index: ERROR: incomplete graph: 32 of " in r.stderr
+    ok = cg("index", API, "--name", "bookstore-api", "--db", tmp_path / "api2.db", "--allow-incomplete", path=str(empty))
+    assert ok.returncode == 0 and "cg index: ERROR: incomplete graph" in ok.stderr and "--allow-incomplete: exit status kept at 0" in ok.stderr
     assert st["plugins"]["php"]["status"] == "skipped" and "php not installed" in st["plugins"]["php"]["reason"]
     php = lang(st["coverage"], "php")
     assert php["status"] == "skipped" and php["files"] == 32 and "cg setup php" in php["hint"]
@@ -50,7 +57,7 @@ def test_missing_node_skips_typescript(tmp_path):
     empty = tmp_path / "bin"
     empty.mkdir()
     r = cg("index", WEB, "--name", "bookstore-web", "--db", tmp_path / "web.db", path=str(empty))
-    assert r.returncode == 0, r.stderr[-800:]
+    assert r.returncode == 3, r.stderr[-800:]      # nothing indexed (#239)
     ts = lang(json.loads(r.stdout)["coverage"], "typescript")
     assert ts["status"] == "skipped" and "node not installed" in ts["reason"] and "cg setup typescript" in ts["hint"]
 

cg_code_graph-0.23.13/tests/test_incomplete_239.py

@@ -0,0 +1,75 @@
+"""`cg index` on a project whose main language could not be indexed (#239).
+
+A missing PHP toolchain used to give exit 0 and a two-node graph. Now the stats carry `incomplete`, every skipped
+language prints a WARNING, and a mostly-unindexed project exits 3 unless `--allow-incomplete` is passed.
+"""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from cg_code_graph.coverage import incomplete, incomplete_lines  # noqa: E402
+
+
+def _cov(*langs):
+    return {"languages": [dict(language=n, files=f, status=s, reason="php not installed", hint="run `cg setup php`")
+                          for n, f, s in langs]}
+
+
+def test_incomplete_none_when_everything_indexed():
+    assert incomplete(_cov(("php", 10, "exact"), ("typescript", 4, "exact"))) is None
+    assert incomplete(None) is None
+
+
+def test_unsupported_files_do_not_count():
+    inc = incomplete(_cov(("php", 3, "skipped"), ("typescript", 40, "exact"), ("sh", 500, "unsupported")))
+    assert inc == {"fatal": False, "skipped_files": 3, "supported_files": 43,
+                   "languages": [{"language": "php", "files": 3, "reason": "php not installed",
+                                  "hint": "run `cg setup php`"}]}
+    lines = incomplete_lines(inc)
+    assert lines == ["cg index: WARNING: php 3 files not indexed: php not installed; fix: run `cg setup php`"]
+
+
+def test_fatal_at_half_of_supported_files():
+    inc = incomplete(_cov(("php", 20, "skipped"), ("typescript", 20, "exact")))
+    assert inc["fatal"]
+    assert incomplete_lines(inc, where="app api")[-1].startswith(
+        "cg index: ERROR (app api): incomplete graph: 20 of 40 supported source files were not indexed; exit status 3")
+
+
+def _write(root: Path, rel: str, text: str):
+    p = root / rel
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text(text)
+
+
+def _cg(*args, path):
+    env = {"PATH": path, "HOME": str(Path(path).parent / "home"), "CG_CACHE": str(Path(path).parent / "cache")}
+    return subprocess.run([sys.executable, "-m", "cg_code_graph.cli", *map(str, args)], cwd=ROOT, env=env,
+                          capture_output=True, text=True, timeout=300)
+
+
+def test_cli_warns_but_exits_0_when_few_files_are_skipped(tmp_path):
+    app = tmp_path / "kiosk"
+    for i in range(6):
+        _write(app, f"src/screen{i}.ts", f"export function screen{i}(): number {{ return {i} }}\n")
+    _write(app, "tools/ping.php", "<?php\nfunction ping() { return 1; }\n")
+    _write(app, "composer.json", '{"name": "kiosk/tools"}\n')
+    _write(app, "package.json", '{"name": "kiosk", "private": true}\n')
+    _write(app, "tsconfig.json", '{"include": ["src"]}\n')
+    bindir = tmp_path / "bin"          # node only: TypeScript is indexed, PHP is not
+    bindir.mkdir()
+    node = shutil.which("node")
+    if node:
+        os.symlink(node, bindir / "node")
+    r = _cg("index", app, "--db", tmp_path / "g.db", path=str(bindir))
+    st = json.loads(r.stdout)
+    if (st["plugins"].get("ts") or st["plugins"].get("typescript") or {}).get("status") == "skipped":
+        return      # no JS runtime on this PATH: covered by the unit tests above
+    assert r.returncode == 0, r.stderr[-600:]
+    assert st["incomplete"]["fatal"] is False and st["incomplete"]["skipped_files"] == 1
+    assert "cg index: WARNING: php 1 file not indexed" in r.stderr and "ERROR" not in r.stderr