cg-code-graph 0.22.0__tar.gz → 0.23.1__tar.gz

{cg_code_graph-0.22.0/cg_code_graph.egg-info → cg_code_graph-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg-code-graph
-Version: 0.22.0
+Version: 0.23.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
@@ -48,7 +48,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 install --host cursor    # or claude, codex, vscode, …: registers the MCP server and a "use cg first" agent rule
 cg reaches table:orders --db out/graph.db   # any table, connection or config key
 ```
 

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/README.md

@@ -21,7 +21,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 install --host cursor    # or claude, codex, vscode, …: registers the MCP server and a "use cg first" agent rule
 cg reaches table:orders --db out/graph.db   # any table, connection or config key
 ```
 

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/__init__.py

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

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/cli.py

@@ -73,6 +73,10 @@ def _add_install_parser(sub, uninstall: bool):
     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")
+    p.add_argument("--no-rules", dest="rules", action="store_false",
+                   help=("leave AGENTS.md and .cursor/rules/cg.mdc alone" if uninstall else
+                         "do not write the 'use cg first' agent rules (AGENTS.md section, .cursor/rules/cg.mdc); "
+                         "project scope only"))
     if not uninstall:
         p.add_argument("--registry", action="store_true",
                        help="global single entry: cg-mcp with no --db; graphs come from the registry")
@@ -520,7 +524,8 @@ def main(argv=None):
         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, registry=registry, migrate=migrate,
-                           apply=bool(getattr(a, "apply", False)), graphs=getattr(a, "graphs", None))
+                           apply=bool(getattr(a, "apply", False)), graphs=getattr(a, "graphs", None),
+                           rules=a.rules)
     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)
@@ -636,6 +641,8 @@ def main(argv=None):
         print(json.dumps(res, indent=1, default=str) if a.json else render_protocols(res, max_items=a.max_items))
         return
     if a.cmd == "tests":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.tests_covering(st, a.spec, min_conf=a.min_confidence, near_depth=a.max_depth or None,
                                unit_only=a.unit_only, exclude_roots=a.exclude_root, through_roots=a.through_roots)
         res["completeness"] = _completeness(st, res.get("targets"))
@@ -674,12 +681,17 @@ def main(argv=None):
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_search(res))
         return
     if a.cmd == "reaches":
+        for spec in a.specs:
+            if _unknown_route(st, spec, a.json):
+                return
         res = Q.reaches(st, a.specs, min_conf=a.min_confidence, max_depth=a.max_depth, gate=None if a.gate == "none" else a.gate,
                         platform=a.platform, connection=a.connection)
         res["completeness"] = _completeness(st, [x for t in res["targets"].values() for x in t] + [i["id"] for i in res["items"]])
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_reaches(res, show_paths=not a.no_paths))
         _note(res["completeness"], a.json)
     elif a.cmd == "impact":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.impact(st, a.spec, min_conf=a.min_confidence, platform=a.platform)
         if a.json:
             res["completeness"] = _completeness(st, list(res["targets"]) + [c["id"] for c in res["callers"]])
@@ -755,6 +767,8 @@ def main(argv=None):
         res = Q.siblings(st, a.spec)
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_siblings(st, a.spec, res))
     elif a.cmd == "node":
+        if _unknown_route(st, a.spec, a.json):
+            return
         ids = list(dict.fromkeys(Q.resolve_targets(st, a.spec)))[:20]
         docs = [node_doc(st, nid) for nid in ids]
         if a.json:
@@ -774,10 +788,14 @@ def main(argv=None):
         if not p:
             raise SystemExit(1)  # scripts can tell "no path" apart from a path
     elif a.cmd == "downstream":
+        if _unknown_route(st, a.spec, a.json):
+            return
         res = Q.downstream(st, a.spec, min_conf=a.min_confidence, max_depth=a.max_depth, gate=None if a.gate == "none" else a.gate,
                            platform=a.platform)
         print(json.dumps(res, indent=1, default=str) if a.json else Q.render_downstream(res, show_paths=not a.no_paths))
     elif a.cmd == "api-calls":
+        if _unknown_route(st, a.spec, a.json):
+            return
         rows = Q.api_calls(st, a.spec)
         print(json.dumps(rows, indent=1, default=str) if a.json else Q.render_api_calls(rows))
         if not a.json:
@@ -789,6 +807,17 @@ def main(argv=None):
         doc = stats_doc(st)
         print(json.dumps(doc, indent=1, default=str) if a.json else render_stats(st, doc))
 
+def _unknown_route(st, spec: str, as_json: bool) -> bool:
+    miss = Q.route_failure(st, spec)
+    if not miss:
+        return False
+    if as_json:
+        print(json.dumps({"error": miss["error"], "spec": miss["spec"], "suggestions": miss["suggestions"]}))
+    else:
+        print(miss["text"])
+    raise SystemExit(1)
+
+
 def node_doc(st, nid: str) -> dict:
     """One node with its attrs parsed and its outgoing / incoming edges (`cg node --json`, #75)."""
     n = dict(st.node(nid))

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/coverage.py

@@ -344,6 +344,9 @@ def compute(root: str | Path, plugins: dict, scip_imported: bool = False, report
             elif not e["files_complete"] and lang == "typescript" and e.get("unmapped"):
                 e["hint"] = ("files outside the source dirs and test trees were not read: list the directories that hold "
                              "source in .cg.yaml `include` (or a tsconfig.json `include`) and re-index")
+                if (nx := _nuxt_dirs(root)):
+                    # Nuxt: name the dirs that were read, so a layer or module dir outside them is explained (#214)
+                    e["hint"] = f"Nuxt project: the source dirs read are the srcDir plus server/ and shared/ ({nx}); " + e["hint"]
         se = (rep or {}).get("syntax_errors")
         if isinstance(se, list) and se and status not in ("skipped", "not_indexed"):
             # files parsed with syntax errors (#73): error spans and the declarations lost there
@@ -434,6 +437,16 @@ def _ts_not_run(root, with_php: bool) -> tuple[str, str]:
     return reason, hint
 
 
+def _nuxt_dirs(root) -> str | None:
+    """'app/, server/, shared/' for a Nuxt project (the dirs the Nuxt plugin reads), else None."""
+    from .plugins.nuxt.plugin import _CFG_NAMES, find_src_dir, side_dirs
+    r = Path(root)
+    if not any((r / n).exists() for n in _CFG_NAMES):
+        return None
+    src = find_src_dir(r)
+    return ", ".join(["the project root" if src == "." else f"{src}/", *(f"{d}/" for d in side_dirs(r, src))])
+
+
 def _python_unmapped_hint(st: dict) -> str:
     if st.get("roots_mode") in ("configured", "flag"):
         where = "python.source_roots in .cg.yaml" if st["roots_mode"] == "configured" else "--python-root"

cg_code_graph-0.23.1/cg_code_graph/install_rules.py

@@ -0,0 +1,88 @@
+"""Agent rules written by `cg install` (project scope, on by default, `--no-rules` skips): a short "use cg first"
+section in AGENTS.md (Claude Code, Codex and other agents read it) and an alwaysApply Cursor rule at
+.cursor/rules/cg.mdc. Only the `<!-- cg:start --> ... <!-- cg:end -->` section is ever written: a re-run replaces
+it in place, content around it is kept, and `cg uninstall` removes it."""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+START = "<!-- cg:start -->"
+END = "<!-- cg:end -->"
+AGENTS_FILE = "AGENTS.md"
+CURSOR_FILE = ".cursor/rules/cg.mdc"
+MDC_HEADER = "---\ndescription: Use the cg code graph before grep or opening whole files\nalwaysApply: true\n---\n"
+_SECTION = re.compile(re.escape(START) + r".*?" + re.escape(END), re.S)
+
+
+def body(db: str = "out/graph.db") -> str:
+    return (
+        "## Code graph (cg)\n\n"
+        "This repo has a cg code graph (MCP server `cg`). Use it before grep or opening whole files:\n"
+        "- `search` to find a symbol (file:line);\n"
+        "- `impact` before editing a function (or `reaches` for a table, column or env key) to see what the change affects;\n"
+        "- `snippet` to read one symbol instead of a whole file;\n"
+        "- `graphs` if unsure which graph to query.\n\n"
+        "Use normal search only for what cg reports as not covered (`coverage`). Without MCP: "
+        f"`cg search|impact|snippet <symbol> --db {db}`.\n")
+
+
+def section(db: str = "out/graph.db") -> str:
+    return f"{START}\n{body(db)}{END}"
+
+
+def _plan(path: Path, new: str | None, old: str, delete: bool = False) -> dict:
+    if delete:
+        return {"path": str(path), "kind": "text", "action": "remove", "old": old, "new": "", "delete_file": True}
+    if new == old:
+        return {"path": str(path), "kind": "text", "action": "noop", "old": old, "new": old, "current": True}
+    action = "insert" if not _SECTION.search(old) else ("remove" if not _SECTION.search(new) else "update")
+    return {"path": str(path), "kind": "text", "action": action, "old": old, "new": new}
+
+
+def _with_section(old: str, sec: str) -> str:
+    if _SECTION.search(old):
+        return _SECTION.sub(lambda _m: sec, old, count=1)
+    if not old:
+        return sec + "\n"
+    return old + ("" if old.endswith("\n\n") else "\n" if old.endswith("\n") else "\n\n") + sec + "\n"
+
+
+def _without_section(old: str) -> str:
+    m = _SECTION.search(old)
+    if not m:
+        return old
+    s, e = m.start(), m.end()
+    while e < len(old) and old[e] == "\n":
+        e += 1
+    while s > 0 and old[s - 1] == "\n":
+        s -= 1
+    head = old[:s]
+    return (head + "\n" + old[e:]) if head and old[e:] else (head + "\n" if head else old[e:])
+
+
+def plans(root: Path, remove: bool = False, db: str = "out/graph.db") -> list[dict]:
+    """One text plan per rules file (the shape `cg agents` previews and `cg install` applies)."""
+    out = []
+    sec = section(db)
+    agents = root / AGENTS_FILE
+    old = agents.read_text(encoding="utf-8") if agents.exists() else ""
+    if remove:
+        rest = _without_section(old)
+        out.append(_plan(agents, None, old, delete=True) if _SECTION.search(old) and not rest.strip() else _plan(agents, rest, old))
+    else:
+        out.append(_plan(agents, _with_section(old, sec), old))
+    mdc = root / CURSOR_FILE
+    old = mdc.read_text(encoding="utf-8") if mdc.exists() else ""
+    if remove:
+        rest = _without_section(old)
+        if mdc.exists() and _SECTION.search(old) and rest.strip() in ("", MDC_HEADER.strip()):
+            out.append(_plan(mdc, None, old, delete=True))
+        else:
+            out.append(_plan(mdc, rest, old))
+    else:
+        new = _with_section(old, sec)
+        if not new.startswith("---\n"):
+            new = MDC_HEADER + new        # an alwaysApply header, added once in front of whatever is there
+        out.append(_plan(mdc, new, old))
+    return [p for p in out if not (remove and p["action"] == "noop" and not p["old"])]

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/link.py

@@ -101,20 +101,73 @@ def _method_ok(cm: str, rm: str) -> bool:
     return cm in rms or "ANY" in rms or (cm == "HEAD" and "GET" in rms)
 
 
+_BASE_SEG = re.compile(r"^(api|v\d+)$", re.I)
+
+
 def suffix_candidates(path: str, routes: list[dict]):
-    """Origin unknown: align the client path with the END of route URIs (prefix assumed to be the base)."""
+    """Align the client path with the end of a route only when the dropped prefix is a base path (`api`, `v1`)."""
     cs = _segs(path)
     out = []
     for r in routes:
         us = _segs(r["uri"])
         if len(us) <= len(cs):
             continue
+        dropped = us[:len(us) - len(cs)]
+        if any(not _BASE_SEG.match(seg) for seg in dropped):
+            continue
         ok, info = match_path("/" + "/".join(cs), "/" + "/".join(us[len(us) - len(cs):]))
         if ok and info["lit"] > 0:
             out.append((r, "suffix", info))
     return out
 
 
+def known_origin_text(attrs: dict) -> str | None:
+    """Env placeholder or literal base URL, when the client recorded one."""
+    kind = attrs.get("origin_kind")
+    origin = attrs.get("origin") or ""
+    base = attrs.get("base") or {}
+    if not isinstance(base, dict):
+        base = {}
+    parts = [origin, base.get("placeholder") or "", base.get("value") or ""]
+    text = " ".join(p for p in parts if isinstance(p, str) and p)
+    if kind == "env" or (isinstance(origin, str) and origin.startswith("{env.")):
+        return text or None
+    if kind == "other" or "://" in text:
+        return text or None
+    return None
+
+
+_GENERIC_ORIGIN = {"env", "base", "url", "uri", "api", "app", "http", "https", "host", "origin", "endpoint", "service",
+                   "internal", "server", "backend", "public", "private", "remote", "domain", "root", "prefix", "path",
+                   "address", "addr", "runtime", "config", "runtimeconfig", "process", "import", "meta", "window",
+                   "location", "nuxt", "next", "vite", "react", "expo", "vue", "localhost", "www", "com"}
+
+
+def repos_for_origin(text: str, servers: list[str]) -> list[str] | None:
+    """Server names named by the origin.
+
+    ``None`` when the origin is a generic API base (``API_BASE_URL``) and does not name a repo:
+    matching stays as it was. ``[]`` when it names a service that is not one of ``servers``.
+    """
+    # camelCase splits (runtimeConfig.public.apiBase -> runtime config public api base); `-`, `_` and `.` all separate,
+    # so ORDERS_API_URL names an orders-api repo
+    split = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text).lower()
+    norm = "-" + "-".join(re.findall(r"[a-z0-9]+", split)) + "-"
+    hits = []
+    for name in servers:
+        token = "-".join(re.findall(r"[a-z0-9]+", re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", name).lower()))
+        if len(token) < 3:
+            continue
+        if f"-{token}-" in norm:
+            hits.append(name)
+    if hits:
+        return hits
+    tokens = [t for t in re.findall(r"[a-z][a-z0-9]+", split) if t not in _GENERIC_ORIGIN]
+    if not tokens:
+        return None
+    return []
+
+
 def match_endpoint(method: str, path: str, routes: list[dict], origin_kind: str = "api", origin: str | None = None,
                    base_prefix: str | None = None) -> dict:
     """base_prefix: path part of a configured base URL already folded into `path` (http node attrs.base); when the
@@ -384,11 +437,24 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
         by_server[rt["server"]].append(rt)
     results = []
     new_edges = []
+    matched_origins: set[tuple[str, str]] = set()
     for client, ep_id, a, _test in http_rows:
         targets = [s for s in server_names if (s != client or folded_self) and (client not in allow or s in allow[client])]
         pool = [rt for s in targets for rt in by_server[s]]
         bp = base_path((a.get("base") or {}).get("value") or "") if a.get("base") else None
+        origin_text = known_origin_text(a)
+        owners = repos_for_origin(origin_text, targets) if origin_text else None
+        if owners is not None and len(owners) == 1:
+            pool = [rt for rt in pool if rt["server"] == owners[0]]
         res = match_endpoint(a["method"], a["path"], pool, a.get("origin_kind", "api"), a.get("origin"), base_prefix=bp or None)
+        if origin_text and owners == [] and not res.get("matched") and a.get("origin_kind") != "other":
+            reason = res.get("reason") or ""
+            if reason.startswith(("no backend route", "not a backend URL")) or "suffix" in reason:
+                res["_reason_before_external"] = reason
+                res["_origin_text"] = origin_text
+                res["reason"] = "external (other origin)"
+        elif origin_text and res.get("matched"):
+            matched_origins.add((client, origin_text))
         res.update({"endpoint": ep_id, "method": a["method"], "calls": calls_by_ep.get(ep_id, []),
                     "_client": client, "_servers": targets})
         results.append(res)
@@ -397,6 +463,12 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
             rr = rmap[m["route"]]
             new_edges.append((ep_id, m["route"], "MATCHES_ROUTE", rr["file"], rr["line"], m["confidence"], CONFIDENCE_RANK[m["confidence"]],
                               json.dumps({"client_path": a["path"], "uri_variant": m["uri_variant"], "segments": m["segments"]}), None))
+    for res in results:
+        # an origin whose other calls from this client matched a linked server is that backend, not an external one
+        before = res.pop("_reason_before_external", None)
+        if before is not None and (res["_client"], res.pop("_origin_text")) in matched_origins:
+            res["reason"] = before
+        res.pop("_origin_text", None)
     db.executemany("INSERT INTO edges(src,dst,kind,file,line,confidence,conf_rank,attrs,gate) VALUES (?,?,?,?,?,?,?,?,?)", new_edges)
     db.commit()
     subscriptions = pair_subscriber_urls(db, routes, server_names, allow, folded_self)
@@ -448,13 +520,20 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
     for sc in scen[:1]:
         db.executemany("INSERT INTO node_entry_live VALUES (?,?,?,?,?)", [(sc, *r) for r in tag_entries_rows(nodes, edges, prop, skip_gate=sc)])
     db.commit()
+    # call sites whose wrapper no entry point reaches are matched, but not live
+    live_ids = {r[0] for r in db.execute("SELECT DISTINCT node_id FROM node_entry WHERE entry_kind != 'test'")}
+    for r in results:
+        for c in r["calls"]:
+            c["live"] = c.get("src") in live_ids
+        if r["matched"] and r["calls"] and not any(c.get("live") for c in r["calls"]):
+            r["no_live_caller"] = True
     # ---- stats: per call site and per distinct endpoint
     n_ep = len(results)
     m_ep = sum(1 for r in results if r["matched"])
     site_match = {}
     for r in results:
         for c in r["calls"]:
-            site_match[c["at"]] = site_match.get(c["at"], False) or bool(r["matched"])
+            site_match[c["at"]] = site_match.get(c["at"], False) or (bool(r["matched"]) and c.get("live", True))
     sites = list(site_match)
     m_sites = sum(1 for v in site_match.values() if v)
     conf_ct = defaultdict(int)
@@ -476,7 +555,7 @@ def link_many(repos: list[tuple[str, str, str]], out_db: str, *, allow: dict | N
             for r in eps:
                 hit = any(rmap[m["route"]]["server"] == server for m in r["matched"])
                 for c in r["calls"]:
-                    sm[c["at"]] = sm.get(c["at"], False) or hit
+                    sm[c["at"]] = sm.get(c["at"], False) or (hit and c.get("live", True))
             pair_stats.append({"client": client, "server": server, "endpoints": len(eps),
                                "endpoints_matched": sum(1 for r in eps if any(rmap[m["route"]]["server"] == server for m in r["matched"])),
                                "call_sites": len(sm), "call_sites_matched": sum(1 for v in sm.values() if v)})
@@ -667,6 +746,11 @@ def write_match_report(res: dict, out_prefix: str) -> None:
         at = ", ".join(sorted({c["at"] for c in r["calls"]})[:3])
         extra = f" closest={r['closest']}" if r.get("closest") else (f" near={r['near']}" if r.get("near") else "")
         L.append(f"- `{r['endpoint']}` - {r['reason']}{extra} - at {at}")
+    dead = [r for r in res["results"] if r.get("no_live_caller")]
+    if dead:
+        L += ["", "## Matched, no live caller", ""]
+        for r in dead:
+            L.append(f"- `{r['endpoint']}` — matched, no live caller")
     L += ["", "## Ambiguous / heuristic matches", ""]
     for r in res["results"]:
         if r["matched"] and (len(r["matched"]) > 1 or any(m["confidence"] == "heuristic" for m in r["matched"])):

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/mcp_graphs.py

@@ -68,7 +68,7 @@ def git_head(root: Path) -> str | None:
 
 
 def _valid_name(name: str) -> bool:
-    return bool(name) and all(c.isalnum() or c in "_.-" for c in name)
+    return bool(name) and all(c.isalnum() or c in "_.-+" for c in name)   # `app+api`: a combined graph
 
 
 def parse_db_arg(text: str) -> tuple[str, Path]:
@@ -318,9 +318,58 @@ def _superset(hits: list[GraphEntry]) -> GraphEntry | None:
     return strict[0] if len(strict) == 1 else None
 
 
+def _deepest_repo(hits: list[GraphEntry], texts: list[str]) -> Path | None:
+    """The repo containing the path: the deepest matching root, when that root is unique."""
+    containing: list[Path] = []
+    for entry in hits:
+        for root in entry.roots:
+            if not any(_under(root, text) for text in texts):
+                continue
+            try:
+                containing.append(root.expanduser().resolve())
+            except OSError:
+                containing.append(root)
+    if not containing:
+        return None
+    deepest: list[Path] = []
+    for root in containing:
+        if any(other != root and _under(root, str(other)) for other in containing):
+            continue
+        deepest.append(root)
+    unique = set(deepest)
+    if len(unique) != 1:
+        return None
+    return next(iter(unique))
+
+
+def _own_graph(hits: list[GraphEntry], texts: list[str]) -> GraphEntry | None:
+    """The one match whose roots are exactly the repo that contains the path."""
+    repo = _deepest_repo(hits, texts)
+    if repo is None:
+        return None
+    own = [entry for entry in hits if _root_set(entry) == {repo}]
+    return own[0] if len(own) == 1 else None
+
+
+def _pick(registry: Registry, hits: list[GraphEntry], texts: list[str]) -> GraphEntry:
+    """Superset, then the graph that is only that repo, then the configured default."""
+    chosen = _superset(hits)
+    if chosen is not None:
+        return chosen
+    chosen = _own_graph(hits, texts)
+    if chosen is not None:
+        return chosen
+    if registry.default:
+        by = registry.by_name()
+        default = by.get(registry.default)
+        if default is not None and default in hits:
+            return default
+    raise _choice_error(hits)
+
+
 def resolve(registry: Registry, *, graph: str | None, paths: list[str],
             cwd: Path | None = None, mcp_roots: list[str] | None = None) -> GraphEntry:
-    """Pick a graph. Several matches stay an error unless one graph's roots contain the others."""
+    """Pick a graph. Several matches use a superset, then a single-repo graph, then the default."""
     by = registry.by_name()
     if graph:
         if graph not in by:
@@ -330,10 +379,7 @@ def resolve(registry: Registry, *, graph: str | None, paths: list[str],
     if len(path_hits) == 1:
         return path_hits[0]
     if len(path_hits) > 1:
-        chosen = _superset(path_hits)
-        if chosen is not None:
-            return chosen
-        raise _choice_error(path_hits)
+        return _pick(registry, path_hits, paths)
     places: list[str] = []
     if mcp_roots:
         places.extend(mcp_roots)
@@ -342,10 +388,7 @@ def resolve(registry: Registry, *, graph: str | None, paths: list[str],
     if len(loc_hits) == 1:
         return loc_hits[0]
     if len(loc_hits) > 1:
-        chosen = _superset(loc_hits)
-        if chosen is not None:
-            return chosen
-        raise _choice_error(loc_hits)
+        return _pick(registry, loc_hits, places)
     if registry.default and registry.default in by:
         return by[registry.default]
     if len(registry.entries) == 1:

{cg_code_graph-0.22.0 → cg_code_graph-0.23.1}/cg_code_graph/mcp_install.py

@@ -781,6 +781,9 @@ def _apply_file(plan: dict) -> None:
         if path.exists():
             path.unlink()
         parent = path.parent
+        if parent.name == "rules" and parent.parent.name == ".cursor" and parent.exists() and not any(parent.iterdir()):
+            parent.rmdir()            # .cursor/rules/cg.mdc was the only rule
+            parent = parent.parent
         if parent.name in _EMPTY_PARENTS and parent.exists() and not any(parent.iterdir()):
             parent.rmdir()
         return
@@ -1023,7 +1026,7 @@ def run(hosts: list[str] | None, *, scope: str, root: str = ".", db: str | None
         tools: str | None = None, portable: bool = False, remove: bool = False,
         dry_run: bool = False, assume_yes: bool = False, input_fn=input, out=print,
         registry: bool = False, migrate: bool = False, apply: bool = False,
-        graphs: str | None = None) -> int:
+        graphs: str | None = None, rules: bool = True) -> int:
     if migrate:
         return run_migrate(hosts, scope=scope, root=root, tools=tools, graphs=graphs, apply=apply and not dry_run, out=out)
     rootp = Path(root).resolve()
@@ -1050,6 +1053,16 @@ def run(hosts: list[str] | None, *, scope: str, root: str = ".", db: str | None
         dbp = None
     plans = iter_plans(expanded, scope=scope, root=rootp, db=dbp, tools=tools, portable=portable, remove=remove,
                        registry=registry)
+    if rules and scope == "project" and not registry:
+        # "use cg first" rules for agents: AGENTS.md section + alwaysApply Cursor rule (cg_code_graph/install_rules.py)
+        from . import install_rules as IR
+        shown = "out/graph.db"
+        if dbp is not None and not portable:
+            try:
+                shown = dbp.relative_to(rootp).as_posix()
+            except ValueError:
+                shown = str(dbp)
+        plans = [*plans, *IR.plans(rootp, remove=remove, db=shown)]
     if not portable and not remove and uses_module_fallback():
         out(_FALLBACK_NOTE)
     for plan in plans:
@@ -1088,6 +1101,10 @@ def run(hosts: list[str] | None, *, scope: str, root: str = ".", db: str | None
         _apply_file(plan)
         if plan.get("delete_file"):
             out(f"removed {plan['path']}")
+        elif plan.get("kind") == "text" and plan["action"] == "remove":
+            out(f"removed the cg section from {plan['path']}")
+        elif plan.get("kind") == "text":
+            out(f"wrote {plan['path']} (cg agent rules, {plan['action']})")
         else:
             out(f"wrote {plan['path']} ({plan['action']})")
     return 0