test: cover move MCP wiring

codebase_rag/constants/cli.py

@@ -648,6 +648,16 @@ class DiffMarker:
 SIGNATURE_NEEDS_KEYWORDS = "the mapping needs keyword arguments this language lacks"
 SIGNATURE_UNMAPPED_PARAM = "the site passes no value for {name}"
 SIGNATURE_SURPLUS_ARGS = "the site passes more arguments than the definition declares"
+# move (issue #1534).
+MOVE_UNKNOWN = "No definition named {qn} in the graph"
+MOVE_METHOD = "{qn} is a method; move its class instead"
+MOVE_SAME_MODULE = "{path} already holds the definition"
+MOVE_NO_GRAMMAR = "No grammar for {path}; the definition cannot be moved"
+MOVE_NO_DEFINITION_TOKEN = "Could not locate the definition of {qn} in {path}"
+MOVE_CYCLE = "Refusing to move: it would create the import cycle {cycle}"
+MOVE_PLANNED = "{importers} importer(s) would be rewritten, {unchanged} left unchanged"
+MOVE_PARSE_FAILED = "Move rolled back: {files} would no longer parse"
+MOVE_CONTRACT_FAILED = "Move rolled back, postcondition failed: {reasons}"
 SIGNATURE_DEFAULT_ORDER = "Parameter {name} has no default but follows one that does"
 # Postcondition contract (issue #1531).
 CONTRACT_OP_RENAME = "rename"

codebase_rag/constants/graph.py

@@ -63,6 +63,7 @@
 KEY_STRUCTURAL_DELTA = "structural_delta"
 KEY_UNMAPPED = "unmapped"
 KEY_VERDICT = "verdict"
+KEY_CYCLE = "cycle"
 KEY_DISPATCH_LITERAL = "dispatch_literal"
 
 

codebase_rag/constants/mcp.py

@@ -22,6 +22,7 @@ class MCPToolName(StrEnum):
     # Graph-driven edit operations (issue #1532).
     RENAME = "rename"
     CHANGE_SIGNATURE = "change_signature"
+    MOVE = "move"
     QUERY_CODE_GRAPH = "query_code_graph"
     GET_CODE_SNIPPET = "get_code_snippet"
     SURGICAL_REPLACE_CODE = "surgical_replace_code"
@@ -112,6 +113,8 @@ class MCPParamName(StrEnum):
     NEW_NAME = "new_name"
     ALLOW_HEURISTIC = "allow_heuristic"
     NEW_PARAMS = "new_params"
+    TARGET_MODULE = "target_module"
+    KEEP_ALIAS = "keep_alias"
 
 
 # MCP server constants

codebase_rag/cypher_queries.py

@@ -815,6 +815,12 @@ def build_create_relationship_query(
 RETURN n.positional_params AS positional_params, n.param_types AS param_types,
        n.return_type AS return_type
 LIMIT 1"""
+# What one module imports, with each statement's site (issue #1534).
+CYPHER_GRAPH_IMPORTS_OF = """MATCH (m:Module)-[r:IMPORTS]->(target)
+WHERE m.qualified_name = $qn AND m.qualified_name STARTS WITH $project_prefix
+RETURN target.qualified_name AS to_qn, r.line AS line, r.col AS col,
+       r.end_line AS end_line, r.end_col AS end_col, r.alias AS alias,
+       r.imported_name AS imported_name"""
 CYPHER_GRAPH_IMPORTERS = """MATCH (m:Module)-[r:IMPORTS]->(target)
 WHERE target.qualified_name = $qn AND m.qualified_name STARTS WITH $project_prefix
 RETURN m.qualified_name AS qualified_name, m.path AS path, r.line AS line,

codebase_rag/editing/__init__.py

@@ -11,6 +11,7 @@
     verify,
 )
 from .imports import ImportRewriter, ImportSite, Rewrite, RewriteError, SymbolMove
+from .move import MoveRefused, MoveReport, move
 from .patcher import (
     Patcher,
     PatcherError,
@@ -43,6 +44,9 @@
 
 __all__ = [
     "Expectation",
+    "MoveRefused",
+    "MoveReport",
+    "move",
     "ParamSpec",
     "SignatureRefused",
     "SignatureReport",

codebase_rag/editing/move.py

@@ -0,0 +1,65 @@
+"""`move(qn, target_module)`: edit-algebra operation 3 (issue #1534).
+
+Moving a symbol out of a shared dumping ground into the one package that
+uses it is the refactor that shrinks affected sets, and by hand it is
+tedious: the definition, its own imports, every importer, re-exports. The
+graph knows the definition's span, the imports its module binds, and every
+importer's statement (issue #1522), so the whole move is one transaction:
+
+- cut the definition (decorators, docstring, adjacent comments included)
+  and paste it into the target with the imports it needs;
+- rewrite every importer through the import rewriter;
+- give the old module an import of the moved name when it still uses it,
+  and optionally a deprecation re-export (`keep_alias=True`);
+- refuse before touching a file when the move would create an import
+  cycle, naming the cycle.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+
+from ..graph_query import QueryFn
+from .contract import Reingest
+from .move_scope import _module_bound
+from .move_types import MoveRefused, MoveReport
+from .transaction import StagedTree, VerificationResult
+
+
+def __getattr__(name: str):
+    if name == "Mover":
+        from .move_operation import Mover
+
+        return Mover
+    raise AttributeError(name)
+
+
+def move(
+    repo_root: Path,
+    fetch_all: QueryFn,
+    project_name: str,
+    qualified_name: str,
+    target_module: str,
+    keep_alias: bool = False,
+    dry_run: bool = False,
+    verify: Callable[[StagedTree], VerificationResult | bool | None] | None = None,
+    reingest: Reingest | None = None,
+) -> MoveReport:
+    """The op: plan (refusing on a cycle) or plan and apply."""
+    from .move_operation import move as _move
+
+    return _move(
+        repo_root,
+        fetch_all,
+        project_name,
+        qualified_name,
+        target_module,
+        keep_alias=keep_alias,
+        dry_run=dry_run,
+        verify=verify,
+        reingest=reingest,
+    )
+
+
+__all__ = ["MoveRefused", "MoveReport", "move", "_module_bound"]

codebase_rag/editing/move_cycles.py

@@ -0,0 +1,44 @@
+"""Import-cycle refusal for move planning."""
+
+from __future__ import annotations
+
+from .. import constants as cs
+from ..graph_query import QueryFn
+from ..structural_delta import import_cycles, snapshot
+from .move_types import MoveRefused
+
+
+class _MoveCycleMixin:
+    fetch_all: QueryFn
+    project: str
+
+    def _refuse_cycles(
+        self,
+        old_module: str,
+        new_module: str,
+        copied_targets: list[str],
+        needs_old: bool,
+        old_needs_new: bool,
+        old_path: str,
+        new_path: str,
+    ) -> None:
+        graph = {
+            qn: set(targets)
+            for qn, targets in snapshot(
+                self.fetch_all, self.project, [old_path, new_path]
+            ).imports.items()
+        }
+        before = import_cycles({qn: frozenset(t) for qn, t in graph.items()})
+        graph.setdefault(new_module, set()).update(t for t in copied_targets if t)
+        if needs_old:
+            graph.setdefault(new_module, set()).add(old_module)
+        if old_needs_new:
+            graph.setdefault(old_module, set()).add(new_module)
+        for importer, targets in graph.items():
+            if old_module in targets and importer not in (old_module, new_module):
+                targets.add(new_module)
+        after = import_cycles({qn: frozenset(t) for qn, t in graph.items()})
+        fresh = [c for c in after - before if new_module in c or old_module in c]
+        if fresh:
+            cycle = tuple(sorted(fresh[0]))
+            raise MoveRefused(cs.MOVE_CYCLE.format(cycle=" -> ".join(cycle)), cycle)