codegraph-engine 2.1.7__py3-none-any.whl → 2.2.0__py3-none-any.whl

codegraph/context.py

@@ -594,6 +594,7 @@ def _get_context_impl(
             if path:
                 c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                 c.row_factory = sqlite3.Row
+                c.execute("PRAGMA busy_timeout = 15000")
                 try:
                     for query in queries:
                         for item in search(
@@ -629,6 +630,7 @@ def _get_context_impl(
                 if path:
                     c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                     c.row_factory = sqlite3.Row
+                    c.execute("PRAGMA busy_timeout = 15000")
                     try:
                         return c.execute(
                             "SELECT route_path, http_method, handler_name, file_path, line, endpoint_id FROM framework_routes"
@@ -665,6 +667,7 @@ def _get_context_impl(
                 if path:
                     c = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
                     c.row_factory = sqlite3.Row
+                    c.execute("PRAGMA busy_timeout = 15000")
                     try:
                         archs.append(get_architecture(c, repo))
                     finally:
@@ -708,6 +711,9 @@ def _get_context_impl(
 
         stage1_candidate_count = len(candidate_dicts)
 
+        # Instantiate ConstraintGuard for hard safety invariants
+        _guard = ConstraintGuard.from_task_spec(task_spec)
+
         # Process framework routes
         route_relationships: list[Relationship] = []
         entry_points_out: list[dict[str, object]] = []
@@ -717,16 +723,26 @@ def _get_context_impl(
             r_path = r["route_path"]
             r_method = r["http_method"]
             ep_id = r["endpoint_id"] or f"{r_method} {r_path}"
+            r_segments = [
+                seg.lower()
+                for seg in str(r_path).split("/")
+                if len(seg) >= 4
+                and not seg.startswith("{")
+                and not seg.startswith("<")
+                and seg.lower() not in {"api", "v1", "v2"}
+            ]
             matches_task = (
                 r_path in task_display_str
                 or ep_id.lower() in task_display_str.lower()
                 or (r_method in task_display_str.upper() and r_path in task_display_str)
+                or task_spec.intent == "ARCHITECTURE"
+                or any(seg in task_display_str.lower() for seg in r_segments)
                 or any(
                     (len(tgt) >= 3 and (tgt.lower() == r["handler_name"].lower() or tgt.lower() in r_path.lower()))
                     for tgt in task_spec.targets
                 )
             )
-            if matches_task:
+            if matches_task and _guard.allows_symbol(str(r["handler_name"])) and _guard.allows_file(str(r["file_path"])):
                 target_symbols.add(r["handler_name"])
                 r_line = r["line"] or 1
                 candidate_dicts.append(
@@ -799,8 +815,108 @@ def _get_context_impl(
                 except Exception:
                     pass
 
-        # Instantiate ConstraintGuard for hard safety invariants
-        _guard = ConstraintGuard.from_task_spec(task_spec)
+        # Seed architectural boundary classes and gateway methods for ARCHITECTURE intent
+        if task_spec.intent == "ARCHITECTURE":
+            try:
+                arch_rows = con.execute(
+                    "SELECT canonical_id, qualified_name, name, kind, path, start_line, end_line "
+                    "FROM symbols WHERE kind = 'class' OR name = 'app'"
+                ).fetchall()
+                for a_row in arch_rows:
+                    a_name = str(a_row["name"])
+                    a_sym = str(a_row["qualified_name"] or a_name)
+                    a_cid = str(a_row["canonical_id"] or "")
+                    a_file = str(a_row["path"] or "")
+                    if (
+                        _guard.allows_symbol(a_sym)
+                        and _guard.allows_symbol(a_name)
+                        and (not a_cid or _guard.allows_canonical_id(a_cid))
+                        and _guard.allows_file(a_file)
+                    ):
+                        target_symbols.add(a_name)
+                        target_symbols.add(a_sym)
+                        candidate_dicts.append(
+                            {
+                                "file": a_file,
+                                "symbol": a_name,
+                                "canonical_id": a_cid,
+                                "start_line": int(a_row["start_line"] or 1),
+                                "end_line": int(a_row["end_line"] or 1),
+                                "score": 0.90,
+                                "relationship": "DEFINES",
+                                "snippet": f"Architectural symbol {a_sym} ({a_row['kind']}) in {a_file}",
+                            }
+                        )
+                if "gateway" in task_display_str.lower():
+                    gw_rows = con.execute(
+                        "SELECT canonical_id, qualified_name, name, kind, path, start_line, end_line "
+                        "FROM symbols WHERE qualified_name LIKE '%Gateway.%'"
+                    ).fetchall()
+                    for g_row in gw_rows:
+                        g_name = str(g_row["name"])
+                        g_sym = str(g_row["qualified_name"] or g_name)
+                        g_cid = str(g_row["canonical_id"] or "")
+                        g_file = str(g_row["path"] or "")
+                        if (
+                            _guard.allows_symbol(g_sym)
+                            and _guard.allows_symbol(g_name)
+                            and (not g_cid or _guard.allows_canonical_id(g_cid))
+                            and _guard.allows_file(g_file)
+                        ):
+                            target_symbols.add(g_name)
+                            target_symbols.add(g_sym)
+                            candidate_dicts.append(
+                                {
+                                    "file": g_file,
+                                    "symbol": g_name,
+                                    "canonical_id": g_cid,
+                                    "start_line": int(g_row["start_line"] or 1),
+                                    "end_line": int(g_row["end_line"] or 1),
+                                    "score": 0.88,
+                                    "relationship": "DEFINES",
+                                    "snippet": f"Gateway method {g_sym} in {g_file}",
+                                }
+                            )
+            except Exception:
+                pass
+
+        # Seed direct methods of resolved class targets
+        for res in _target_resolutions.values():
+            cls_qname = res.qualified_name
+            if cls_qname and res.target_type.value == "CLASS":
+                try:
+                    m_rows = con.execute(
+                        "SELECT canonical_id, qualified_name, name, kind, path, start_line, end_line "
+                        "FROM symbols WHERE qualified_name LIKE ?",
+                        (f"{cls_qname}.%",),
+                    ).fetchall()
+                    for m_row in m_rows:
+                        m_name = str(m_row["name"])
+                        m_sym = str(m_row["qualified_name"] or m_name)
+                        m_cid = str(m_row["canonical_id"] or "")
+                        m_file = str(m_row["path"] or "")
+                        if (
+                            _guard.allows_symbol(m_sym)
+                            and _guard.allows_symbol(m_name)
+                            and (not m_cid or _guard.allows_canonical_id(m_cid))
+                            and _guard.allows_file(m_file)
+                        ):
+                            target_symbols.add(m_name)
+                            target_symbols.add(m_sym)
+                            candidate_dicts.append(
+                                {
+                                    "file": m_file,
+                                    "symbol": m_name,
+                                    "canonical_id": m_cid,
+                                    "start_line": int(m_row["start_line"] or 1),
+                                    "end_line": int(m_row["end_line"] or 1),
+                                    "score": 0.88,
+                                    "relationship": "DEFINES",
+                                    "snippet": f"Method {m_sym} of target class {cls_qname}",
+                                }
+                            )
+                except Exception:
+                    pass
 
         # 5. Graph exploration (callers/callees) & Tests with deterministic seeds
         t_graph_start = time.perf_counter()

codegraph/database/interrogation.py

@@ -748,6 +748,8 @@ def get_db_schema(
     schema: str | None = None,
     *,
     dialect: str | None = None,
+    limit: int | None = None,
+    offset: int = 0,
 ) -> dict[str, Any]:
     """Return the complete repository database schema overview with safe credential redaction."""
     if isinstance(repo_or_dialect, str) and not dialect:
@@ -800,21 +802,42 @@ def get_db_schema(
 
     dialects = sorted({t["dialect"] for t in tables if t.get("dialect")}) or ["UNKNOWN"]
 
-    return redact_payload({
+    safe_tables = tables
+    safe_models = models
+    safe_migrations = migrations
+    safe_cols = columns
+    safe_rels = rels
+
+    if limit is not None:
+        safe_offset = max(0, offset)
+        safe_limit = max(0, limit)
+        safe_tables = tables[safe_offset : safe_offset + safe_limit]
+        safe_models = models[safe_offset : safe_offset + safe_limit]
+        safe_migrations = migrations[safe_offset : safe_offset + safe_limit]
+        safe_cols = columns[: max(safe_limit * 5, 20)]
+        safe_rels = rels[: max(safe_limit * 5, 20)]
+
+    result_dict: dict[str, Any] = {
         "status": "ok",
         "dialects": dialects,
         "table_count": len(tables),
         "column_count": len(columns),
         "model_count": len(models),
         "migration_count": len(migrations),
-        "tables": tables,
-        "columns": columns,
-        "models": models,
-        "relationships": rels,
-        "migrations": migrations,
+        "tables": safe_tables,
+        "columns": safe_cols,
+        "models": safe_models,
+        "relationships": safe_rels,
+        "migrations": safe_migrations,
         "env_variables": env_vars,
         "database_credentials": "REDACTED",
-    })
+    }
+    if limit is not None:
+        result_dict["limit"] = safe_limit
+        result_dict["offset"] = safe_offset
+        result_dict["has_more"] = (safe_offset + len(safe_tables)) < len(tables)
+
+    return redact_payload(result_dict)
 
 
 def get_db_impact(

codegraph/freshness.py

@@ -235,30 +235,68 @@ def check_freshness(
     deleted: list[str] = []
     parse_failed: list[str] = []
 
-    try:
-        rows = con.execute("SELECT path, hash, status FROM files").fetchall()
-    except sqlite3.OperationalError:
-        rows = con.execute("SELECT path, hash, 'ok' AS status FROM files").fetchall()
-
-    for row in rows:
-        rel = str(row["path"])
-        if row["status"] == "parse_failed":
-            parse_failed.append(rel)
-            if rel not in modified:
-                modified.append(rel)
-        abs_path = repository / rel
-        if not abs_path.exists():
-            deleted.append(rel)
-        else:
+    # Fast path 1: Git commit diff (branch switch or commit advance)
+    git_diff_handled = False
+    if cur_commit and idx_commit and cur_commit != idx_commit:
+        diff_out = _run_git(repository, "diff", "--name-status", idx_commit, cur_commit)
+        if diff_out is not None:
+            git_diff_handled = True
+            for line in diff_out.splitlines():
+                parts = line.strip().split(maxsplit=1)
+                if len(parts) == 2:
+                    action, fpath = parts[0], parts[1]
+                    if action.startswith("D"):
+                        deleted.append(fpath)
+                    else:
+                        modified.append(fpath)
+
+    # Fast path 2: Git status when HEAD commit is unchanged
+    if not git_diff_handled and cur_commit and idx_commit and cur_commit == idx_commit:
+        status_out = _run_git(repository, "status", "--porcelain", "--untracked-files=no")
+        if status_out is not None and not status_out.strip():
+            # Working tree has zero tracked changes against HEAD
+            git_diff_handled = True
             try:
-                digest = hashlib.sha256(
-                    abs_path.read_text(encoding="utf-8", errors="replace").encode()
-                ).hexdigest()
-                if digest != row["hash"] and rel not in modified:
-                    modified.append(rel)
-            except OSError:
+                pf_rows = con.execute("SELECT path FROM files WHERE status='parse_failed'").fetchall()
+                for r in pf_rows:
+                    parse_failed.append(str(r[0]))
+                    modified.append(str(r[0]))
+            except sqlite3.OperationalError:
+                pass
+
+    if not git_diff_handled:
+        try:
+            rows = con.execute("SELECT path, hash, status, indexed_at FROM files").fetchall()
+        except sqlite3.OperationalError:
+            try:
+                rows = con.execute("SELECT path, hash, status, 0 AS indexed_at FROM files").fetchall()
+            except sqlite3.OperationalError:
+                rows = con.execute("SELECT path, hash, 'ok' AS status, 0 AS indexed_at FROM files").fetchall()
+
+        for row in rows:
+            rel = str(row["path"])
+            if row["status"] == "parse_failed":
+                parse_failed.append(rel)
                 if rel not in modified:
                     modified.append(rel)
+            abs_path = repository / rel
+            if not abs_path.exists():
+                deleted.append(rel)
+            else:
+                try:
+                    st = abs_path.stat()
+                    # Mtime check: skip reading & hashing files strictly older than indexing time
+                    idx_at = int(row["indexed_at"] or 0)
+                    if idx_at > 0 and int(st.st_mtime) < idx_at and row["status"] != "parse_failed":
+                        continue
+                    digest = hashlib.sha256(
+                        abs_path.read_text(encoding="utf-8", errors="replace").encode()
+                    ).hexdigest()
+                    if digest != row["hash"] and rel not in modified:
+                        modified.append(rel)
+                except OSError:
+                    if rel not in modified:
+                        modified.append(rel)
 
     changed = len(modified) + len(deleted)
     if changed == 0 and not parse_failed and (idx_commit == cur_commit or cur_commit is None):

codegraph/indexing/indexer.py

@@ -493,8 +493,11 @@ class Indexer:
         con = sqlite3.connect(self.db_path)
         con.row_factory = make_compat_row
         con.execute("PRAGMA journal_mode = WAL")
+        con.execute("PRAGMA synchronous = NORMAL")
         con.execute("PRAGMA foreign_keys = ON")
-        con.execute("PRAGMA busy_timeout = 5000")
+        con.execute("PRAGMA busy_timeout = 15000")
+        con.execute("PRAGMA cache_size = -64000")
+        con.execute("PRAGMA temp_store = MEMORY")
         self._ensure_schema(con)
         return con
 
@@ -538,9 +541,13 @@ class Indexer:
                 pass
             con.commit()
         else:
-            # Idempotently ensure all tables from SCHEMA exist
-            con.executescript(SCHEMA)
-            con.commit()
+            existing_core = con.execute(
+                "SELECT count(*) FROM sqlite_master WHERE type='table' "
+                "AND name IN ('files', 'symbols', 'graph_edges', 'db_tables', 'runtime_traces')"
+            ).fetchone()[0]
+            if existing_core < 5:
+                con.executescript(SCHEMA)
+                con.commit()
 
     def _migrate_schema(
         self, con: sqlite3.Connection, from_version: int, to_version: int

codegraph/installer.py

@@ -201,12 +201,15 @@ class InstallerReport:
             out["error"] = self.error
         return out
 
-    def format_preview_human(self) -> str:
+    def format_preview_human(self, *, unicode_override: bool | None = None) -> str:
         """Render the interactive preview banner before confirmation."""
+        from codegraph.cli_output import get_cli_symbols
+
+        sym = get_cli_symbols(unicode_override=unicode_override)
         lines: list[str] = ["CodeGraph Installer", ""]
         lines.append("Detected agents:")
         for da in self.detected_agents:
-            mark = "✓" if da.detected else "✗"
+            mark = sym.ok if da.detected else sym.error
             lines.append(f"  {mark} {da.display_name}")
 
         lines.append("")
@@ -221,11 +224,11 @@ class InstallerReport:
         lines.append("")
         lines.append("Installation scope:")
         if self.location == "global":
-            lines.append("  (•) Global")
-            lines.append("  ( ) Current project")
+            lines.append(f"  {sym.radio_on} Global")
+            lines.append(f"  {sym.radio_off} Current project")
         else:
-            lines.append("  ( ) Global")
-            lines.append("  (•) Current project")
+            lines.append(f"  {sym.radio_off} Global")
+            lines.append(f"  {sym.radio_on} Current project")
 
         lines.append("")
         lines.append("Changes to be made:")
@@ -234,8 +237,11 @@ class InstallerReport:
         lines.append("  + CodeGraph skill/rules")
         return "\n".join(lines)
 
-    def format_human(self) -> str:
+    def format_human(self, *, unicode_override: bool | None = None) -> str:
         """Render concise, professional human-readable output."""
+        from codegraph.cli_output import get_cli_symbols
+
+        sym = get_cli_symbols(unicode_override=unicode_override)
         if self.error is not None:
             err_lines = [
                 f"Error [{self.error.get('code', 'ERROR')}]: {self.error.get('message', '')}",
@@ -256,10 +262,14 @@ class InstallerReport:
 
         if self.status == "dry_run":
             if self.operation == "install":
-                lines.append(self.format_preview_human())
+                lines.append(self.format_preview_human(unicode_override=unicode_override))
                 lines.append("")
             else:
-                title = "CodeGraph Uninstaller (Dry Run)" if self.operation == "uninstall" else "CodeGraph Uninit (Dry Run)"
+                title = (
+                    "CodeGraph Uninstaller (Dry Run)"
+                    if self.operation == "uninstall"
+                    else "CodeGraph Uninit (Dry Run)"
+                )
                 lines.append(title)
                 lines.append("")
 
@@ -295,15 +305,15 @@ class InstallerReport:
 
         if self.operation == "install":
             for r_msg in self.repairs:
-                lines.append(f"↻ Repaired: {r_msg}")
+                lines.append(f"{sym.repair} Repaired: {r_msg}")
             for w_msg in self.warnings:
-                lines.append(f"! Warning: {w_msg}")
+                lines.append(f"{sym.warn} Warning: {w_msg}")
 
-            lines.append("✓ CodeGraph installed")
+            lines.append(f"{sym.ok} CodeGraph installed")
             if self.verification is not None:
-                v_mcp = "✓" if self.verification.mcp_config_verified else "✗"
-                v_inst = "✓" if self.verification.instructions_verified else "✗"
-                v_srv = "✓" if self.verification.mcp_server_health_verified else "✗"
+                v_mcp = sym.ok if self.verification.mcp_config_verified else sym.error
+                v_inst = sym.ok if self.verification.instructions_verified else sym.error
+                v_srv = sym.ok if self.verification.mcp_server_health_verified else sym.error
                 lines.append(f"{v_mcp} MCP configuration verified")
                 lines.append(f"{v_inst} Agent instructions verified")
                 lines.append(f"{v_srv} MCP server health verified")
@@ -319,23 +329,23 @@ class InstallerReport:
 
         if self.operation == "uninstall":
             for w_msg in self.warnings:
-                lines.append(f"! Warning: {w_msg}")
+                lines.append(f"{sym.warn} Warning: {w_msg}")
             if removed or modified:
                 for c in [*removed, *modified]:
                     verb = "Removed" if c.action == "remove" else "Updated"
-                    lines.append(f"✓ {verb} {c.display_path}")
+                    lines.append(f"{sym.ok} {verb} {c.display_path}")
             else:
-                lines.append("✓ No CodeGraph agent integrations needed removal")
-            lines.append("✓ CodeGraph agent integration uninstalled")
+                lines.append(f"{sym.ok} No CodeGraph agent integrations needed removal")
+            lines.append(f"{sym.ok} CodeGraph agent integration uninstalled")
             return "\n".join(lines)
 
         # uninit
         if removed:
             for c in removed:
-                lines.append(f"✓ Removed {c.display_path}")
+                lines.append(f"{sym.ok} Removed {c.display_path}")
         else:
-            lines.append("✓ No CodeGraph index files present")
-        lines.append("✓ Project CodeGraph index removed")
+            lines.append(f"{sym.ok} No CodeGraph index files present")
+        lines.append(f"{sym.ok} Project CodeGraph index removed")
         return "\n".join(lines)
 
 
@@ -1351,6 +1361,33 @@ def run_install(
         allow_malformed_repair=allow_malformed_repair,
     )
 
+    from codegraph.process_lifecycle import (
+        discover_codegraph_processes,
+        stop_codegraph_processes,
+    )
+
+    proc_discovery = discover_codegraph_processes(clean_stale=not dry_run)
+    current_pid = os.getpid()
+    other_active = [
+        p for p in proc_discovery.active_processes if p.record.pid != current_pid
+    ]
+    orphaned_procs = [p for p in other_active if p.orphaned]
+    live_procs = [p for p in other_active if not p.orphaned]
+
+    if orphaned_procs and dry_run:
+        pids_str = ", ".join(str(p.record.pid) for p in orphaned_procs)
+        warnings.append(
+            f"Orphaned CodeGraph process(es) detected (PID: {pids_str}); "
+            "run 'codegraph stop' or 'codegraph install' to clean up."
+        )
+    if live_procs:
+        pids_str = ", ".join(str(p.record.pid) for p in live_procs)
+        warnings.append(
+            f"Active CodeGraph process(es) running (PID: {pids_str}). "
+            "Before upgrading ('pip install --upgrade codegraph-engine'), run 'codegraph stop' "
+            "to prevent executable file lock errors (WinError 32)."
+        )
+
     preview_report = InstallerReport(
         status="dry_run" if dry_run else "ok",
         operation="install",
@@ -1383,6 +1420,12 @@ def run_install(
                 files_changed=False,
             )
 
+    if orphaned_procs:
+        stop_rep = stop_codegraph_processes(only_orphaned=True)
+        stopped_cnt = sum(1 for item in stop_rep.stopped_processes if item.stopped)
+        if stopped_cnt > 0:
+            repairs.append(f"Stopped {stopped_cnt} orphaned CodeGraph background process(es).")
+
     applied = _apply_planned_changes_atomically(changes)
     ver = verify_installation(
         base_root=base_root,
@@ -1545,6 +1588,13 @@ def run_uninstall(
                 files_changed=False,
             )
 
+    from codegraph.process_lifecycle import stop_codegraph_processes
+
+    stop_codegraph_processes(
+        repository=None if scope == "global" else effective_ws,
+        stop_all=(scope == "global"),
+    )
+
     applied = _apply_planned_changes_atomically(planned)
     return InstallerReport(
         status="ok",

codegraph/interrogation.py

@@ -1979,6 +1979,8 @@ def list_routes(
     framework: str | None = None,
     method: str | None = None,
     path: str | None = None,
+    limit: int | None = None,
+    offset: int = 0,
 ) -> dict[str, Any]:
     """Expose application routes discovered from the repository."""
     unindexed = check_index_available(con, repository)
@@ -2028,10 +2030,27 @@ def list_routes(
         for r in rows
     ]
 
+    total_count = len(routes)
+    if limit is not None:
+        safe_offset = max(0, offset)
+        safe_limit = max(0, limit)
+        paginated_routes = routes[safe_offset : safe_offset + safe_limit]
+        return {
+            "status": "ok",
+            **meta,
+            "count": len(paginated_routes),
+            "total_count": total_count,
+            "limit": safe_limit,
+            "offset": safe_offset,
+            "has_more": (safe_offset + len(paginated_routes)) < total_count,
+            "routes": paginated_routes,
+        }
+
     return {
         "status": "ok",
         **meta,
         "count": len(routes),
+        "total_count": total_count,
         "routes": routes,
     }