codeui-python 0.1.0__py3-none-any.whl

codeui/agent/edit_tools.py

@@ -0,0 +1,280 @@
+"""Edit tools allowing agents to propose and apply non-destructive overrides."""
+import json
+from dataclasses import dataclass, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from codeui.core.graph import Graph
+from codeui.core.ir import SymbolKind
+from codeui.core.override import Conflict, Override, OverrideKind, OverrideStore
+from codeui.errors import SymbolNotFoundError, FileNotFoundInGraphError
+
+@dataclass
+class EditProposal:
+    """Dry-run proposal report for edit tools.
+    Example:
+        >>> p = EditProposal("s1", "rename_symbol", ["s1"], ["a.py"], "diff preview", [])
+        >>> p.target_id
+        's1'
+    """
+    target_id: str
+    kind: str
+    affected_symbols: List[str]
+    affected_files: List[str]
+    diff_preview: str
+    conflicts: List[Conflict]
+    new_value: Any = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert EditProposal to dictionary.
+        Example:
+            >>> p = EditProposal("s1", "rename", [], [], "", [])
+            >>> p.to_dict()["target_id"]
+            's1'
+        """
+        return asdict(self)
+
+class EditTools:
+    """Provides agent interface to dry-run, apply code overrides, and edit project files directly on disk.
+    Example:
+        >>> g = Graph()
+        >>> store = OverrideStore()
+        >>> tools = EditTools(g, store)
+        >>> tools.diff()
+        ''
+    """
+    def __init__(
+        self,
+        graph: Graph,
+        override_store: Optional[OverrideStore] = None,
+        project_root: Optional[Union[str, Path]] = None,
+        direct_disk: bool = True,
+    ) -> None:
+        self.graph = graph
+        self.override_store = override_store if override_store is not None else OverrideStore()
+        self.project_root = Path(project_root).resolve() if project_root else None
+        self.direct_disk = direct_disk
+
+    def rename_symbol(self, symbol_id: str, new_name: str) -> EditProposal:
+        """Propose renaming a symbol and updating references.
+        Example:
+            >>> from codeui.core.ir import Symbol, Location, Visibility
+            >>> g = Graph()
+            >>> g.add_symbol(Symbol("s1", "f", "a.f", SymbolKind.FUNCTION, "python", Location("a.py", 1, 0, 2, 0), None, None, Visibility.PUBLIC, (), "h"))
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> prop = tools.rename_symbol("s1", "new_name")
+            >>> prop.target_id
+            's1'
+        """
+        if not self.graph.has_symbol(symbol_id):
+            raise SymbolNotFoundError(symbol_id)
+        sym = self.graph.get_symbol(symbol_id)
+        affected_files = [sym.location.file_id]
+        incoming = self.graph.get_incoming_edges(symbol_id)
+        affected_symbols = [symbol_id] + [e.source_id for e in incoming]
+        diff_preview = f"--- a/{sym.location.file_id}\n+++ b/{sym.location.file_id}\n- {sym.name}\n+ {new_name}\n"
+        return EditProposal(
+            target_id=symbol_id,
+            kind="rename_symbol",
+            affected_symbols=affected_symbols,
+            affected_files=affected_files,
+            diff_preview=diff_preview,
+            conflicts=[],
+            new_value=new_name,
+        )
+
+    def retype_symbol(self, symbol_id: str, new_kind: SymbolKind) -> EditProposal:
+        """Propose retyping a symbol's SymbolKind.
+        Example:
+            >>> from codeui.core.ir import Symbol, Location, Visibility
+            >>> g = Graph()
+            >>> g.add_symbol(Symbol("s1", "f", "a.f", SymbolKind.FUNCTION, "python", Location("a.py", 1, 0, 2, 0), None, None, Visibility.PUBLIC, (), "h"))
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> prop = tools.retype_symbol("s1", SymbolKind.METHOD)
+            >>> prop.kind
+            'retype_symbol'
+        """
+        if not self.graph.has_symbol(symbol_id):
+            raise SymbolNotFoundError(symbol_id)
+        sym = self.graph.get_symbol(symbol_id)
+        return EditProposal(
+            target_id=symbol_id,
+            kind="retype_symbol",
+            affected_symbols=[symbol_id],
+            affected_files=[sym.location.file_id],
+            diff_preview=f"Change kind of {sym.name} from {sym.kind} to {new_kind}",
+            conflicts=[],
+            new_value=new_kind,
+        )
+
+    def replace_symbol_body(self, symbol_id: str, new_body: str) -> EditProposal:
+        """Propose replacing the implementation body of a single symbol.
+        Example:
+            >>> from codeui.core.ir import Symbol, Location, Visibility
+            >>> g = Graph()
+            >>> g.add_symbol(Symbol("s1", "f", "a.f", SymbolKind.FUNCTION, "python", Location("a.py", 1, 0, 2, 0), None, None, Visibility.PUBLIC, (), "h"))
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> prop = tools.replace_symbol_body("s1", "def foo(): pass")
+            >>> prop.target_id
+            's1'
+        """
+        if not self.graph.has_symbol(symbol_id):
+            raise SymbolNotFoundError(symbol_id)
+        sym = self.graph.get_symbol(symbol_id)
+        return EditProposal(
+            target_id=symbol_id,
+            kind="replace_symbol_body",
+            affected_symbols=[symbol_id],
+            affected_files=[sym.location.file_id],
+            diff_preview=f"Replace body of {sym.name} with:\n{new_body}",
+            conflicts=[],
+            new_value=new_body,
+        )
+
+    def replace_file(self, file_id: str, new_content: str, original_content: str = "") -> EditProposal:
+        """Propose replacing entire file content without mutating disk.
+        Example:
+            >>> g = Graph()
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> prop = tools.replace_file("app.py", "x = 1", "x = 0")
+            >>> prop.affected_files
+            ['app.py']
+        """
+        diff = f"--- a/{file_id}\n+++ b/{file_id}\n{new_content}"
+        return EditProposal(
+            target_id=file_id,
+            kind="replace_file",
+            affected_symbols=[],
+            affected_files=[file_id],
+            diff_preview=diff,
+            conflicts=[],
+            new_value=new_content,
+        )
+
+    def write_file_to_disk(self, file_path: str, new_content: str) -> Path:
+        """Write content directly to project file on disk.
+        Example:
+            >>> import tempfile
+            >>> with tempfile.TemporaryDirectory() as td:
+            ...     tools = EditTools(Graph(), project_root=td)
+            ...     p = tools.write_file_to_disk("sub/app.py", "x = 1")
+            ...     p.exists()
+            True
+        """
+        root = (self.project_root if self.project_root is not None else Path(".")).resolve()
+        clean_rel = file_path.split("::")[0].replace("module::", "").replace("\\", "/").lstrip("/")
+        
+        target_path: Optional[Path] = None
+        cand_direct = (root / clean_rel).resolve()
+        if cand_direct.exists() and cand_direct.is_file():
+            target_path = cand_direct
+        elif root.name and clean_rel.startswith(root.name + "/"):
+            sub_cand = (root / clean_rel[len(root.name):].lstrip("/")).resolve()
+            if sub_cand.exists() and sub_cand.is_file():
+                target_path = sub_cand
+
+        if target_path is None and self.graph:
+            for known_file in self.graph.get_all_files():
+                k_clean = known_file.replace("\\", "/").lstrip("./")
+                if k_clean == clean_rel or k_clean.endswith("/" + clean_rel) or clean_rel.endswith("/" + k_clean):
+                    cand_k = (root / k_clean).resolve()
+                    if cand_k.exists() and cand_k.is_file():
+                        target_path = cand_k
+                        break
+
+        if target_path is None:
+            target_path = cand_direct
+
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        target_path.write_text(new_content, encoding="utf-8")
+        if self.override_store:
+            self.override_store.revert(clean_rel)
+            try:
+                rel = str(target_path.relative_to(root)).replace("\\", "/")
+                self.override_store.revert(rel)
+            except Exception:
+                pass
+        return target_path
+
+    def apply_to_disk(self, proposal: EditProposal, author: str = "agent") -> Path:
+        """Apply an EditProposal directly to project files on disk.
+        Example:
+            >>> import tempfile
+            >>> with tempfile.TemporaryDirectory() as td:
+            ...     tools = EditTools(Graph(), project_root=td)
+            ...     prop = tools.replace_file("test.py", "val = 10")
+            ...     path = tools.apply_to_disk(prop)
+            ...     path.read_text()
+            'val = 10'
+        """
+        content = proposal.new_value if proposal.new_value is not None else (
+            proposal.diff_preview.split("\n", 2)[-1] if "\n" in proposal.diff_preview else proposal.diff_preview
+        )
+        return self.write_file_to_disk(proposal.target_id, content)
+
+    def apply(self, proposal: EditProposal, author: str = "agent", write_to_disk: Optional[bool] = None) -> None:
+        """Apply an EditProposal into OverrideStore or directly to project file on disk.
+        Example:
+            >>> g = Graph()
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store, direct_disk=False)
+            >>> prop = tools.replace_file("app.py", "x = 1")
+            >>> tools.apply(prop)
+            >>> store.get("app.py") is not None
+            True
+        """
+        should_write_disk = write_to_disk if write_to_disk is not None else (self.direct_disk and self.project_root is not None)
+        if should_write_disk and proposal.kind == "replace_file":
+            content = proposal.new_value if proposal.new_value is not None else (
+                proposal.diff_preview.split("\n", 2)[-1] if "\n" in proposal.diff_preview else proposal.diff_preview
+            )
+            self.write_file_to_disk(proposal.target_id, content)
+            return
+
+        now = datetime.now(timezone.utc).isoformat()
+        if proposal.kind == "replace_file":
+            content = proposal.new_value if proposal.new_value is not None else (
+                proposal.diff_preview.split("\n", 2)[-1] if "\n" in proposal.diff_preview else proposal.diff_preview
+            )
+            self.override_store.set_file_override(
+                file_path=proposal.target_id,
+                original_content="",
+                new_content=content,
+                author=author,
+            )
+        else:
+            val = proposal.new_value if proposal.new_value is not None else proposal.diff_preview
+            override = Override(
+                target_id=proposal.target_id,
+                kind=OverrideKind(proposal.kind),
+                original_hash="",
+                new_value=val,
+                author=author,
+                created_at=now,
+            )
+            self.override_store.set(override)
+
+    def revert(self, target_id: str) -> None:
+        """Revert override for target ID.
+        Example:
+            >>> g = Graph()
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> tools.revert("app.py")
+        """
+        self.override_store.revert(target_id)
+
+    def diff(self) -> str:
+        """Generate unified diff across all applied overrides.
+        Example:
+            >>> g = Graph()
+            >>> store = OverrideStore()
+            >>> tools = EditTools(g, store)
+            >>> tools.diff()
+            ''
+        """
+        return self.override_store.to_diff()

codeui/agent/integrations.py

@@ -0,0 +1,243 @@
+"""LangChain, LlamaIndex, and MCP tool integration helpers."""
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+from codeui.agent.context import ContextBuilder
+from codeui.agent.contribution import ContributionManager
+from codeui.agent.edit_tools import EditProposal, EditTools
+from codeui.core.graph import Graph
+from codeui.core.override import OverrideStore
+from codeui.core.repo import get_library_repo_url
+from codeui.tracer.tracer import Tracer
+
+class CodeUITools:
+    """Unified integration tools exposing codeui capabilities to AI agents.
+    Example:
+        >>> g = Graph()
+        >>> tools = CodeUITools(g)
+        >>> "matches" in tools.find_symbol("main")
+        True
+    """
+    def __init__(
+        self,
+        graph: Graph,
+        override_store: Optional[OverrideStore] = None,
+        project_root: Optional[Union[str, Path]] = None,
+        direct_disk: bool = True,
+    ) -> None:
+        self.graph = graph
+        self.override_store = override_store or OverrideStore()
+        self.project_root = Path(project_root).resolve() if project_root else None
+        self.direct_disk = direct_disk
+        self.tracer = Tracer(graph)
+        self.context_builder = ContextBuilder(graph)
+        self.edit_tools = EditTools(
+            graph=graph,
+            override_store=self.override_store,
+            project_root=self.project_root,
+            direct_disk=self.direct_disk,
+        )
+
+    def find_symbol(self, query: str) -> Dict[str, Any]:
+        """Search for symbols by name or qualified name.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.find_symbol("f")["matches"]
+            []
+        """
+        matches = [
+            s.to_dict() for s in self.graph.get_all_symbols()
+            if query.lower() in s.name.lower() or query.lower() in s.qualified_name.lower()
+        ]
+        return {"query": query, "matches": matches, "count": len(matches)}
+
+    def get_context(self, symbol_id: str, depth: int = 1) -> Dict[str, Any]:
+        """Retrieve graph-based context bundle for symbol.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> "manifest" in tools.get_context("sym_1")
+            True
+        """
+        bundle = self.context_builder.for_symbol(symbol_id, depth=depth)
+        return bundle.to_dict()
+
+    def find_defects(self, severity: str | None = None) -> Dict[str, Any]:
+        """Fetch all defects filtered by optional severity.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.find_defects()["count"]
+            0
+        """
+        findings = self.graph.get_findings()
+        if severity:
+            findings = [f for f in findings if str(f.severity) == severity]
+        return {"findings": [f.to_dict() for f in findings], "count": len(findings)}
+
+    def trace_call_chain(self, symbol_id: str, direction: str = "forward", depth: int = 3) -> Dict[str, Any]:
+        """Trace symbol call chain forward or backward.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.trace_call_chain("sym_1")["chain"]
+            []
+        """
+        if direction == "backward":
+            chain = [s.to_dict() for s in self.tracer.backward(symbol_id, depth=depth)]
+        else:
+            chain = [s.to_dict() for s in self.tracer.forward(symbol_id, depth=depth)]
+        return {"symbol_id": symbol_id, "direction": direction, "chain": chain}
+
+    def propose_rename(self, symbol_id: str, new_name: str) -> Dict[str, Any]:
+        """Propose renaming a symbol and preview diff.
+        Example:
+            >>> from codeui.core.ir import Location, Symbol, SymbolKind, Visibility
+            >>> g = Graph()
+            >>> loc = Location("a.py", 1, 0, 1, 0)
+            >>> g.add_symbol(Symbol("s1", "f", "a.f", SymbolKind.FUNCTION, "python", loc, None, None, Visibility.PUBLIC, (), "h"))
+            >>> tools = CodeUITools(g)
+            >>> tools.propose_rename("s1", "new_f")["target_id"]
+            's1'
+        """
+        proposal = self.edit_tools.rename_symbol(symbol_id, new_name)
+        return proposal.to_dict()
+
+    def propose_replace_file(self, file_id: str, new_content: str, original_content: str = "") -> Dict[str, Any]:
+        """Propose replacing file content.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.propose_replace_file("a.py", "x = 1")["target_id"]
+            'a.py'
+        """
+        proposal = self.edit_tools.replace_file(file_id, new_content, original_content)
+        return proposal.to_dict()
+
+    def write_file_direct(self, file_id: str, new_content: str) -> Dict[str, Any]:
+        """Directly write content to a project file on disk.
+        Example:
+            >>> import tempfile
+            >>> with tempfile.TemporaryDirectory() as td:
+            ...     tools = CodeUITools(Graph(), project_root=td)
+            ...     res = tools.write_file_direct("main.py", "print('hello')")
+            ...     res["status"]
+            'saved_to_disk'
+        """
+        path = self.edit_tools.write_file_to_disk(file_id, new_content)
+        return {"status": "saved_to_disk", "file_id": file_id, "path": str(path)}
+
+    def apply_proposal(
+        self,
+        proposal: Dict[str, Any],
+        author: str = "agent",
+        direct_disk: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """Apply an edit proposal into the active override store or directly to project file on disk.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g, direct_disk=False)
+            >>> prop = tools.propose_replace_file("a.py", "x = 1")
+            >>> tools.apply_proposal(prop)["status"]
+            'applied'
+        """
+        prop_obj = EditProposal(
+            target_id=proposal["target_id"],
+            kind=proposal["kind"],
+            affected_symbols=proposal.get("affected_symbols", []),
+            affected_files=proposal.get("affected_files", []),
+            diff_preview=proposal.get("diff_preview", ""),
+            conflicts=[],
+            new_value=proposal.get("new_value"),
+        )
+        self.edit_tools.apply(prop_obj, author=author, write_to_disk=direct_disk)
+        status = "written_to_disk" if (direct_disk or (direct_disk is None and self.direct_disk and self.project_root is not None)) else "applied"
+        return {"status": status, "target_id": proposal["target_id"]}
+
+    def revert_override(self, target_id: str) -> Dict[str, Any]:
+        """Revert active override for target symbol or file.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.revert_override("a.py")["status"]
+            'reverted'
+        """
+        self.edit_tools.revert(target_id)
+        return {"status": "reverted", "target_id": target_id}
+
+    def diff(self) -> str:
+        """Get unified diff across all active overrides.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.get_diff()
+            ''
+        """
+        return self.edit_tools.diff()
+
+    def get_diff(self) -> str:
+        """Get unified diff across all active overrides.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.get_diff()
+            ''
+        """
+        return self.edit_tools.diff()
+
+    def get_repository_url(self) -> str:
+        """Retrieve the official codeui GitHub repository URL.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.get_repository_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        return get_library_repo_url()
+
+    def clone_library_repository(
+        self,
+        target_dir: Optional[Union[str, Path]] = None,
+        token: Optional[str] = None,
+        branch: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Clone the codeui repository for inspection, bug fixing, or feature addition.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.get_repository_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        mgr = ContributionManager(token=token)
+        cloned_path = mgr.clone_repository(target_dir=target_dir, token=token, branch=branch)
+        return {
+            "status": "cloned",
+            "repo_url": mgr.get_repo_url(),
+            "cloned_dir": str(cloned_path),
+        }
+
+    def submit_library_contribution(
+        self,
+        title: str,
+        description: str,
+        file_changes: Dict[str, str],
+        branch_name: Optional[str] = None,
+        token: Optional[str] = None,
+        push: bool = True,
+    ) -> Dict[str, Any]:
+        """Clone codeui, apply modifications (bug fixes / features), commit, and push to GitHub.
+        Example:
+            >>> g = Graph()
+            >>> tools = CodeUITools(g)
+            >>> tools.get_repository_url()
+            'https://github.com/AAlsubari/codeUI'
+        """
+        mgr = ContributionManager(token=token)
+        return mgr.submit_contribution(
+            title=title,
+            description=description,
+            file_changes=file_changes,
+            branch_name=branch_name,
+            token=token,
+            push=push,
+        )

codeui/agent/mcp_server.py

@@ -0,0 +1,94 @@
+"""Model Context Protocol (MCP) server exposing codeui edit and analysis tools."""
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+from codeui.agent.integrations import CodeUITools
+from codeui.core.graph import Graph
+
+class MCPServer:
+    """Model Context Protocol (MCP) server handler for AI agent tool invocations.
+    Example:
+        >>> g = Graph()
+        >>> server = MCPServer(g)
+        >>> resp = server.handle_request({"method": "tools/list", "id": 1})
+        >>> resp["result"]["tools"][0]["name"]
+        'find_symbol'
+    """
+    def __init__(self, graph: Graph, project_root: Optional[Union[str, Path]] = None, direct_disk: bool = True) -> None:
+        self.graph = graph
+        self.tools = CodeUITools(graph, project_root=project_root, direct_disk=direct_disk)
+
+    def handle_request(self, request: Dict[str, Any]) -> Dict[str, Any]:
+        """Process JSON-RPC style MCP protocol request.
+        Example:
+            >>> server = MCPServer(Graph())
+            >>> resp = server.handle_request({"method": "unknown", "id": 1})
+            >>> "error" in resp
+            True
+        """
+        req_id = request.get("id")
+        method = request.get("method")
+        params = request.get("params", {})
+
+        if method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {
+                    "tools": [
+                        {"name": "find_symbol", "description": "Search for code symbols by name"},
+                        {"name": "get_context", "description": "Get graph context bundle for symbol"},
+                        {"name": "find_defects", "description": "Get defect findings"},
+                        {"name": "trace_call_chain", "description": "Trace symbol forward/backward call chain"},
+                        {"name": "propose_rename", "description": "Propose renaming a symbol and preview diff"},
+                        {"name": "propose_replace_file", "description": "Propose replacing entire file content"},
+                        {"name": "apply_proposal", "description": "Apply edit proposal into active override store or directly to disk"},
+                        {"name": "write_file_to_disk", "description": "Directly write new content to project file on disk"},
+                        {"name": "revert_override", "description": "Revert active override for target"},
+                        {"name": "get_diff", "description": "Get unified diff across all active overrides"},
+                    ]
+                },
+            }
+        elif method == "tools/call":
+            tool_name = params.get("name")
+            args = params.get("arguments", {})
+            if tool_name == "find_symbol":
+                res = self.tools.find_symbol(args.get("query", ""))
+            elif tool_name == "get_context":
+                res = self.tools.get_context(args.get("symbol_id", ""), args.get("depth", 1))
+            elif tool_name == "find_defects":
+                res = self.tools.find_defects(args.get("severity"))
+            elif tool_name == "trace_call_chain":
+                res = self.tools.trace_call_chain(args.get("symbol_id", ""), args.get("direction", "forward"), args.get("depth", 3))
+            elif tool_name == "propose_rename":
+                res = self.tools.propose_rename(args.get("symbol_id", ""), args.get("new_name", ""))
+            elif tool_name == "propose_replace_file":
+                res = self.tools.propose_replace_file(args.get("file_id", ""), args.get("new_content", ""), args.get("original_content", ""))
+            elif tool_name == "apply_proposal":
+                res = self.tools.apply_proposal(
+                    args.get("proposal", {}),
+                    author=args.get("author", "agent"),
+                    direct_disk=args.get("direct_disk"),
+                )
+            elif tool_name == "write_file_to_disk":
+                res = self.tools.write_file_direct(args.get("file_id", ""), args.get("content", ""))
+            elif tool_name == "revert_override":
+                res = self.tools.revert_override(args.get("target_id", ""))
+            elif tool_name == "get_diff":
+                res = {"diff": self.tools.get_diff()}
+            else:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32601, "message": f"Tool not found: {tool_name}"},
+                }
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {"content": [{"type": "text", "text": json.dumps(res, sort_keys=True)}]},
+            }
+        return {
+            "jsonrpc": "2.0",
+            "id": req_id,
+            "error": {"code": -32601, "message": f"Method not found: {method}"},
+        }

codeui/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analysis engine and defect detection modules for codeui."""