graphnav 1.2.2__tar.gz → 1.3.0__tar.gz

{graphnav-1.2.2/graphnav.egg-info → graphnav-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphnav
-Version: 1.2.2
+Version: 1.3.0
 Summary: Knowledge-graph context injection for AI coding agents in monorepos
 License-Expression: MIT
 Requires-Python: >=3.11

{graphnav-1.2.2 → graphnav-1.3.0}/README.md

@@ -18,6 +18,7 @@ GraphNav solves this by:
 
 ## GraphNav Core Features
 
+- **Always fresh, automatically** — when source files change, the next graph query detects it and rebuilds the graph in the background. No daemon, no manual re-runs, nothing to remember.
 - **Token-budgeted context packs** — `graphnav context "<task>"` returns only the relevant code, inline, with no LLM call.
 - **Native MCP tools** — `graphnav serve` exposes the graph to agents over the Model Context Protocol, refreshed automatically when the graph changes.
 - **Graph-aware ranking** — BM25 plus relation-weighted call-edge expansion and a git-recency nudge, so the file you actually need to edit surfaces even when its text doesn't match the query.
@@ -40,7 +41,7 @@ That's the whole setup. Run `graphnav` from your project root and it:
 2. Builds the knowledge graph
 3. Writes the agent instruction files
 
-Then open the repo in your AI coding tool and start working. **There is nothing else to run.**
+Then open the repo in your AI coding tool and start working. **There is nothing else to run — ever.** When you edit files, the next graph query (from you or your agent) automatically rebuilds the graph in the background, so it never goes stale. Disable with `auto_rebuild = false` under `[mono]` or `GRAPHNAV_NO_AUTO_REBUILD=1`.
 
 Requires Python ≥ 3.11. Pulls `graphifyy` (the `graphify` binary) automatically — including under `pipx`, `--user`, and virtualenv installs.
 
@@ -63,7 +64,7 @@ After running `graphnav`, every AI agent in the repo has access to:
 ### Optional
 
 ```bash
-graphnav watch     # keep the graph live as you edit
+graphnav watch     # eager mode: rebuild on every save instead of at query time
 graphnav doctor    # diagnose the setup if something looks wrong
 ```
 
@@ -308,6 +309,7 @@ Place a `config.toml` in the project root (or pass `--config PATH`):
 ```toml
 [mono]
 graphify_backend = "claude"        # LLM backend for extraction
+auto_rebuild = true                # rebuild the graph in the background when queries find it stale
 watch_poll_interval = 3.0          # seconds between mtime checks in watch mode
 context_budget_tokens = 2000       # token budget for graphnav context output
 context_top_files = 8              # max files returned by context command

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/cli.py

@@ -104,6 +104,7 @@ def _run_context_command(argv: list[str]) -> None:
             "task": task,
             "skip_patterns": cfg.graph.skip_patterns,
             "query_cfg": cfg.query,
+            "auto_rebuild": cfg.mono.auto_rebuild,
         }
         if args.files is not None:
             kwargs["top_files"] = args.files
@@ -129,6 +130,7 @@ def _run_graph_query_command(kind: str, argv: list[str]) -> None:
 
     cfg = load_config(args.config)
     root = os.path.abspath(args.root)
+    multirepo.maybe_auto_rebuild(root, enabled=cfg.mono.auto_rebuild)
     graph_path = multirepo._overarching_graph_path(root)
     if not os.path.exists(graph_path):
         print(f"Error: no knowledge graph at {graph_path}. Run `graphnav map` first.", file=sys.stderr)
@@ -137,14 +139,21 @@ def _run_graph_query_command(kind: str, argv: list[str]) -> None:
     if kind == "impact":
         from codex_graph.mcp_server import GraphTools
 
-        tools = GraphTools(root, cfg.graph.skip_patterns, query_cfg=cfg.query)
+        tools = GraphTools(root, cfg.graph.skip_patterns, query_cfg=cfg.query, auto_rebuild=False)
         print(tools.impact(args.term))
         sys.exit(0)
 
-    nav = load_bundle(
-        graph_path, cfg.graph.skip_patterns,
-        relation_weights=cfg.query.edge_relation_weights, repo_root=root,
-    ).nav
+    import json as _json
+
+    try:
+        nav = load_bundle(
+            graph_path, cfg.graph.skip_patterns,
+            relation_weights=cfg.query.edge_relation_weights, repo_root=root,
+        ).nav
+    except (_json.JSONDecodeError, KeyError, OSError) as exc:
+        print(f"Error: could not read {graph_path} ({type(exc).__name__}: {exc}).", file=sys.stderr)
+        print("Run `graphnav map` to rebuild the graph.", file=sys.stderr)
+        sys.exit(2)
 
     if kind == "find":
         hits = nav.find_symbols(args.term, k=10)
@@ -284,6 +293,10 @@ def main() -> None:
         except GraphNotFoundError as e:
             print(f"Error: {e}", file=sys.stderr)
             sys.exit(2)
+        except Exception as e:
+            print(f"Error: could not read {graph_path} ({type(e).__name__}: {e}).", file=sys.stderr)
+            print("Run `graphnav map` to rebuild the graph.", file=sys.stderr)
+            sys.exit(2)
 
         ranked = query_files(
             prompt,
@@ -317,5 +330,13 @@ def main() -> None:
         sys.exit(124)
 
 
+def entry() -> None:
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n[graphnav] interrupted", file=sys.stderr)
+        sys.exit(130)
+
+
 if __name__ == "__main__":
-    main()
+    entry()

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/config.py

@@ -51,6 +51,7 @@ class MonoConfig:
     context_budget_tokens: int = 2000
     context_top_files: int = 8
     extra_skip_dirs: list[str] = field(default_factory=list)
+    auto_rebuild: bool = True
 
 
 @dataclass
@@ -129,12 +130,58 @@ def _apply_toml(cfg: Config, data: dict, warnings: list[str] | None = None) -> C
             context_budget_tokens=m.get("context_budget_tokens", cfg.mono.context_budget_tokens),
             context_top_files=m.get("context_top_files", cfg.mono.context_top_files),
             extra_skip_dirs=m.get("extra_skip_dirs", cfg.mono.extra_skip_dirs),
+            auto_rebuild=m.get("auto_rebuild", cfg.mono.auto_rebuild),
         )
     return cfg
 
 
+_NUMERIC_FIELDS = (
+    ("query", "top_k", int), ("query", "community_boost_weight", float),
+    ("query", "bm25_k1", float), ("query", "bm25_b", float),
+    ("query", "edge_boost_weight", float), ("query", "recency_boost_weight", float),
+    ("context", "max_file_chars", int),
+    ("codex", "timeout_seconds", int),
+    ("mono", "watch_poll_interval", float), ("mono", "context_budget_tokens", int),
+    ("mono", "context_top_files", int),
+)
+
+
+def _coerce_types(cfg: Config, warnings: list[str]) -> None:
+    defaults = Config()
+    for section, key, typ in _NUMERIC_FIELDS:
+        value = getattr(getattr(cfg, section), key)
+        if isinstance(value, bool) or not isinstance(value, (int, float)):
+            fallback = getattr(getattr(defaults, section), key)
+            warnings.append(f"{section}.{key} has invalid value {value!r} — using default {fallback}")
+            setattr(getattr(cfg, section), key, fallback)
+        elif typ is int and not isinstance(value, int):
+            setattr(getattr(cfg, section), key, int(value))
+    if not isinstance(cfg.query.edge_relation_weights, dict):
+        warnings.append("query.edge_relation_weights must be a table — ignoring")
+        cfg.query.edge_relation_weights = {}
+    else:
+        for rel in list(cfg.query.edge_relation_weights):
+            w = cfg.query.edge_relation_weights[rel]
+            if isinstance(w, bool) or not isinstance(w, (int, float)):
+                warnings.append(f"query.edge_relation_weights.{rel} has invalid value {w!r} — ignoring")
+                del cfg.query.edge_relation_weights[rel]
+    for section, key in (("mono", "auto_rebuild"), ("context", "show_scores")):
+        value = getattr(getattr(cfg, section), key)
+        if not isinstance(value, bool):
+            fallback = getattr(getattr(Config(), section), key)
+            warnings.append(f"{section}.{key} must be true or false — using default {fallback}")
+            setattr(getattr(cfg, section), key, fallback)
+    for section, key in (("mono", "marker_files"), ("mono", "extra_skip_dirs"), ("graph", "skip_patterns"), ("codex", "extra_args")):
+        value = getattr(getattr(cfg, section), key)
+        if not isinstance(value, list) or any(not isinstance(v, str) for v in value):
+            fallback = getattr(getattr(Config(), section), key)
+            warnings.append(f"{section}.{key} must be a list of strings — using default")
+            setattr(getattr(cfg, section), key, fallback)
+
+
 def _validate(cfg: Config) -> list[str]:
     warnings: list[str] = []
+    _coerce_types(cfg, warnings)
     if cfg.query.top_k < 1:
         warnings.append(f"query.top_k {cfg.query.top_k} clamped to 1")
         cfg.query.top_k = 1
@@ -192,12 +239,20 @@ def load_config_report(explicit_path: str | None = None) -> tuple[Config, str |
 
     source_path: str | None = None
     for path in candidates:
-        if os.path.exists(path):
+        if not os.path.exists(path):
+            continue
+        try:
             with open(path, "rb") as f:
                 data = tomllib.load(f)
-            cfg = _apply_toml(cfg, data, warnings)
+        except (tomllib.TOMLDecodeError, OSError) as exc:
+            warnings.append(f"could not parse {path} ({exc}) — using defaults")
             source_path = path
             break
+        if not explicit_path and not any(section in data for section in _SECTION_TYPES):
+            continue
+        cfg = _apply_toml(cfg, data, warnings)
+        source_path = path
+        break
     else:
         if explicit_path:
             print(f"Warning: config file not found: {explicit_path}", file=sys.stderr)

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/doctor.py

@@ -11,8 +11,8 @@ from codex_graph.multirepo import (
     _graph_meta_path,
     _load_env_file,
     _overarching_graph_path,
-    detect_services,
     find_graphify,
+    resolve_services,
     staleness_note,
 )
 
@@ -104,9 +104,11 @@ def _check_api_key(root: str, cfg: Config) -> CheckResult:
 
 
 def _check_services(root: str, cfg: Config) -> CheckResult:
-    services = detect_services(root, cfg.mono.marker_files, cfg.mono.extra_skip_dirs)
+    services, single = resolve_services(root, cfg.mono.marker_files, cfg.mono.extra_skip_dirs)
     if not services:
-        return CheckResult("fail", "services", "no services detected — add code or marker files to subdirectories")
+        return CheckResult("fail", "services", "no source code found — run graphnav from your project root")
+    if single:
+        return CheckResult("ok", "services", "single project (whole repo mapped as one graph)")
     names = [s.name for s in services]
     shown = ", ".join(names[:MAX_SERVICE_NAMES_SHOWN])
     if len(names) > MAX_SERVICE_NAMES_SHOWN:

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/graph_cache.py

@@ -149,7 +149,7 @@ def _build_bundle(
 ) -> GraphBundle:
     from codex_graph.multirepo import _symbols_by_file
 
-    with open(graph_path) as f:
+    with open(graph_path, encoding="utf-8") as f:
         graph = json.load(f)
     return GraphBundle(
         stamp=stamp,

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/graph_nav.py

@@ -11,7 +11,7 @@ from codex_graph.graph_query import _tokenize
 class GraphNav:
     def __init__(self, graph_path: str, skip_patterns: list[str] | None = None, graph: dict | None = None):
         if graph is None:
-            with open(graph_path) as f:
+            with open(graph_path, encoding="utf-8") as f:
                 graph = json.load(f)
         self.skip = skip_patterns or []
         self._label_index = None
@@ -27,7 +27,10 @@ class GraphNav:
                 self.file2ids[sf].append(nid)
         self.in_edges: dict[object, list] = defaultdict(list)
         self.out_edges: dict[object, list] = defaultdict(list)
-        for e in graph.get("links", []):
+        links = graph.get("links")
+        if links is None:
+            links = graph.get("edges", [])
+        for e in links or []:
             s, t = e.get("source"), e.get("target")
             if s is None or t is None:
                 continue
@@ -104,12 +107,18 @@ class GraphNav:
         return hits
 
     def neighbors(self, symbol: str, k: int = 12) -> dict:
-        q = set(_tokenize(symbol))
-        best, best_ov = None, 0
-        for nid, n in self.id2node.items():
-            ov = len(q & set(_tokenize(n.get("label", ""))))
-            if ov > best_ov:
-                best, best_ov = nid, ov
+        exact = self._labels().get(symbol.lower())
+        if exact:
+            best = exact[0]
+        else:
+            q = set(_tokenize(symbol))
+            best, best_score = None, (0, 0.0)
+            for nid, n in self.id2node.items():
+                toks = set(_tokenize(n.get("label", "")))
+                ov = len(q & toks)
+                score = (ov, ov / (len(toks) or 1))
+                if score > best_score:
+                    best, best_score = nid, score
         fuzzy = False
         if best is None:
             fuzzy_ids = self._fuzzy_ids(symbol, n=1)

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/graph_query.py

@@ -92,7 +92,7 @@ class GraphIndex:
         graph: dict | None = None,
     ):
         if graph is None:
-            with open(graph_path) as f:
+            with open(graph_path, encoding="utf-8") as f:
                 graph = json.load(f)
 
         nodes = graph.get("nodes", [])

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/mcp_server.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import os
 import sys
 
@@ -7,7 +8,11 @@ from codex_graph import GraphNotFoundError
 from codex_graph.config import QueryConfig, load_config
 from codex_graph.graph_cache import DEFAULT_PACK_SKIP_PATTERNS, load_bundle
 from codex_graph.graph_nav import GraphNav
-from codex_graph.multirepo import _overarching_graph_path, build_context_pack_inline
+from codex_graph.multirepo import (
+    _overarching_graph_path,
+    build_context_pack_inline,
+    maybe_auto_rebuild,
+)
 
 MAX_REGION_LINES = 200
 
@@ -31,10 +36,12 @@ class GraphTools:
         root: str,
         skip_patterns: list[str] | None = None,
         query_cfg: QueryConfig | None = None,
+        auto_rebuild: bool = True,
     ):
         self.root = os.path.abspath(root)
         self.skip_patterns = skip_patterns or list(DEFAULT_PACK_SKIP_PATTERNS)
         self.query_cfg = query_cfg or QueryConfig()
+        self.auto_rebuild = auto_rebuild
         self.graph_path = _overarching_graph_path(self.root)
 
     @property
@@ -46,16 +53,17 @@ class GraphTools:
                 relation_weights=self.query_cfg.edge_relation_weights,
                 repo_root=self.root,
             ).nav
-        except GraphNotFoundError:
+        except (GraphNotFoundError, OSError, json.JSONDecodeError, KeyError):
             return None
 
     def graph_context(self, task: str) -> str:
         return build_context_pack_inline(
             root=self.root, task=task, skip_patterns=self.skip_patterns,
-            query_cfg=self.query_cfg,
+            query_cfg=self.query_cfg, auto_rebuild=self.auto_rebuild,
         )
 
     def graph_find(self, query: str) -> str:
+        maybe_auto_rebuild(self.root, enabled=self.auto_rebuild)
         if self.nav is None:
             return _NO_GRAPH
         hits = self.nav.find_symbols(query, k=8)
@@ -68,6 +76,7 @@ class GraphTools:
         return "\n".join(lines)
 
     def graph_neighbors(self, symbol: str) -> str:
+        maybe_auto_rebuild(self.root, enabled=self.auto_rebuild)
         if self.nav is None:
             return _NO_GRAPH
         r = self.nav.neighbors(symbol)
@@ -95,6 +104,7 @@ class GraphTools:
             return f"error: {exc}"
 
     def impact(self, symbol: str) -> str:
+        maybe_auto_rebuild(self.root, enabled=self.auto_rebuild)
         if self.nav is None:
             return _NO_GRAPH
         r = self.nav.neighbors(symbol)
@@ -129,7 +139,10 @@ def serve(root: str = ".", config_path: str | None = None) -> int:
         return 1
 
     cfg = load_config(config_path)
-    tools = GraphTools(os.path.abspath(root), cfg.graph.skip_patterns, query_cfg=cfg.query)
+    tools = GraphTools(
+        os.path.abspath(root), cfg.graph.skip_patterns, query_cfg=cfg.query,
+        auto_rebuild=cfg.mono.auto_rebuild,
+    )
     server = FastMCP("graphnav")
 
     @server.tool()

{graphnav-1.2.2 → graphnav-1.3.0}/codex_graph/multirepo.py

@@ -4,6 +4,7 @@ import json
 import os
 import re
 import shutil
+import signal
 import subprocess
 import sys
 import threading
@@ -39,14 +40,34 @@ def find_graphify() -> str | None:
     return None
 
 
+def _any_subdir_has_marker(
+    root: str,
+    marker_files: list[str],
+    extra_skip_dirs: list[str] | None = None,
+) -> bool:
+    skip_dirs = SKIP_DIRS | frozenset(extra_skip_dirs or ())
+    try:
+        entries = os.listdir(root)
+    except OSError:
+        return False
+    for entry in entries:
+        abs_path = os.path.join(root, entry)
+        if not os.path.isdir(abs_path) or entry in skip_dirs or entry.startswith("."):
+            continue
+        if any(os.path.exists(os.path.join(abs_path, m)) for m in marker_files):
+            return True
+    return False
+
+
 def resolve_services(
     root: str,
     marker_files: list[str],
     extra_skip_dirs: list[str] | None = None,
 ) -> tuple[list[ServiceInfo], bool]:
-    services = detect_services(root, marker_files, extra_skip_dirs)
-    if services:
-        return services, False
+    if _any_subdir_has_marker(root, marker_files, extra_skip_dirs):
+        services = detect_services(root, marker_files, extra_skip_dirs)
+        if services:
+            return services, False
     skip_dirs = SKIP_DIRS | frozenset(extra_skip_dirs or ())
     if _has_source_files(root, skip_dirs=skip_dirs):
         name = os.path.basename(os.path.abspath(root).rstrip(os.sep)) or "repo"
@@ -65,12 +86,12 @@ def _warn(msg: str) -> None:
 
 def _write_if_changed(path: str, content: str) -> bool:
     try:
-        with open(path) as f:
+        with open(path, encoding="utf-8") as f:
             if f.read() == content:
                 return False
-    except OSError:
+    except (OSError, UnicodeDecodeError):
         pass
-    with open(path, "w") as f:
+    with open(path, "w", encoding="utf-8") as f:
         f.write(content)
     return True
 
@@ -104,7 +125,7 @@ def _find_env_file(start: str) -> str | None:
 def _parse_env_file(path: str) -> dict[str, str]:
     env_vars: dict[str, str] = {}
     try:
-        with open(path) as f:
+        with open(path, encoding="utf-8-sig") as f:
             for line in f:
                 line = line.strip()
                 if not line or line.startswith("#") or "=" not in line:
@@ -138,13 +159,22 @@ def _env_file_sources(root: str) -> list[str]:
     return sources
 
 
+_KEY_ALIASES = {
+    "ANTHROPIC_KEY": "ANTHROPIC_API_KEY",
+    "OPENAI_KEY": "OPENAI_API_KEY",
+    "GEMINI_KEY": "GEMINI_API_KEY",
+    "DEEPSEEK_KEY": "DEEPSEEK_API_KEY",
+}
+
+
 def _load_env_file(root: str) -> dict[str, str]:
     env_vars: dict[str, str] = {}
     for path in _env_file_sources(root):
         for key, value in _parse_env_file(path).items():
             env_vars.setdefault(key, value)
-    if "ANTHROPIC_KEY" in env_vars and "ANTHROPIC_API_KEY" not in env_vars:
-        env_vars["ANTHROPIC_API_KEY"] = env_vars["ANTHROPIC_KEY"]
+    for alias, canonical in _KEY_ALIASES.items():
+        if alias in env_vars and canonical not in env_vars:
+            env_vars[canonical] = env_vars[alias]
     return env_vars
 
 
@@ -278,6 +308,81 @@ def run_extract(
     return _stream_proc(proc, timeout)
 
 
+AUTO_REBUILD_COOLDOWN = 60.0
+
+
+def _newest_source_mtime(root: str, max_depth: int = 4) -> float:
+    newest = 0.0
+    base = root.rstrip(os.sep).count(os.sep)
+    for dirpath, dirnames, filenames in os.walk(root):
+        depth = dirpath.count(os.sep) - base
+        if depth >= max_depth:
+            dirnames[:] = []
+        else:
+            dirnames[:] = [
+                d for d in dirnames
+                if d not in SKIP_DIRS and not d.startswith(".")
+            ]
+        for fn in filenames:
+            if os.path.splitext(fn)[1] in SOURCE_EXTENSIONS:
+                try:
+                    mt = os.stat(os.path.join(dirpath, fn)).st_mtime
+                except OSError:
+                    continue
+                if mt > newest:
+                    newest = mt
+    return newest
+
+
+def graph_is_stale(root: str) -> bool:
+    try:
+        graph_mtime = os.stat(_overarching_graph_path(root)).st_mtime
+    except OSError:
+        return True
+    return _newest_source_mtime(root) > graph_mtime + 1.0
+
+
+def maybe_auto_rebuild(root: str, enabled: bool = True) -> bool:
+    if not enabled or os.environ.get("GRAPHNAV_NO_AUTO_REBUILD") == "1":
+        return False
+    root = os.path.abspath(root)
+    if not graph_is_stale(root):
+        return False
+    out_dir = os.path.join(root, "graphify-out")
+    try:
+        os.makedirs(out_dir, exist_ok=True)
+    except OSError:
+        return False
+    pid_path = os.path.join(out_dir, ".graphnav-rebuild.pid")
+    try:
+        st = os.stat(pid_path)
+        with open(pid_path) as f:
+            pid = int(f.read().strip() or 0)
+        if pid > 0:
+            try:
+                os.kill(pid, 0)
+                return False
+            except OSError:
+                pass
+        if time.time() - st.st_mtime < AUTO_REBUILD_COOLDOWN:
+            return False
+    except (OSError, ValueError):
+        pass
+    log_path = os.path.join(out_dir, "auto-rebuild.log")
+    try:
+        with open(log_path, "ab") as log:
+            proc = subprocess.Popen(
+                [sys.executable, "-m", "codex_graph.cli", "map", "--root", root],
+                stdout=log, stderr=log, start_new_session=True,
+                env=_build_subprocess_env(root),
+            )
+        with open(pid_path, "w") as f:
+            f.write(str(proc.pid))
+        return True
+    except OSError:
+        return False
+
+
 def _overarching_graph_path(root: str) -> str:
     return os.path.join(root, "graphify-out", "graph.json")
 
@@ -316,7 +421,7 @@ def write_graph_meta(root: str) -> None:
     meta = {"built_at": time.strftime("%Y-%m-%dT%H:%M:%S"), "git_sha": _git_sha(root)}
     path = _graph_meta_path(root)
     os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w") as f:
+    with open(path, "w", encoding="utf-8") as f:
         json.dump(meta, f, indent=2)
 
 
@@ -325,7 +430,7 @@ def staleness_note(root: str) -> str:
     if not os.path.exists(path):
         return ""
     try:
-        with open(path) as f:
+        with open(path, encoding="utf-8") as f:
             meta = json.load(f)
     except (OSError, json.JSONDecodeError):
         return ""
@@ -371,7 +476,7 @@ def partition_graph(
     overarching_graph_path: str,
     services: list[ServiceInfo],
 ) -> dict[str, int]:
-    with open(overarching_graph_path) as f:
+    with open(overarching_graph_path, encoding="utf-8") as f:
         graph = json.load(f)
 
     service_names = {s.name for s in services}
@@ -414,7 +519,7 @@ def analyze_bridges(
     overarching_graph_path: str,
     services: list[ServiceInfo],
 ) -> dict[str, list[BridgeRow]]:
-    with open(overarching_graph_path) as f:
+    with open(overarching_graph_path, encoding="utf-8") as f:
         graph = json.load(f)
 
     service_names = {s.name for s in services}
@@ -507,7 +612,7 @@ def write_symbols_md(service: ServiceInfo) -> str:
     os.makedirs(out_dir, exist_ok=True)
     path = os.path.join(out_dir, "SYMBOLS.md")
     try:
-        with open(service.graph_path) as f:
+        with open(service.graph_path, encoding="utf-8") as f:
             graph = json.load(f)
     except (OSError, json.JSONDecodeError) as exc:
         _warn(f"could not read {service.graph_path} ({type(exc).__name__}) — symbols index will be empty")
@@ -589,7 +694,7 @@ def _write_managed_block(path: str, content: str) -> None:
     existing = ""
     if os.path.exists(path):
         try:
-            with open(path) as f:
+            with open(path, encoding="utf-8", errors="replace") as f:
                 existing = f.read()
         except OSError:
             existing = ""
@@ -636,9 +741,18 @@ def build_context_pack(
     from codex_graph.graph_query import query_files
 
     root = os.path.abspath(root)
+    if mono_cfg is None:
+        mono_cfg = MonoConfig()
+    rebuild_started = maybe_auto_rebuild(root, enabled=mono_cfg.auto_rebuild)
     overarching_path = _overarching_graph_path(root)
     if not os.path.exists(overarching_path):
         rel = os.path.relpath(overarching_path, root)
+        if rebuild_started:
+            return (
+                f"# Context for: {task}\n\n"
+                "Knowledge graph is being built automatically in the background — "
+                "retry this in ~30s.\n"
+            )
         return (
             f"# Context for: {task}\n\n"
             f"No knowledge graph found at {rel}.\n"
@@ -649,8 +763,6 @@ def build_context_pack(
         skip_patterns = list(DEFAULT_PACK_SKIP_PATTERNS)
     if query_cfg is None:
         query_cfg = QueryConfig()
-    if mono_cfg is None:
-        mono_cfg = MonoConfig()
 
     degraded = False
     try:
@@ -678,6 +790,8 @@ def build_context_pack(
     note = staleness_note(root)
     if note:
         out_lines += [note, ""]
+    if rebuild_started:
+        out_lines += ["_Source files changed — automatic graph rebuild started in the background._", ""]
     if degraded:
         out_lines.append(
             "_Knowledge graph could not be read (corrupt or invalid graph.json) — "
@@ -733,7 +847,7 @@ def build_context_pack(
 
 def _extract_code_windows(abs_path, lines_wanted, before=2, after=14, max_lines=110):
     try:
-        with open(abs_path, errors="replace") as f:
+        with open(abs_path, encoding="utf-8", errors="replace") as f:
             src = f.read().splitlines()
     except OSError:
         return ""
@@ -757,14 +871,22 @@ def _extract_code_windows(abs_path, lines_wanted, before=2, after=14, max_lines=
 
 
 def build_context_pack_inline(
-    root, task, top_files=3, budget_tokens=2500, skip_patterns=None, query_cfg=None
+    root, task, top_files=3, budget_tokens=2500, skip_patterns=None, query_cfg=None,
+    auto_rebuild=True,
 ):
     from codex_graph.graph_cache import DEFAULT_PACK_SKIP_PATTERNS, load_bundle
     from codex_graph.graph_query import query_files
 
     root = os.path.abspath(root)
+    rebuild_started = maybe_auto_rebuild(root, enabled=auto_rebuild)
     overarching_path = _overarching_graph_path(root)
     if not os.path.exists(overarching_path):
+        if rebuild_started:
+            return (
+                f"# Context for: {task}\n\n"
+                "Knowledge graph is being built automatically in the background — "
+                "retry this in ~30s.\n"
+            )
         return f"# Context for: {task}\n\nNo knowledge graph found.\n"
     if skip_patterns is None:
         skip_patterns = list(DEFAULT_PACK_SKIP_PATTERNS)
@@ -797,6 +919,8 @@ def build_context_pack_inline(
     note = staleness_note(root)
     if note:
         out += [note, ""]
+    if rebuild_started:
+        out += ["_Source files changed — automatic graph rebuild started in the background._", ""]
     out.append(
         "## Relevant code (extracted from the knowledge graph — already in context, do not re-open these files)"
     )
@@ -844,7 +968,10 @@ def build_context_pack_inline(
     text = "\n".join(out) + "\n"
     char_budget = max(budget_tokens, 0) * 4
     if char_budget and len(text) > char_budget:
-        text = text[:char_budget].rstrip() + "\n```\n\n_(truncated to budget)_\n"
+        truncated = text[:char_budget].rstrip()
+        if truncated.count("```") % 2 == 1:
+            truncated += "\n```"
+        text = truncated + "\n\n_(truncated to budget)_\n"
     return text
 
 
@@ -904,7 +1031,12 @@ def run_map(
         print("  Ensure an API key is available (e.g. ANTHROPIC_API_KEY or ANTHROPIC_KEY in a .env file).", file=sys.stderr)
         return 1
 
-    bridges = _refresh(root, services, overarching_path, single=single)
+    try:
+        bridges = _refresh(root, services, overarching_path, single=single)
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"Error: extracted graph could not be read ({type(exc).__name__}: {exc}).", file=sys.stderr)
+        print("  Re-run `graphnav map`; if it persists, delete graphify-out/ and try again.", file=sys.stderr)
+        return 1
     total_bridges = sum(len(rows) for rows in bridges.values())
 
     print(f"\nSetup complete. Your AI coding agents are now configured for this repo.")
@@ -950,7 +1082,10 @@ def run_watch(
             print(f"Error: bootstrap extraction failed (exit {rc}).", file=sys.stderr)
             return 1
 
-    _refresh(root, services, overarching_path, single=single)
+    try:
+        _refresh(root, services, overarching_path, single=single)
+    except (OSError, json.JSONDecodeError) as exc:
+        _warn(f"could not read graph.json ({type(exc).__name__}) — will retry as it updates")
 
     def _start_watch() -> subprocess.Popen:
         return subprocess.Popen(
@@ -960,6 +1095,14 @@ def run_watch(
             env=env,
         )
 
+    def _sigterm(_signum, _frame):
+        raise KeyboardInterrupt
+
+    try:
+        signal.signal(signal.SIGTERM, _sigterm)
+    except (ValueError, OSError):
+        pass
+
     watch_proc = _start_watch()
     backoff = RestartBackoff()
     backoff.record_start(time.monotonic())
@@ -985,7 +1128,11 @@ def run_watch(
                     pending_mtime = None
                     ts = time.strftime("%H:%M:%S")
                     print(f"[graphnav] {ts} graph updated — refreshing symbols and bridges ...", file=sys.stderr)
-                    _refresh(root, services, overarching_path, single=single)
+                    try:
+                        _refresh(root, services, overarching_path, single=single)
+                    except (OSError, json.JSONDecodeError) as exc:
+                        _warn(f"could not read graph.json ({type(exc).__name__}) — will retry on next update")
+                        last_mtime = 0.0
                 else:
                     pending_mtime = mtime
             elif mtime != last_mtime:

{graphnav-1.2.2 → graphnav-1.3.0/graphnav.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphnav
-Version: 1.2.2
+Version: 1.3.0
 Summary: Knowledge-graph context injection for AI coding agents in monorepos
 License-Expression: MIT
 Requires-Python: >=3.11

{graphnav-1.2.2 → graphnav-1.3.0}/graphnav.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ graphnav.egg-info/dependency_links.txt
 graphnav.egg-info/entry_points.txt
 graphnav.egg-info/requires.txt
 graphnav.egg-info/top_level.txt
+tests/test_auto_rebuild.py
 tests/test_cli.py
 tests/test_config.py
 tests/test_doctor.py
@@ -25,4 +26,5 @@ tests/test_graph_nav.py
 tests/test_graph_query.py
 tests/test_mcp_server.py
 tests/test_multirepo.py
+tests/test_robustness.py
 tests/test_runner.py

graphnav-1.3.0/graphnav.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graphnav = codex_graph.cli:entry

{graphnav-1.2.2 → graphnav-1.3.0}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphnav"
-version = "1.2.2"
+version = "1.3.0"
 description = "Knowledge-graph context injection for AI coding agents in monorepos"
 license = "MIT"
 requires-python = ">=3.11"
 dependencies = ["graphifyy>=0.8", "mcp>=1.2"]
 
 [project.scripts]
-graphnav = "codex_graph.cli:main"
+graphnav = "codex_graph.cli:entry"
 
 [project.optional-dependencies]
 dev = ["pytest>=8", "anthropic>=0.40"]

graphnav-1.3.0/tests/test_auto_rebuild.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import os
+import time
+from unittest.mock import MagicMock
+
+import pytest
+
+from codex_graph import multirepo
+from codex_graph.config import load_config_report
+from codex_graph.multirepo import graph_is_stale, maybe_auto_rebuild
+from tests.conftest import write_graph
+
+
+@pytest.fixture
+def allow_auto(monkeypatch):
+    monkeypatch.delenv("GRAPHNAV_NO_AUTO_REBUILD", raising=False)
+
+
+@pytest.fixture
+def fake_popen(monkeypatch):
+    proc = MagicMock()
+    proc.pid = 99999999
+    popen = MagicMock(return_value=proc)
+    monkeypatch.setattr(multirepo.subprocess, "Popen", popen)
+    monkeypatch.setattr(multirepo, "_git_sha", lambda root: None)
+    monkeypatch.setattr("codex_graph.graph_cache._git_recency", lambda root: {})
+    return popen
+
+
+def _make_repo(tmp_path, stale: bool):
+    src = tmp_path / "app.py"
+    src.write_text("def main():\n    pass\n")
+    write_graph(tmp_path / "graphify-out" / "graph.json", [], [])
+    graph = tmp_path / "graphify-out" / "graph.json"
+    if stale:
+        os.utime(graph, (time.time() - 100, time.time() - 100))
+    else:
+        os.utime(src, (time.time() - 100, time.time() - 100))
+    return tmp_path
+
+
+class TestStaleness:
+    def test_missing_graph_is_stale(self, tmp_path):
+        (tmp_path / "app.py").write_text("x = 1\n")
+        assert graph_is_stale(str(tmp_path)) is True
+
+    def test_fresh_graph_not_stale(self, tmp_path):
+        _make_repo(tmp_path, stale=False)
+        assert graph_is_stale(str(tmp_path)) is False
+
+    def test_edited_source_is_stale(self, tmp_path):
+        _make_repo(tmp_path, stale=True)
+        assert graph_is_stale(str(tmp_path)) is True
+
+
+class TestMaybeAutoRebuild:
+    def test_spawns_on_stale(self, tmp_path, allow_auto, fake_popen):
+        _make_repo(tmp_path, stale=True)
+        assert maybe_auto_rebuild(str(tmp_path)) is True
+        fake_popen.assert_called_once()
+        argv = fake_popen.call_args[0][0]
+        assert argv[-2:] == ["--root", str(tmp_path)]
+        assert "map" in argv
+        pid_file = tmp_path / "graphify-out" / ".graphnav-rebuild.pid"
+        assert pid_file.read_text() == "99999999"
+
+    def test_no_spawn_when_fresh(self, tmp_path, allow_auto, fake_popen):
+        _make_repo(tmp_path, stale=False)
+        assert maybe_auto_rebuild(str(tmp_path)) is False
+        fake_popen.assert_not_called()
+
+    def test_no_spawn_when_disabled(self, tmp_path, allow_auto, fake_popen):
+        _make_repo(tmp_path, stale=True)
+        assert maybe_auto_rebuild(str(tmp_path), enabled=False) is False
+        fake_popen.assert_not_called()
+
+    def test_env_escape_hatch(self, tmp_path, monkeypatch, fake_popen):
+        monkeypatch.setenv("GRAPHNAV_NO_AUTO_REBUILD", "1")
+        _make_repo(tmp_path, stale=True)
+        assert maybe_auto_rebuild(str(tmp_path)) is False
+        fake_popen.assert_not_called()
+
+    def test_skips_when_rebuild_running(self, tmp_path, allow_auto, fake_popen):
+        _make_repo(tmp_path, stale=True)
+        pid_file = tmp_path / "graphify-out" / ".graphnav-rebuild.pid"
+        pid_file.write_text(str(os.getpid()))
+        assert maybe_auto_rebuild(str(tmp_path)) is False
+        fake_popen.assert_not_called()
+
+    def test_cooldown_after_dead_rebuild(self, tmp_path, allow_auto, fake_popen):
+        _make_repo(tmp_path, stale=True)
+        pid_file = tmp_path / "graphify-out" / ".graphnav-rebuild.pid"
+        pid_file.write_text("999999999")
+        assert maybe_auto_rebuild(str(tmp_path)) is False
+        fake_popen.assert_not_called()
+        old = time.time() - 120
+        os.utime(pid_file, (old, old))
+        assert maybe_auto_rebuild(str(tmp_path)) is True
+        fake_popen.assert_called_once()
+
+
+class TestPackNotes:
+    def test_inline_pack_notes_rebuild(self, tmp_path, allow_auto, fake_popen, monkeypatch):
+        _make_repo(tmp_path, stale=True)
+        write_graph(
+            tmp_path / "graphify-out" / "graph.json",
+            [{"id": "m", "label": "main", "source_file": "app.py",
+              "file_type": "code", "source_location": "L1", "community": 0}],
+            [],
+        )
+        graph = tmp_path / "graphify-out" / "graph.json"
+        os.utime(graph, (time.time() - 100, time.time() - 100))
+        pack = multirepo.build_context_pack_inline(str(tmp_path), "main")
+        assert "automatic graph rebuild started" in pack
+
+    def test_no_graph_pack_reports_building(self, tmp_path, allow_auto, fake_popen):
+        (tmp_path / "app.py").write_text("def main():\n    pass\n")
+        pack = multirepo.build_context_pack_inline(str(tmp_path), "main")
+        assert "being built automatically" in pack
+
+
+class TestConfigKnob:
+    def test_auto_rebuild_default_true(self):
+        cfg, _, _ = load_config_report()
+        assert cfg.mono.auto_rebuild is True
+
+    def test_auto_rebuild_from_toml(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text("[mono]\nauto_rebuild = false\n")
+        monkeypatch.chdir(tmp_path)
+        cfg, _, warnings = load_config_report()
+        assert cfg.mono.auto_rebuild is False
+        assert warnings == []
+
+    def test_wrong_typed_auto_rebuild(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text('[mono]\nauto_rebuild = "yes"\n')
+        monkeypatch.chdir(tmp_path)
+        cfg, _, warnings = load_config_report()
+        assert cfg.mono.auto_rebuild is True
+        assert any("true or false" in w for w in warnings)

{graphnav-1.2.2 → graphnav-1.3.0}/tests/test_cli.py

@@ -123,7 +123,7 @@ class TestContextCommand:
     def test_context_forwards_budget_and_files(self, tmp_path, monkeypatch):
         captured = {}
 
-        def fake_pack(root, task, skip_patterns=None, top_files=None, budget_tokens=None, query_cfg=None):
+        def fake_pack(root, task, skip_patterns=None, top_files=None, budget_tokens=None, query_cfg=None, **kw):
             captured["top_files"] = top_files
             captured["budget_tokens"] = budget_tokens
             return ""

{graphnav-1.2.2 → graphnav-1.3.0}/tests/test_multirepo.py

@@ -1199,12 +1199,11 @@ class TestRunMap:
         monkeypatch.setattr("codex_graph.multirepo.shutil.which", lambda _: "/graphify")
         roots_seen = []
 
-        def fake_detect(root, markers, extra_skip_dirs=None):
+        def fake_resolve(root, markers, extra_skip_dirs=None):
             roots_seen.append(root)
-            return []
+            return [], False
 
-        monkeypatch.setattr("codex_graph.multirepo.detect_services", fake_detect)
-        monkeypatch.setattr("codex_graph.multirepo._has_source_files", lambda *a, **k: False)
+        monkeypatch.setattr("codex_graph.multirepo.resolve_services", fake_resolve)
         run_map(".", MonoConfig())
         assert os.path.isabs(roots_seen[0])
 

graphnav-1.3.0/tests/test_robustness.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import json
+import sys
+
+import pytest
+
+from codex_graph.config import load_config_report
+from codex_graph.graph_nav import GraphNav
+from codex_graph.multirepo import (
+    _load_env_file,
+    _parse_env_file,
+    build_context_pack_inline,
+    resolve_services,
+)
+from tests.conftest import write_graph
+
+
+class TestFlatRepoDetection:
+    def test_src_and_tests_dirs_without_markers_is_single_project(self, tmp_path):
+        (tmp_path / "src").mkdir()
+        (tmp_path / "src" / "main.py").write_text("def main():\n    pass\n")
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "tests" / "test_main.py").write_text("def test_x():\n    pass\n")
+        services, single = resolve_services(str(tmp_path), ["pyproject.toml", "package.json"])
+        assert single is True
+        assert len(services) == 1
+        assert services[0].abs_path == str(tmp_path)
+
+    def test_root_marker_with_tests_dir_is_single_project(self, tmp_path):
+        (tmp_path / "pyproject.toml").touch()
+        (tmp_path / "app.py").write_text("x = 1\n")
+        (tmp_path / "tests").mkdir()
+        (tmp_path / "tests" / "test_app.py").write_text("y = 2\n")
+        services, single = resolve_services(str(tmp_path), ["pyproject.toml"])
+        assert single is True
+
+    def test_subdir_marker_still_monorepo(self, tmp_path):
+        for name in ("backend", "frontend"):
+            d = tmp_path / name
+            d.mkdir()
+            (d / "package.json").touch()
+        services, single = resolve_services(str(tmp_path), ["package.json"])
+        assert single is False
+        assert [s.name for s in services] == ["backend", "frontend"]
+
+    def test_one_marker_subdir_pulls_in_source_only_dirs(self, tmp_path):
+        backend = tmp_path / "backend"
+        backend.mkdir()
+        (backend / "pyproject.toml").touch()
+        shared = tmp_path / "shared"
+        shared.mkdir()
+        (shared / "util.py").write_text("z = 3\n")
+        services, single = resolve_services(str(tmp_path), ["pyproject.toml"])
+        assert single is False
+        assert {s.name for s in services} == {"backend", "shared"}
+
+
+class TestConfigRobustness:
+    def test_malformed_toml_falls_back_to_defaults(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text("[query\ntop_k = 3\n")
+        monkeypatch.chdir(tmp_path)
+        cfg, source, warnings = load_config_report()
+        assert cfg.query.top_k == 5
+        assert any("could not parse" in w for w in warnings)
+
+    def test_foreign_config_toml_ignored(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text('[params]\ntitle = "My Hugo Site"\nbaseURL = "x"\n')
+        monkeypatch.chdir(tmp_path)
+        cfg, source, warnings = load_config_report()
+        assert source is None
+        assert warnings == []
+
+    def test_wrong_typed_value_uses_default(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text('[query]\ntop_k = "five"\n')
+        monkeypatch.chdir(tmp_path)
+        cfg, source, warnings = load_config_report()
+        assert cfg.query.top_k == 5
+        assert any("invalid value" in w for w in warnings)
+
+    def test_wrong_typed_list_uses_default(self, tmp_path, monkeypatch):
+        (tmp_path / "config.toml").write_text('[mono]\nmarker_files = "package.json"\n')
+        monkeypatch.chdir(tmp_path)
+        cfg, source, warnings = load_config_report()
+        assert "pyproject.toml" in cfg.mono.marker_files
+        assert any("list of strings" in w for w in warnings)
+
+    def test_explicit_path_with_no_known_sections_still_loads(self, tmp_path):
+        p = tmp_path / "custom.toml"
+        p.write_text("")
+        cfg, source, warnings = load_config_report(str(p))
+        assert source == str(p)
+
+
+class TestNeighborsExactMatch:
+    def test_exact_label_beats_superstring(self):
+        graph = {
+            "nodes": [
+                {"id": "test_main", "label": "test_main", "source_file": "tests/test_app.py",
+                 "file_type": "code", "source_location": "L1"},
+                {"id": "main", "label": "main", "source_file": "app.py",
+                 "file_type": "code", "source_location": "L5"},
+            ],
+            "links": [],
+        }
+        nav = GraphNav("unused", graph=graph)
+        r = nav.neighbors("main")
+        assert r["symbol"] == "main"
+        assert r["defined_at"] == "app.py:L5"
+
+
+class TestGraphNavEdgesKey:
+    def test_edges_key_fallback(self, tmp_path):
+        graph = {
+            "nodes": [
+                {"id": "a", "label": "alpha_func", "source_file": "a.py",
+                 "file_type": "code", "source_location": "L1"},
+                {"id": "b", "label": "beta_func", "source_file": "b.py",
+                 "file_type": "code", "source_location": "L2"},
+            ],
+            "edges": [{"source": "a", "target": "b", "relation": "calls"}],
+        }
+        nav = GraphNav("unused", graph=graph)
+        r = nav.neighbors("alpha_func")
+        assert r["callees"]
+        assert "beta_func" in r["callees"][0]
+
+
+class TestEnvFileParsing:
+    def test_bom_stripped(self, tmp_path):
+        p = tmp_path / ".env"
+        p.write_bytes("ANTHROPIC_API_KEY=sk-bom\n".encode("utf-8"))
+        env = _parse_env_file(str(p))
+        assert env.get("ANTHROPIC_API_KEY") == "sk-bom"
+
+    def test_openai_key_alias(self, tmp_path, monkeypatch):
+        (tmp_path / ".env").write_text("OPENAI_KEY=sk-oai\n")
+        monkeypatch.chdir(tmp_path)
+        env = _load_env_file(str(tmp_path))
+        assert env.get("OPENAI_API_KEY") == "sk-oai"
+
+
+class TestDoctorFlatRepo:
+    def test_flat_repo_services_check_passes(self, tmp_path, monkeypatch, capsys):
+        from codex_graph import doctor
+
+        (tmp_path / "app.py").write_text("def main():\n    pass\n")
+        write_graph(
+            tmp_path / "graphify-out" / "graph.json",
+            [{"id": "m", "label": "main", "source_file": "app.py",
+              "file_type": "code", "source_location": "L1", "community": 0}],
+            [],
+        )
+        (tmp_path / "graphify-out" / ".graphnav-meta.json").write_text(
+            json.dumps({"built_at": "x", "git_sha": None})
+        )
+        monkeypatch.setattr(doctor, "find_graphify", lambda: "/usr/bin/graphify")
+        monkeypatch.setattr(
+            doctor.subprocess, "run",
+            lambda *a, **k: __import__("subprocess").CompletedProcess(a, 0, stdout="graphify 0.9", stderr=""),
+        )
+        monkeypatch.setenv("ANTHROPIC_API_KEY", "sk-test")
+        rc = doctor.run_doctor(str(tmp_path))
+        out = capsys.readouterr().out
+        assert rc == 0
+        assert "single project" in out
+
+
+class TestCorruptGraphCli:
+    def test_find_with_corrupt_graph_exits_2(self, tmp_path, monkeypatch, capsys):
+        (tmp_path / "graphify-out").mkdir()
+        (tmp_path / "graphify-out" / "graph.json").write_text("{not json")
+        monkeypatch.setattr(
+            sys, "argv", ["graphnav", "find", "anything", "--root", str(tmp_path)]
+        )
+        from codex_graph.cli import main
+
+        with pytest.raises(SystemExit) as exc:
+            main()
+        assert exc.value.code == 2
+        err = capsys.readouterr().err
+        assert "graphnav map" in err
+
+
+class TestInlinePackTruncation:
+    def test_truncation_balances_code_fences(self, tmp_path):
+        nodes = []
+        for i in range(40):
+            name = f"mod_{i}"
+            src = tmp_path / f"{name}.py"
+            src.write_text("\n".join(f"def fn_{j}():\n    pass" for j in range(30)))
+            nodes.append({
+                "id": name, "label": f"search target term {i}", "source_file": f"{name}.py",
+                "file_type": "code", "source_location": "L1", "community": 0,
+            })
+        write_graph(tmp_path / "graphify-out" / "graph.json", nodes, [])
+        pack = build_context_pack_inline(
+            str(tmp_path), "search target term", top_files=8, budget_tokens=100
+        )
+        assert "_(truncated to budget)_" in pack
+        assert pack.count("```") % 2 == 0

graphnav-1.2.2/graphnav.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-graphnav = codex_graph.cli:main