@scemoon/cdh 1.0.0

package/onecode/agent/tools/git_tools.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+
+
+class WorktreeTool:
+    """Manage git worktrees (Clawd-Code pattern)."""
+
+    def __init__(self, workspace_root: Path | None = None):
+        self._workspace_root = (workspace_root or Path.cwd()).resolve()
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="Worktree",
+            description="Manage git worktrees: create, list, prune. Worktrees allow checking out multiple branches simultaneously.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "action": {
+                        "type": "string",
+                        "enum": ["list", "add", "prune"],
+                        "description": "List worktrees, add a new worktree, or prune stale ones",
+                    },
+                    "path": {"type": "string", "description": "Path for the new worktree (required for add)"},
+                    "branch": {"type": "string", "description": "Branch to checkout (default: new branch named after path)"},
+                    "commitish": {"type": "string", "description": "Commit, tag, or branch to base the worktree on"},
+                },
+                "required": ["action"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        action = tool_input.get("action", "list")
+        try:
+            if action == "list":
+                result = subprocess.run(
+                    ["git", "worktree", "list"],
+                    capture_output=True, text=True, timeout=30,
+                    cwd=str(self._workspace_root),
+                )
+                if result.returncode != 0:
+                    return ToolResult(name="Worktree", output={"error": result.stderr.strip()}, is_error=True)
+                worktrees = []
+                for line in result.stdout.strip().split("\n"):
+                    if line:
+                        parts = line.split()
+                        worktrees.append({"path": parts[0], "branch": parts[1] if len(parts) > 1 else ""})
+                return ToolResult(name="Worktree", output={"worktrees": worktrees})
+
+            elif action == "add":
+                wt_path = tool_input.get("path", "")
+                if not wt_path:
+                    return ToolResult(name="Worktree", output={"error": "path required for add"}, is_error=True)
+                branch = tool_input.get("branch")
+                commitish = tool_input.get("commitish")
+                cmd = ["git", "worktree", "add", wt_path]
+                if branch:
+                    cmd.extend(["-b", branch])
+                if commitish:
+                    cmd.append(commitish)
+                result = subprocess.run(cmd, capture_output=True, text=True, timeout=60, cwd=str(self._workspace_root))
+                if result.returncode != 0:
+                    return ToolResult(name="Worktree", output={"error": result.stderr.strip()}, is_error=True)
+                return ToolResult(name="Worktree", output={"path": wt_path, "status": "created", "output": result.stdout.strip()})
+
+            elif action == "prune":
+                result = subprocess.run(
+                    ["git", "worktree", "prune"],
+                    capture_output=True, text=True, timeout=30,
+                    cwd=str(self._workspace_root),
+                )
+                if result.returncode != 0:
+                    return ToolResult(name="Worktree", output={"error": result.stderr.strip()}, is_error=True)
+                return ToolResult(name="Worktree", output={"status": "pruned"})
+
+            return ToolResult(name="Worktree", output={"error": f"unknown action: {action}"}, is_error=True)
+        except subprocess.TimeoutExpired:
+            return ToolResult(name="Worktree", output={"error": "git worktree command timed out"}, is_error=True)
+        except FileNotFoundError:
+            return ToolResult(name="Worktree", output={"error": "git not found"}, is_error=True)
+        except Exception as e:
+            return ToolResult(name="Worktree", output={"error": str(e)}, is_error=True)
+

package/onecode/agent/tools/lsp_tools.py

@@ -0,0 +1,404 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+
+
+class LSPClient:
+    def __init__(self, command: list[str], root_uri: str, workspace_root: Path | None = None):
+        self._command = command
+        self._root_uri = root_uri
+        self._workspace_root = workspace_root or Path(root_uri.replace("file://", "")) if root_uri else Path.cwd()
+        self._process: subprocess.Popen | None = None
+        self._request_id = 0
+        self._pending: dict[int, Any] = {}
+
+    def start(self) -> bool:
+        try:
+            self._process = subprocess.Popen(
+                self._command,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            resp = self._send("initialize", {
+                "processId": None,
+                "rootUri": self._root_uri,
+                "capabilities": {
+                    "textDocument": {
+                        "definition": {"dynamicRegistration": True},
+                        "references": {"dynamicRegistration": True},
+                        "hover": {"dynamicRegistration": True},
+                        "documentSymbol": {"dynamicRegistration": True},
+                        "callHierarchy": {"dynamicRegistration": True},
+                    },
+                    "workspace": {
+                        "symbol": {"dynamicRegistration": True},
+                    },
+                },
+            })
+            self._send("initialized", {"parameters": {}})
+            return resp is not None
+        except Exception:
+            self.stop()
+            return False
+
+    def _send(self, method: str, params: dict) -> dict | None:
+        if not self._process or not self._process.stdin:
+            return None
+        self._request_id += 1
+        msg_id = self._request_id
+        msg = json.dumps({"jsonrpc": "2.0", "id": msg_id, "method": method, "params": params})
+        self._process.stdin.write((msg + "\n").encode())
+        self._process.stdin.flush()
+
+        line = self._process.stdout.readline() if self._process.stdout else b""
+        if line:
+            try:
+                resp = json.loads(line)
+                if resp.get("id") == msg_id:
+                    if "error" in resp:
+                        return {"error": resp["error"]}
+                    return resp.get("result")
+                return None
+            except json.JSONDecodeError:
+                pass
+        return None
+
+    def _read_notification(self) -> dict | None:
+        if not self._process or not self._process.stdout:
+            return None
+        import select
+        if select.select([self._process.stdout], [], [], 0.1)[0]:
+            line = self._process.stdout.readline()
+            if line:
+                try:
+                    return json.loads(line)
+                except json.JSONDecodeError:
+                    pass
+        return None
+
+    def _position_params(self, file_uri: str, line: int, character: int) -> dict:
+        return {
+            "textDocument": {"uri": file_uri},
+            "position": {"line": line, "character": character},
+        }
+
+    def goto_definition(self, file_uri: str, line: int, character: int) -> list[dict]:
+        result = self._send("textDocument/definition", self._position_params(file_uri, line, character))
+        if result is None:
+            return []
+        if isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            result = [result] if result else []
+        return [self._location_to_dict(loc) for loc in result if loc]
+
+    def find_references(self, file_uri: str, line: int, character: int, include_declaration: bool = True) -> list[dict]:
+        params = self._position_params(file_uri, line, character)
+        params["context"] = {"includeDeclaration": include_declaration}
+        result = self._send("textDocument/references", params)
+        if result is None:
+            return []
+        if isinstance(result, dict) and "error" in result:
+            return []
+        return [self._location_to_dict(loc) for loc in result if loc]
+
+    def hover(self, file_uri: str, line: int, character: int) -> dict | None:
+        result = self._send("textDocument/hover", self._position_params(file_uri, line, character))
+        if result is None or isinstance(result, dict) and "error" in result:
+            return None
+        if not result:
+            return None
+        return {
+            "contents": result.get("contents", ""),
+            "range": result.get("range"),
+        }
+
+    def document_symbol(self, file_uri: str) -> list[dict]:
+        result = self._send("textDocument/documentSymbol", {"textDocument": {"uri": file_uri}})
+        if result is None or isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            return []
+        symbols = []
+        for item in result:
+            if isinstance(item, dict):
+                symbols.append({
+                    "name": item.get("name", ""),
+                    "kind": item.get("kind", ""),
+                    "location": self._location_to_dict(item.get("location")),
+                    "containerName": item.get("containerName", ""),
+                })
+        return symbols
+
+    def workspace_symbol(self, query: str) -> list[dict]:
+        result = self._send("workspace/symbol", {"query": query})
+        if result is None or isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            return []
+        symbols = []
+        for item in result:
+            if isinstance(item, dict):
+                symbols.append({
+                    "name": item.get("name", ""),
+                    "kind": item.get("kind", ""),
+                    "location": self._location_to_dict(item.get("location")),
+                    "containerName": item.get("containerName", ""),
+                })
+        return symbols
+
+    def goto_implementation(self, file_uri: str, line: int, character: int) -> list[dict]:
+        result = self._send("textDocument/implementation", self._position_params(file_uri, line, character))
+        if result is None or isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            result = [result] if result else []
+        return [self._location_to_dict(loc) for loc in result if loc]
+
+    def call_hierarchy(self, file_uri: str, line: int, character: int) -> dict:
+        result = self._send("textDocument/prepareCallHierarchy", self._position_params(file_uri, line, character))
+        if result is None or isinstance(result, dict) and "error" in result:
+            return {"incomingCalls": [], "outgoingCalls": []}
+
+        if not isinstance(result, list) or not result:
+            return {"incomingCalls": [], "outgoingCalls": []}
+
+        item = result[0] if result else {}
+        call_hierarchy = {"incomingCalls": [], "outgoingCalls": []}
+
+        if item.get("from"):
+            incoming = self._send("callHierarchy/incomingCalls", {"item": item})
+            if incoming and isinstance(incoming, list):
+                call_hierarchy["incomingCalls"] = [
+                    {"from": c.get("from", {}).get("name", ""), "locations": [self._location_to_dict(loc) for loc in c.get("from", {}).get("locations", [])]}
+                    for c in incoming if isinstance(c, dict)
+                ]
+
+        if item.get("to"):
+            outgoing = self._send("callHierarchy/outgoingCalls", {"item": item})
+            if outgoing and isinstance(outgoing, list):
+                call_hierarchy["outgoingCalls"] = [
+                    {"to": c.get("to", {}).get("name", ""), "locations": [self._location_to_dict(loc) for loc in c.get("to", {}).get("locations", [])]}
+                    for c in outgoing if isinstance(c, dict)
+                ]
+
+        return call_hierarchy
+
+    def incoming_calls(self, file_uri: str, line: int, character: int) -> list[dict]:
+        result = self._send("callHierarchy/incomingCalls", {
+            "item": {
+                "name": "",
+                "uri": file_uri,
+                "range": {"start": {"line": line, "character": character}, "end": {"line": line, "character": character}},
+            }
+        })
+        if result is None or isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            return []
+        return [
+            {"from": c.get("from", {}).get("name", ""), "locations": [self._location_to_dict(loc) for loc in c.get("from", {}).get("locations", [])]}
+            for c in result if isinstance(c, dict)
+        ]
+
+    def outgoing_calls(self, file_uri: str, line: int, character: int) -> list[dict]:
+        result = self._send("callHierarchy/outgoingCalls", {
+            "item": {
+                "name": "",
+                "uri": file_uri,
+                "range": {"start": {"line": line, "character": character}, "end": {"line": line, "character": character}},
+            }
+        })
+        if result is None or isinstance(result, dict) and "error" in result:
+            return []
+        if not isinstance(result, list):
+            return []
+        return [
+            {"to": c.get("to", {}).get("name", ""), "locations": [self._location_to_dict(loc) for loc in c.get("to", {}).get("locations", [])]}
+            for c in result if isinstance(c, dict)
+        ]
+
+    def diagnostics(self, file_uri: str, text: str) -> list[dict]:
+        self._send("textDocument/didOpen", {
+            "textDocument": {"uri": file_uri, "languageId": "python", "version": 1, "text": text},
+        })
+        result = self._send("textDocument/diagnostic", {"textDocument": {"uri": file_uri}})
+        if result is None:
+            return []
+        if isinstance(result, dict) and "error" in result:
+            return []
+        return result.get("diagnostics", []) if isinstance(result, dict) else []
+
+    def _location_to_dict(self, loc: Any) -> dict | None:
+        if not isinstance(loc, dict):
+            return None
+        uri = loc.get("uri", "")
+        range_data = loc.get("range", {})
+        if not range_data:
+            return {"uri": uri, "line": 0, "endLine": 0, "column": 0, "endColumn": 0}
+        start = range_data.get("start", {})
+        end = range_data.get("end", {})
+        return {
+            "uri": uri,
+            "line": start.get("line", 0) + 1,
+            "endLine": end.get("line", 0) + 1,
+            "column": start.get("character", 0) + 1,
+            "endColumn": end.get("character", 0) + 1,
+        }
+
+    def stop(self):
+        if self._process:
+            try:
+                self._process.terminate()
+                self._process.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+            self._process = None
+
+
+class LSPTool:
+    def __init__(self):
+        self._servers: dict[str, LSPClient] = {}
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="LSP",
+            description="Get code intelligence from a Language Server. Supports: diagnostics, gotoDefinition, findReferences, hover, documentSymbol, workspaceSymbol, gotoImplementation, callHierarchy, incomingCalls, outgoingCalls.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "command": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "LSP server command (e.g. ['pyright-langserver', '--stdio'])",
+                    },
+                    "file_path": {"type": "string", "description": "Path to the file to analyze"},
+                    "action": {
+                        "type": "string",
+                        "enum": [
+                            "diagnostics",
+                            "gotoDefinition",
+                            "findReferences",
+                            "hover",
+                            "documentSymbol",
+                            "workspaceSymbol",
+                            "gotoImplementation",
+                            "callHierarchy",
+                            "incomingCalls",
+                            "outgoingCalls",
+                        ],
+                        "description": "LSP action to perform",
+                    },
+                    "line": {
+                        "type": "integer",
+                        "description": "Line number (1-based) for position-based actions (gotoDefinition, findReferences, hover, gotoImplementation, callHierarchy, incomingCalls, outgoingCalls)",
+                    },
+                    "character": {
+                        "type": "integer",
+                        "description": "Character position (1-based) for position-based actions",
+                    },
+                    "query": {
+                        "type": "string",
+                        "description": "Query string for workspaceSymbol action",
+                    },
+                    "include_declaration": {
+                        "type": "boolean",
+                        "description": "Include declaration in references (default: true)",
+                        "default": True,
+                    },
+                },
+                "required": ["command", "file_path", "action"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        command = tool_input.get("command", [])
+        file_path = tool_input.get("file_path", "")
+        action = tool_input.get("action", "diagnostics")
+
+        if not command or not file_path:
+            return ToolResult(name="LSP", output={"error": "command and file_path required"}, is_error=True)
+
+        server_key = "|".join(command)
+        if server_key not in self._servers:
+            workspace_root = Path(file_path).parent if file_path else Path.cwd()
+            root_uri = workspace_root.as_uri()
+            server = LSPClient(command, root_uri, workspace_root)
+            if not server.start():
+                return ToolResult(name="LSP", output={"error": f"failed to start LSP server: {command}"}, is_error=True)
+            self._servers[server_key] = server
+
+        server = self._servers[server_key]
+        file_uri = Path(file_path).absolute().as_uri()
+        text = ""
+        try:
+            text = Path(file_path).read_text(encoding="utf-8")
+        except Exception as e:
+            return ToolResult(name="LSP", output={"error": f"cannot read file: {e}"}, is_error=True)
+
+        line = tool_input.get("line", 1) - 1
+        character = tool_input.get("character", 1) - 1
+
+        try:
+            if action == "diagnostics":
+                diags = server.diagnostics(file_uri, text)
+                return ToolResult(name="LSP", output={"diagnostics": diags, "count": len(diags)})
+
+            elif action == "gotoDefinition":
+                results = server.goto_definition(file_uri, line, character)
+                return ToolResult(name="LSP", output={"definitions": results, "count": len(results)})
+
+            elif action == "findReferences":
+                include_decl = tool_input.get("include_declaration", True)
+                results = server.find_references(file_uri, line, character, include_decl)
+                return ToolResult(name="LSP", output={"references": results, "count": len(results)})
+
+            elif action == "hover":
+                result = server.hover(file_uri, line, character)
+                if result:
+                    return ToolResult(name="LSP", output=result)
+                return ToolResult(name="LSP", output={"error": "no hover info available"})
+
+            elif action == "documentSymbol":
+                symbols = server.document_symbol(file_uri)
+                return ToolResult(name="LSP", output={"symbols": symbols, "count": len(symbols)})
+
+            elif action == "workspaceSymbol":
+                query = tool_input.get("query", "")
+                symbols = server.workspace_symbol(query)
+                return ToolResult(name="LSP", output={"symbols": symbols, "count": len(symbols)})
+
+            elif action == "gotoImplementation":
+                results = server.goto_implementation(file_uri, line, character)
+                return ToolResult(name="LSP", output={"implementations": results, "count": len(results)})
+
+            elif action == "callHierarchy":
+                result = server.call_hierarchy(file_uri, line, character)
+                return ToolResult(name="LSP", output=result)
+
+            elif action == "incomingCalls":
+                results = server.incoming_calls(file_uri, line, character)
+                return ToolResult(name="LSP", output={"incomingCalls": results, "count": len(results)})
+
+            elif action == "outgoingCalls":
+                results = server.outgoing_calls(file_uri, line, character)
+                return ToolResult(name="LSP", output={"outgoingCalls": results, "count": len(results)})
+
+            else:
+                return ToolResult(name="LSP", output={"error": f"unknown action: {action}"}, is_error=True)
+
+        except Exception as e:
+            return ToolResult(name="LSP", output={"error": str(e)}, is_error=True)
+
+
+    def stop_all(self):
+        for server in self._servers.values():
+            server.stop()
+        self._servers.clear()

package/onecode/agent/tools/mcp_tools.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Any
+
+from onecode.agent.tools.protocol import ToolResult
+from onecode.agent.tools.registry import ToolSpec
+from onecode.mcp.manager import MCPManager
+
+
+class MCPTool:
+    """Call a tool from a connected MCP server (Clawd-Code pattern)."""
+
+    def __init__(self, mcp_manager: MCPManager):
+        self._mcp = mcp_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="MCPTool",
+            description="Call a tool on an MCP server. Requires an active MCP connection.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "server": {"type": "string", "description": "MCP server name"},
+                    "tool": {"type": "string", "description": "Tool name on the MCP server"},
+                    "arguments": {"type": "object", "description": "Tool arguments"},
+                },
+                "required": ["server", "tool"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        import asyncio
+        server = tool_input.get("server", "")
+        tool_name = tool_input.get("tool", "")
+        args = tool_input.get("arguments", {})
+        if not self._mcp.is_connected(server):
+            return ToolResult(
+                name="MCPTool",
+                output={"error": f"MCP server '{server}' is not connected"},
+                is_error=True,
+            )
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                import threading
+                future = asyncio.run_coroutine_threadsafe(
+                    self._mcp.call_tool(server, tool_name, args), loop
+                )
+                result = future.result(timeout=60)
+            else:
+                result = asyncio.run(self._mcp.call_tool(server, tool_name, args))
+            return ToolResult(name="MCPTool", output=result or {"error": "no response"})
+        except Exception as e:
+            return ToolResult(
+                name="MCPTool",
+                output={"error": str(e)},
+                is_error=True,
+            )
+
+
+
+class MCPResourcesTool:
+    """Access resources from a connected MCP server."""
+
+    def __init__(self, mcp_manager: MCPManager):
+        self._mcp = mcp_manager
+
+    def spec(self) -> ToolSpec:
+        return ToolSpec(
+            name="MCPResources",
+            description="List or read resources from a connected MCP server. Provides access to external data sources.",
+            input_schema={
+                "type": "object",
+                "properties": {
+                    "server": {"type": "string", "description": "MCP server name"},
+                    "action": {
+                        "type": "string",
+                        "enum": ["list", "read"],
+                        "description": "List available resources or read a specific resource",
+                    },
+                    "uri": {
+                        "type": "string",
+                        "description": "Resource URI to read (required for action='read')",
+                    },
+                },
+                "required": ["server", "action"],
+            },
+        )
+
+    def run(self, tool_input: dict[str, Any]) -> ToolResult:
+        import asyncio
+        server = tool_input.get("server", "")
+        action = tool_input.get("action", "list")
+        uri = tool_input.get("uri", "")
+        if not self._mcp.is_connected(server):
+            return ToolResult(
+                name="MCPResources",
+                output={"error": f"MCP server '{server}' is not connected"},
+                is_error=True,
+            )
+        client = self._mcp.get_client(server)
+        if not client:
+            return ToolResult(name="MCPResources", output={"error": "client not found"}, is_error=True)
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                import threading
+                if action == "list":
+                    future = asyncio.run_coroutine_threadsafe(
+                        client._send_request("resources/list", {}), loop
+                    )
+                else:
+                    future = asyncio.run_coroutine_threadsafe(
+                        client._send_request("resources/read", {"uri": uri}), loop
+                    )
+                result = future.result(timeout=60)
+            else:
+                if action == "list":
+                    result = asyncio.run(client._send_request("resources/list", {}))
+                else:
+                    result = asyncio.run(client._send_request("resources/read", {"uri": uri}))
+            return ToolResult(name="MCPResources", output=result or {"error": "no response"})
+        except Exception as e:
+            return ToolResult(
+                name="MCPResources",
+                output={"error": str(e)},
+                is_error=True,
+            )
+

package/onecode/agent/tools/permission_handler.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+
+from onecode.agent.tools.permissions import PermissionResult
+
+
+@dataclass(frozen=True)
+class PermissionDecision:
+    result: PermissionResult
+    reason: str = ""
+
+
+PermissionHandler = Callable[[str, str, dict], PermissionDecision]
+"""Signature: (tool_name: str, question: str, tool_input: dict) -> PermissionDecision"""
+
+
+class InteractivePermissionHandler:
+    """Handles ASK-level permission requests from tools.
+
+    Clawd-Code pattern: when a tool's check_permissions() returns ASK,
+    the handler determines whether to allow or deny based on user input.
+
+    The default implementation denies all ASK requests (fail-safe).
+    Callers can provide a custom handler to prompt the user interactively.
+    """
+
+    def __init__(self, handler: Optional[PermissionHandler] = None) -> None:
+        self._handler = handler
+
+    def handle(
+        self,
+        tool_name: str,
+        tool_input: dict,
+        question: str = "",
+    ) -> PermissionDecision:
+        if self._handler is not None:
+            return self._handler(tool_name, question, tool_input)
+        return PermissionDecision(
+            result=PermissionResult.DENY,
+            reason="No interactive permission handler configured",
+        )
+
+    def __repr__(self) -> str:
+        return f"InteractivePermissionHandler(handler={'set' if self._handler else 'None'})"