code-graph-rag 0.4.5__tar.gz → 0.4.19__tar.gz

{code_graph_rag-0.4.5/code_graph_rag.egg-info → code_graph_rag-0.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.4.5
+Version: 0.4.19
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -41,7 +41,7 @@ Requires-Dist: pathspec>=1.0.4
 Requires-Dist: pygments>=2.20.0
 Requires-Dist: certifi>=2026.10.23
 Requires-Dist: regex>=2024.11.6
-Requires-Dist: cgr-graph-rs<0.2,>=0.1.4; platform_python_implementation == "CPython" and ((sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or sys_platform == "darwin" or (sys_platform == "win32" and platform_machine == "AMD64"))
+Requires-Dist: cgr-graph-rs<0.2,>=0.1.5; platform_python_implementation == "CPython" and ((sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or sys_platform == "darwin" or (sys_platform == "win32" and platform_machine == "AMD64"))
 Provides-Extra: test
 Requires-Dist: jedi>=0.19; extra == "test"
 Requires-Dist: pytest>=8.4.1; extra == "test"

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/README.md

@@ -61,7 +61,10 @@ Code-Graph-RAG parses a multi-language codebase with Tree-sitter, sharpened by c
 ## Latest News 🔥
 
 <!-- SECTION:latest_news -->
-- **MiniMax Models Added**: Current MiniMax text models have been included.
+- **Quiet Mode Enhancement**: The `--quiet` flag for the CLI now suppresses the scanning line for dead code and duplicates, providing a cleaner output.
+- **Context Budget Fix**: The system now correctly handles cases where a target doesn't fit within the allocated budget, preventing unexpected behaviour.
+- **Code Quality**: Changes have been made to report decorator and modifier changes that affect method calls and to ensure submodule grammars are loaded correctly.
+- **CGR Prune Feature**: A new `cgr prune` functionality has been added to remove projects where the root no longer exists.
 <!-- /SECTION:latest_news -->
 
 See [NEWS.md](NEWS.md) for the full history.

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19/code_graph_rag.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-graph-rag
-Version: 0.4.5
+Version: 0.4.19
 Summary: The ultimate RAG for your monorepo. Query, understand, and edit multi-language codebases with the power of AI and knowledge graphs
 License-Expression: MIT
 Keywords: rag,retrieval-augmented-generation,knowledge-graph,code-analysis,tree-sitter,mcp,mcp-server,llm,graph-database,semantic-search,codebase,memgraph,developer-tools,monorepo
@@ -41,7 +41,7 @@ Requires-Dist: pathspec>=1.0.4
 Requires-Dist: pygments>=2.20.0
 Requires-Dist: certifi>=2026.10.23
 Requires-Dist: regex>=2024.11.6
-Requires-Dist: cgr-graph-rs<0.2,>=0.1.4; platform_python_implementation == "CPython" and ((sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or sys_platform == "darwin" or (sys_platform == "win32" and platform_machine == "AMD64"))
+Requires-Dist: cgr-graph-rs<0.2,>=0.1.5; platform_python_implementation == "CPython" and ((sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or sys_platform == "darwin" or (sys_platform == "win32" and platform_machine == "AMD64"))
 Provides-Extra: test
 Requires-Dist: jedi>=0.19; extra == "test"
 Requires-Dist: pytest>=8.4.1; extra == "test"

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/code_graph_rag.egg-info/SOURCES.txt

@@ -62,6 +62,7 @@ codebase_rag/schema_builder.py
 codebase_rag/schema_parse.py
 codebase_rag/schemas.py
 codebase_rag/sensitive_paths.py
+codebase_rag/source_checkout.py
 codebase_rag/sql_names.py
 codebase_rag/sqlite_vectors.py
 codebase_rag/structural_check.py
@@ -357,9 +358,12 @@ codebase_rag/parsers/php/utils.py
 codebase_rag/parsers/py/__init__.py
 codebase_rag/parsers/py/ast_analyzer.py
 codebase_rag/parsers/py/class_aliases.py
+codebase_rag/parsers/py/definition_index.py
 codebase_rag/parsers/py/expression_analyzer.py
+codebase_rag/parsers/py/flow_bindings.py
 codebase_rag/parsers/py/forward_refs.py
 codebase_rag/parsers/py/overloads.py
+codebase_rag/parsers/py/patterns.py
 codebase_rag/parsers/py/receiver_rebinding.py
 codebase_rag/parsers/py/type_inference.py
 codebase_rag/parsers/py/utils.py

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/code_graph_rag.egg-info/requires.txt

@@ -23,7 +23,7 @@ certifi>=2026.10.23
 regex>=2024.11.6
 
 [:platform_python_implementation == "CPython" and ((sys_platform == "linux" and (platform_machine == "x86_64" or platform_machine == "aarch64")) or sys_platform == "darwin" or (sys_platform == "win32" and platform_machine == "AMD64"))]
-cgr-graph-rs<0.2,>=0.1.4
+cgr-graph-rs<0.2,>=0.1.5
 
 [ast-grep]
 ast-grep-py>=0.51.0

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/codebase_rag/cli.py

@@ -8,6 +8,7 @@ import subprocess
 import sys
 import tempfile
 import time
+import uuid
 from collections.abc import Callable, Coroutine, Generator, Iterable
 from contextlib import ExitStack, contextmanager
 from fnmatch import fnmatch
@@ -20,6 +21,7 @@ import click
 import typer
 from loguru import logger
 from rich.console import Console
+from rich.markup import escape
 from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
@@ -81,10 +83,13 @@ from .sync_guard import SyncRefusedError, mark_sync_incomplete, release_project_
 from .sync_guard import clear_sync_incomplete as _clear_sync_incomplete
 from .sync_guard import partial_graph_refusal as _partial_graph_refusal
 from .sync_guard import project_owner_refusal as _project_owner_refusal
+from .sync_guard import retire_exited_runs as _retire_exited_runs
 from .sync_guard import retire_stranded_runs as _retire_stranded_runs
 from .sync_guard import stranded_runs as _stranded_runs
 from .sync_guard import sync_marker_params as _sync_marker_params
 from .sync_guard import sync_owner as _sync_owner
+from .sync_guard import take_over_runs as _take_over_runs
+from .sync_guard import writing_runs as _writing_runs
 from .sync_lock import SyncLockError, repo_sync_lock
 from .tools.health_checker import HealthChecker
 from .tools.language import cli as language_cli
@@ -110,6 +115,7 @@ from .utils.path_utils import (
     project_roots_from_rows,
     projects_sharing_root,
     resolve_repo_path,
+    root_proven_missing,
     unwritable_output_reason,
 )
 from .utils.process_owner import pid_may_be_running, process_host
@@ -1066,13 +1072,15 @@ def _clear_deleted_project_markers(
     a sync that failed before the delete keeps the project in `cgr status`
     as interrupted. A marker goes only when its run cannot still be writing:
     the CLI sync's once that sync provably stopped (PR #2532 review: a sync
-    still running would otherwise write on unguarded), and any run's that
-    never wrote the graph. A run that had begun writing owns its marker
-    (#1709). Best effort, like `_clear_sync_incomplete`: the project is
-    deleted.
+    still running would otherwise write on unguarded), any run's whose
+    process provably exited (#2479), and any run's that never wrote the
+    graph. A run that had begun writing and may still be alive owns its
+    marker (#1709). Best effort, like `_clear_sync_incomplete`: the project
+    is deleted.
     """
     try:
         kept = _clear_stopped_sync_marker(ingestor, project_name)
+        _retire_exited_runs(ingestor, project_name)
         ingestor.execute_write(
             cq.CYPHER_RECOVER_PROJECT_INCOMPLETE,
             {cs.KEY_PROJECT_NAME: project_name},
@@ -1336,20 +1344,30 @@ def _resolve_and_validate_repo(repo_path: str | None) -> Path:
 
 
 def _cleanup_project_embeddings(
-    ingestor: MemgraphIngestor, project_name: str, projects: Iterable[str]
-) -> None:
-    rows = ingestor.fetch_all(
-        cs.CYPHER_QUERY_PROJECT_NODE_IDS,
-        {cs.KEY_PROJECT_NAME: project_name},
-    )
+    ingestor: MemgraphIngestor,
+    project_name: str,
+    projects: Iterable[str],
+    node_rows: list[ResultRow] | None = None,
+) -> bool:
+    """Delete the project's vectors; False when the store reports a miss.
+
+    The rows may be supplied pre-fetched: prune reads the ids before the
+    conditional purge fires, because once the graph is deleted no query can
+    recover them.
+    """
+    if node_rows is None:
+        node_rows = ingestor.fetch_all(
+            cs.CYPHER_QUERY_PROJECT_NODE_IDS,
+            {cs.KEY_PROJECT_NAME: project_name},
+        )
     node_ids: list[int] = []
-    for row in rows:
+    for row in node_rows:
         node_id = row.get(cs.KEY_NODE_ID)
         if isinstance(node_id, int):
             node_ids.append(node_id)
     # A project nested under this one (`svc.v2` under `svc`) keeps its
     # vectors, which the prefix-scoped node-id read also names.
-    delete_project_embeddings(
+    return delete_project_embeddings(
         project_name, node_ids, nested_project_names(project_name, projects)
     )
 
@@ -2600,9 +2618,10 @@ def status_command() -> None:
             cs.CLI_STATUS_SYNCS_NONE.format(endpoint=status.memgraph_endpoint)
         )
         return
+    missing = _missing_root_candidates({sync.name: sync.root_path for sync in syncs})
     app_context.console.print(cs.CLI_STATUS_SYNCS_HEADER)
     for sync in syncs:
-        app_context.console.print(_sync_row(sync))
+        app_context.console.print(_sync_row(sync, sync.name in missing))
 
 
 def _stamp_text(stamp: ResultValue | None) -> str | None:
@@ -2631,23 +2650,29 @@ def _project_syncs() -> list[ProjectSync] | None:
         for row in projects
         if row.get(cs.KEY_NAME)
     }
+    roots = project_roots_from_rows(projects)
     interrupted = {str(row["project"]) for row in markers if row.get("project")}
     return [
         ProjectSync(
             name=name,
             last_synced_at=_stamp_text(synced_at.get(name)),
             interrupted=name in interrupted,
+            root_path=roots.get(name),
         )
         for name in sorted(synced_at.keys() | interrupted)
     ]
 
 
-def _sync_row(sync: ProjectSync) -> str:
+def _sync_row(sync: ProjectSync, root_missing: bool = False) -> str:
     details: list[str] = []
     if sync.last_synced_at:
         details.append(cs.CLI_STATUS_SYNC_TIME.format(time=sync.last_synced_at))
     elif not sync.interrupted:
         details.append(cs.CLI_STATUS_SYNC_NOT_RECORDED)
+    if sync.root_path:
+        details.append(cs.CLI_STATUS_SYNC_ROOT.format(root=escape(sync.root_path)))
+    if root_missing:
+        details.append(style(cs.CLI_STATUS_ROOT_MISSING, cs.Color.RED))
     if sync.interrupted:
         details.append(
             cs.CLI_STATUS_SYNC_MARKED.format(marker=cs.CLI_STATUS_SYNC_INCOMPLETE)
@@ -2788,6 +2813,16 @@ def context_command(
     if payload["resolved"] is None:
         typer.echo(cs.CONTEXT_UNRESOLVED.format(target=target), err=True)
         raise typer.Exit(code=1)
+    # Only the target's own trim marks a slice truncated, so truncated and
+    # empty means not even its first line fitted.
+    if payload["truncated"] and not payload["pieces"]:
+        typer.echo(
+            cs.CONTEXT_TARGET_OVER_BUDGET.format(
+                target=payload["resolved"], budget=budget
+            ),
+            err=True,
+        )
+        raise typer.Exit(code=1)
 
 
 @app.command(
@@ -3172,7 +3207,8 @@ def _emit_dead_code(
 def _notice_single_project_endpoint_roots(show_progress: bool) -> None:
     """Endpoint roots off on a graph holding one project: every endpoint
     reads as uncalled. Stdout carries the JSON payload when that format is
-    chosen (local review P1), so the notice goes to stderr then."""
+    chosen (local review P1), and only the table under --quiet, so the
+    notice goes to stderr then."""
     if show_progress:
         app_context.console.print(
             style(cs.CLI_DEADCODE_SINGLE_PROJECT_ENDPOINTS, cs.Color.YELLOW)
@@ -3244,7 +3280,11 @@ def dead_code(
     from .dead_code import collect_dead_code_with_coverage
 
     chosen = _scan_project_option(project, project_name)
-    show_progress = output_format == cs.DeadCodeFormat.TABLE and output is None
+    show_progress = (
+        output_format == cs.DeadCodeFormat.TABLE
+        and output is None
+        and not settings.QUIET
+    )
     if show_progress:
         app_context.console.print(style(cs.CLI_DEADCODE_CONNECTING, cs.Color.CYAN))
 
@@ -3657,7 +3697,11 @@ def duplicates(
     from .duplicates import collect_duplicates_with_coverage
 
     chosen = _scan_project_option(project, project_name)
-    show_progress = output_format == cs.DuplicatesFormat.TABLE and output is None
+    show_progress = (
+        output_format == cs.DuplicatesFormat.TABLE
+        and output is None
+        and not settings.QUIET
+    )
     if show_progress:
         app_context.console.print(style(cs.CLI_DUPLICATES_CONNECTING, cs.Color.CYAN))
 
@@ -3838,5 +3882,299 @@ def delete_project(
     )
 
 
+def _missing_root_candidates(roots: dict[str, str | None]) -> dict[str, str]:
+    """Projects whose recorded root is provably gone (issue #2479).
+
+    The checkout cgr itself runs from is never a candidate, whatever the
+    stat says. A shell can survive its own directory being deleted, so a
+    dead cwd reads as an unknown, not as an exemption: the question is
+    undeterminable and nothing is a candidate.
+    """
+    try:
+        cwd = Path.cwd().resolve()
+    except OSError:
+        return {}
+    missing: dict[str, str] = {}
+    for project_name, root in roots.items():
+        if not root:
+            continue
+        try:
+            here = Path(root).resolve() == cwd
+        except (OSError, RuntimeError):
+            # A symlink loop cannot be resolved: undeterminable, so live.
+            continue
+        if here:
+            continue
+        if root_proven_missing(root):
+            missing[project_name] = root
+    return missing
+
+
+def _report_prune_candidates(candidates: dict[str, str]) -> None:
+    if not candidates:
+        app_context.console.print(style(cs.CLI_MSG_PRUNE_NO_CANDIDATES, cs.Color.GREEN))
+        return
+    app_context.console.print(cs.CLI_MSG_PRUNE_CANDIDATES)
+    for project_name, root in sorted(candidates.items()):
+        app_context.console.print(
+            cs.CLI_MSG_PRUNE_CANDIDATE.format(
+                project_name=project_name, root=escape(root)
+            )
+        )
+
+
+def _report_prune_failure(project_name: str, error: Exception) -> None:
+    message = cs.CLI_ERR_PRUNE_FAILED.format(project_name=project_name, error=error)
+    app_context.console.print(style(message, cs.Color.RED))
+    logger.exception(message)
+
+
+def _clear_own_marker(
+    ingestor: MemgraphIngestor, project_name: str, run_id: str
+) -> None:
+    # Only a verified purge takes prune's marker off: one that failed keeps
+    # it, standing for the exited runs' markers it replaced. Best effort, as
+    # the purge is done.
+    try:
+        ingestor.execute_write(
+            cq.CYPHER_CLEAR_PROJECT_INCOMPLETE,
+            {cs.KEY_PROJECT_NAME: project_name, cs.KEY_RUN_ID: run_id},
+        )
+    except Exception as exc:
+        logger.warning(
+            ls.CLI_DELETE_MARKER_NOT_CLEARED.format(project=project_name, error=exc)
+        )
+
+
+def _purge_left_nothing(
+    ingestor: MemgraphIngestor, project_name: str, run_id: str
+) -> bool:
+    """Whether a fresh read finds nothing of the project left (#2479).
+
+    Nothing left means no Project, nothing under its name, and no run of it
+    writing: a sync that began writing since the delete may own what the
+    vector cleanup that follows would take. Raises when the graph cannot be
+    read; an empty count reads as not proven.
+    """
+    if project_name in ingestor.list_projects():
+        return False
+    if _writing_runs(ingestor, project_name, run_id).live:
+        return False
+    rows = ingestor.fetch_all(
+        cq.CYPHER_COUNT_PROJECT_NODES,
+        {
+            cs.KEY_PROJECT_NAME: project_name,
+            cs.KEY_PROJECT_PREFIX: f"{project_name}{cs.SEPARATOR_DOT}",
+        },
+    )
+    counts = [row.get(cs.KEY_RESIDUAL_NODES) for row in rows]
+    return bool(counts) and all(count == 0 for count in counts)
+
+
+def _prune_projects(
+    ingestor: MemgraphIngestor, candidates: dict[str, str], projects: list[str]
+) -> tuple[list[str], list[str]]:
+    """Prune each candidate and verify the purge against a fresh graph read.
+
+    Returns the names verified as purged and the names whose removal could
+    not be verified; the caller reports the second list as failures, never
+    as successes, and a skipped candidate is in neither.
+    """
+    pruned: list[str] = []
+    failures: list[str] = []
+    for project_name, root in sorted(candidates.items()):
+        outcome = _prune_one(ingestor, project_name, root, projects)
+        if outcome == cs.PruneOutcome.PRUNED:
+            pruned.append(project_name)
+        elif outcome == cs.PruneOutcome.FAILED:
+            failures.append(project_name)
+    return pruned, failures
+
+
+def _prune_one(
+    ingestor: MemgraphIngestor, project_name: str, root: str, projects: list[str]
+) -> cs.PruneOutcome:
+    """Prune one candidate (#2479).
+
+    The delete is conditional on the project still naming the root this run
+    checked, and on no run of it writing, inside the delete statement
+    itself, so a concurrent sync repointing the project's root_path, or one
+    starting to write it, is skipped, not destroyed. A checkout
+    recreated at the old path is still only narrowed by the existence
+    re-check. A purge that cannot be proven complete -- the project still
+    listed, or anything left under its name -- is a failure, never a
+    success. A proven purge then takes what `delete-project` takes after its
+    delete: the project's notes and its incomplete-run markers, which would
+    otherwise keep it in `cgr status`.
+    """
+    if not root_proven_missing(root):
+        _say(cs.CLI_WARN_PRUNE_ROOT_BACK.format(project_name=project_name))
+        return cs.PruneOutcome.SKIPPED
+    run_id = f"{cs.PRUNE_RUN_ID_PREFIX}{uuid.uuid4().hex}"
+    try:
+        # A run of the same name may be writing from another checkout or
+        # machine: its marker is the one signal it gives. One whose process
+        # provably exited does not hold the project: prune takes its place,
+        # so a sync that died with its checkout is not a reason to keep it.
+        runs = _writing_runs(ingestor, project_name, run_id)
+        if runs.live:
+            _say(cs.CLI_WARN_PRUNE_RUN_WRITING.format(project_name=project_name))
+            return cs.PruneOutcome.SKIPPED
+        _take_over_runs(ingestor, project_name, run_id, runs.exited)
+        node_rows = _purge_if_root(ingestor, project_name, root, run_id)
+    except GraphUnavailableError:
+        raise
+    except Exception as e:
+        _report_prune_failure(project_name, e)
+        return cs.PruneOutcome.FAILED
+    if node_rows is None:
+        _say(cs.CLI_WARN_PRUNE_ROOT_CHANGED.format(project_name=project_name))
+        return cs.PruneOutcome.SKIPPED
+    try:
+        verified = _purge_left_nothing(ingestor, project_name, run_id)
+    except GraphUnavailableError:
+        raise
+    except Exception as e:
+        _report_prune_failure(project_name, e)
+        return cs.PruneOutcome.FAILED
+    if not verified:
+        _say(
+            cs.CLI_ERR_PRUNE_VERIFY_FAILED.format(project_name=project_name),
+            cs.Color.RED,
+        )
+        return cs.PruneOutcome.FAILED
+    _delete_pruned_vectors(ingestor, project_name, projects, node_rows)
+    if not prune_orphaned_glosses(ingestor, project_name):
+        _say(cs.CLI_WARN_GLOSSES_NOT_PRUNED.format(project_name=project_name))
+    _clear_own_marker(ingestor, project_name, run_id)
+    _clear_deleted_project_markers(ingestor, project_name)
+    _say(cs.CLI_MSG_PROJECT_PRUNED.format(project_name=project_name), cs.Color.GREEN)
+    return cs.PruneOutcome.PRUNED
+
+
+def _say(message: str, color: cs.Color = cs.Color.YELLOW) -> None:
+    app_context.console.print(style(message, color))
+
+
+def _purge_if_root(
+    ingestor: MemgraphIngestor, project_name: str, root: str, run_id: str
+) -> list[ResultRow] | None:
+    """Run the conditional purge; the project's node-id rows when it fired.
+
+    The ids are read while the project is still in the graph: once it is
+    deleted no query can recover them, and its vectors go only when the
+    conditional delete fires. None when it did not fire.
+    """
+    node_rows = ingestor.fetch_all(
+        cs.CYPHER_QUERY_PROJECT_NODE_IDS,
+        {cs.KEY_PROJECT_NAME: project_name},
+    )
+    _info(
+        style(
+            cs.CLI_MSG_PRUNING_PROJECT.format(
+                project_name=project_name, root=escape(root)
+            ),
+            cs.Color.YELLOW,
+        )
+    )
+    try:
+        fired = ingestor.delete_project(
+            project_name, expected_root=root, own_run_id=run_id
+        )
+    except Exception:
+        _sweep_glosses_after_failed_delete(ingestor, project_name)
+        raise
+    return node_rows if fired else None
+
+
+def _delete_pruned_vectors(
+    ingestor: MemgraphIngestor,
+    project_name: str,
+    projects: list[str],
+    node_rows: list[ResultRow],
+) -> None:
+    # Run only once the purge is verified: the store finds a project's
+    # points by its name, so a project a sync recreated under that name
+    # since the delete would lose its vectors, and verification has just
+    # read that none exists. The graph purge is proven either way; a vector
+    # deletion that fails or raises leaks vectors for dead node ids and is
+    # not recoverable by a retry, so it warns and the prune still counts.
+    try:
+        deleted = _cleanup_project_embeddings(
+            ingestor, project_name, projects, node_rows
+        )
+    except Exception as e:
+        logger.warning(
+            ls.CLI_PRUNE_VECTORS_FAILED.format(project=project_name, error=e)
+        )
+        deleted = False
+    if not deleted:
+        _say(cs.CLI_WARN_PRUNE_VECTORS_KEPT.format(project_name=project_name))
+
+
+@app.command(
+    name=ch.CLICommandName.PRUNE,
+    help=ch.CMD_PRUNE,
+    short_help=ch.CMD_PRUNE,
+    epilog=ch.EXAMPLES_PRUNE,
+    rich_help_panel=ch.PANEL_MANAGE,
+)
+def prune(
+    dry_run: bool = typer.Option(False, "--dry-run", help=ch.HELP_PRUNE_DRY_RUN),
+    yes: bool = typer.Option(False, "--yes", "-y", help=ch.HELP_PRUNE_YES),
+) -> None:
+    effective_batch_size = settings.resolve_batch_size(None)
+
+    try:
+        with connect_memgraph(effective_batch_size) as ingestor:
+            roots = ingestor.list_project_roots()
+            candidates = _missing_root_candidates(roots)
+            _report_prune_candidates(candidates)
+            if not candidates or dry_run:
+                if dry_run and candidates:
+                    _info(
+                        style(
+                            cs.CLI_MSG_PRUNE_DRY_RUN.format(count=len(candidates)),
+                            cs.Color.CYAN,
+                        )
+                    )
+                return
+            if not yes:
+                if not _stdin_is_interactive():
+                    app_context.console.print(
+                        style(cs.CLI_ERR_PRUNE_NEEDS_CONFIRMATION, cs.Color.RED)
+                    )
+                    raise typer.Exit(1)
+                confirmed = typer.confirm(
+                    cs.CLI_PROMPT_PRUNE_CONFIRM.format(count=len(candidates)),
+                    default=False,
+                )
+                if not confirmed:
+                    app_context.console.print(
+                        style(cs.CLI_MSG_PRUNE_ABORTED, cs.Color.CYAN)
+                    )
+                    raise typer.Exit(1)
+            pruned, failures = _prune_projects(ingestor, candidates, list(roots))
+            if pruned:
+                _info(
+                    style(
+                        cs.CLI_MSG_PRUNE_DONE.format(count=len(pruned)),
+                        cs.Color.GREEN,
+                    )
+                )
+            if failures:
+                raise typer.Exit(1)
+    except typer.Exit:
+        raise
+    except GraphUnavailableError:
+        raise
+    except Exception as e:
+        app_context.console.print(
+            style(cs.CLI_ERR_PRUNE_RUN_FAILED.format(error=e), cs.Color.RED)
+        )
+        logger.exception(cs.CLI_ERR_PRUNE_RUN_FAILED.format(error=e))
+        raise typer.Exit(1) from e
+
+
 if __name__ == "__main__":
     app()

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/codebase_rag/cli_help.py

@@ -15,6 +15,7 @@ class CLICommandName(StrEnum):
     DEAD_CODE = "dead-code"
     DUPLICATES = "duplicates"
     DELETE_PROJECT = "delete-project"
+    PRUNE = "prune"
     DAEMON = "daemon"
     WORKSPACE = "workspace"
     TRACE = "trace"
@@ -724,6 +725,10 @@ HELP_DELETE_PROJECT_REPO_PATH = (
     "Repository whose project to delete when --project is not given. Its "
     "local hash cache is removed too."
 )
+HELP_PRUNE_DRY_RUN = "List the projects that would be pruned without deleting anything."
+HELP_PRUNE_YES = "Prune without asking for confirmation."
+CMD_PRUNE = "Prune projects whose repository root no longer exists"
+EXAMPLES_PRUNE = "EXAMPLE\n\n  cgr prune --dry-run\n\n  cgr prune --yes"
 HELP_COMMAND = "Command path to document, such as 'start' or 'daemon logs'."
 
 CMD_VERIFY_INDEX = "Verify a protobuf index against its provenance manifest"
@@ -741,6 +746,7 @@ CLI_COMMANDS: dict[CLICommandName, str] = {
     CLICommandName.DEAD_CODE: CMD_DEAD_CODE,
     CLICommandName.DUPLICATES: CMD_DUPLICATES,
     CLICommandName.DELETE_PROJECT: CMD_DELETE_PROJECT,
+    CLICommandName.PRUNE: CMD_PRUNE,
     CLICommandName.LANGUAGE: CMD_LANGUAGE,
     CLICommandName.DAEMON: CMD_DAEMON,
     CLICommandName.TRACE: CMD_TRACE,

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/codebase_rag/constants/ast_js.py

@@ -110,6 +110,7 @@ TS_FUNCTION_EXPRESSION = "function_expression"
 # (`get thing() {...}`); its presence marks the method as a property whose
 # reads are member accesses, not invocations.
 TS_GET_ACCESSOR_KEYWORD = "get"
+TS_SET_ACCESSOR_KEYWORD = "set"
 TS_ARROW_FUNCTION = "arrow_function"
 TS_REQUIRED_PARAMETER = "required_parameter"
 TS_OPTIONAL_PARAMETER = "optional_parameter"

{code_graph_rag-0.4.5 → code_graph_rag-0.4.19}/codebase_rag/constants/ast_python.py

@@ -49,6 +49,13 @@ TS_PY_ASYNC = "async"
 # target is bound to: `with` calls `__enter__`, `async with` awaits `__aenter__`.
 PY_DUNDER_ENTER = "__enter__"
 PY_DUNDER_AENTER = "__aenter__"
+# ...and what it calls when the block is left, however it is left.
+PY_DUNDER_EXIT = "__exit__"
+PY_DUNDER_AEXIT = "__aexit__"
+# `name` then, on the same line and statement, an `=`: a plain, annotated,
+# chained, unpacking or walrus assignment to it (and some comparisons and
+# keyword arguments, harmlessly). `{name}` is the escaped name.
+PY_ASSIGNED_NAME_PATTERN = r"\b{name}\b[^=\n;]*="
 # The `if TYPE_CHECKING:` guard (bare or `typing.`-qualified): its body is
 # read by type checkers only and binds nothing at runtime.
 PY_TYPE_CHECKING = "TYPE_CHECKING"
@@ -521,6 +528,11 @@ PY_COMPREHENSION_TYPES = frozenset(
 # tree stays alive outside the AST cache's memory cap, so the cache holds a
 # few trees, all of whose scopes it keeps, rather than a number of scopes.
 PY_SCOPE_CACHE_TREES = 8
+# Trees whose definition indexes stay cached (`PythonDefinitionIndexes`), for
+# the same reason. Lookups cluster by file: indexing code-graph-rag's own tree
+# made 12,944 lookups into 1,375 files, and keeping 8 trees answered 83% of
+# them from an index (keeping every tree, 89%).
+PY_DEFINITION_INDEX_TREES = 8
 # The callable-parameter scan (`parsers/utils.py`, and the tree bridge's port
 # of it for the interface fingerprint): the scopes that capture an enclosing
 # def's parameters, and the ones it never enters.