Clawd Code Python Port

from dataclasses import dataclass, fieldfrom typing import List, Optional
@dataclassclass Module:    name: str    status: str          # e.g. "ported", "stub", "backlog"    source_path: str    notes: Optional[str] = None
@dataclassclass Subsystem:    name: str    modules: List[Module] = field(default_factory=list)    description: Optional[str] = None
@dataclassclass PortManifest:    subsystems: List[Subsystem] = field(default_factory=list)    backlog: List[str] = field(default_factory=list)    version: str = "0.1.0"

from dataclasses import dataclassfrom typing import Callable, Optional, Any, Dict
@dataclassclass Tool:    name: str    description: str    parameters: Dict[str, Any]          # JSON-schema style param spec    handler: Optional[Callable] = None  # Python callable for this tool
# Example: registering a tooldef read_file_handler(path: str) -> str:    with open(path, "r") as f:        return f.read()
READ_FILE_TOOL = Tool(    name="read_file",    description="Read the contents of a file at the given path.",    parameters={        "path": {"type": "string", "description": "Absolute or relative file path"}    },    handler=read_file_handler,)
# Tool registry patternTOOL_REGISTRY: Dict[str, Tool] = {    READ_FILE_TOOL.name: READ_FILE_TOOL,}
def dispatch_tool(name: str, **kwargs) -> Any:    tool = TOOL_REGISTRY.get(name)    if tool is None:        raise ValueError(f"Unknown tool: {name}")    if tool.handler is None:        raise NotImplementedError(f"Tool '{name}' has no handler yet.")    return tool.handler(**kwargs)

from dataclasses import dataclassfrom typing import Optional, Callable, Any
@dataclassclass Command:    name: str    description: str    aliases: list    handler: Optional[Callable] = None
# Example commanddef summarize_handler(context: dict) -> str:    return f"Summarizing {len(context.get('files', []))} files."
SUMMARIZE_COMMAND = Command(    name="summarize",    description="Summarize the current workspace context.",    aliases=["sum", "overview"],    handler=summarize_handler,)
COMMAND_REGISTRY = {    SUMMARIZE_COMMAND.name: SUMMARIZE_COMMAND,}
def run_command(name: str, context: dict) -> Any:    cmd = COMMAND_REGISTRY.get(name)    if not cmd:        raise ValueError(f"Unknown command: {name}")    if not cmd.handler:        raise NotImplementedError(f"Command '{name}' not yet implemented.")    return cmd.handler(context)

from dataclasses import dataclass, fieldfrom typing import List, Optional, Any
@dataclassclass TaskResult:    success: bool    output: Any    error: Optional[str] = None
@dataclassclass Task:    goal: str    tools: List[str] = field(default_factory=list)   # tool names available    context: dict = field(default_factory=dict)    result: Optional[TaskResult] = None
    def run(self, dispatcher) -> TaskResult:        """        dispatcher: callable(tool_name, **kwargs) -> Any        Implement your agent loop here.        """        try:            # Minimal stub: just report goal received            output = f"Task received: {self.goal}"            self.result = TaskResult(success=True, output=output)        except Exception as e:            self.result = TaskResult(success=False, output=None, error=str(e))        return self.result
# Usagefrom src.tools import dispatch_tool
task = Task(    goal="Read README.md and summarize it",    tools=["read_file"],    context={"working_dir": "."},)result = task.run(dispatcher=dispatch_tool)print(result.output)

from src.port_manifest import build_manifestfrom src.query_engine import render_summary
manifest = build_manifest()summary = render_summary(manifest)print(summary)

from src.port_manifest import build_manifest
manifest = build_manifest()
for subsystem in manifest.subsystems:    print(f"[{subsystem.name}]")    for module in subsystem.modules:        print(f"  {module.name}: {module.status}")
print("Backlog:", manifest.backlog)

# src/tools.py
def list_dir_handler(path: str):    import os    return os.listdir(path)
LIST_DIR_TOOL = Tool(    name="list_dir",    description="List files in a directory.",    parameters={"path": {"type": "string"}},    handler=list_dir_handler,)
TOOL_REGISTRY["list_dir"] = LIST_DIR_TOOL

# src/commands.py
def lint_handler(context: dict) -> str:    files = context.get("files", [])    return f"Linting {len(files)} files (stub)."
LINT_COMMAND = Command(    name="lint",    description="Lint the current workspace files.",    aliases=["check"],    handler=lint_handler,)
COMMAND_REGISTRY["lint"] = LINT_COMMAND

# tests/test_tools.pyimport unittestfrom src.tools import dispatch_toolimport tempfile, os
class TestReadFileTool(unittest.TestCase):    def test_read_file(self):        with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=False) as f:            f.write("hello clawd")            path = f.name        try:            result = dispatch_tool("read_file", path=path)            self.assertEqual(result, "hello clawd")        finally:            os.unlink(path)
if __name__ == "__main__":    unittest.main()

from src.tools import dispatch_toolfrom src.task import Task
task = Task(    goal="Read and list files",    tools=["read_file", "list_dir"],    context={"working_dir": "."},)
# Manual tool chain (before full agent loop is implemented)files = dispatch_tool("list_dir", path=".")for fname in files[:3]:    content = dispatch_tool("read_file", path=fname)    print(f"--- {fname} ---\n{content[:200]}")

from src.port_manifest import build_manifest
def unported_modules():    manifest = build_manifest()    stubs = []    for sub in manifest.subsystems:        for mod in sub.modules:            if mod.status != "ported":                stubs.append((sub.name, mod.name, mod.status))    return stubs
for subsystem, module, status in unported_modules():    print(f"{subsystem}/{module} → {status}")