claw-code 0.2.0__py3-none-any.whl

src/runtime.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .commands import PORTED_COMMANDS
+from .context import PortContext, build_port_context, render_context
+from .history import HistoryLog
+from .models import PermissionDenial, PortingModule
+from .query_engine import QueryEngineConfig, QueryEnginePort, TurnResult
+from .setup import SetupReport, WorkspaceSetup, run_setup
+from .system_init import build_system_init_message
+from .tools import PORTED_TOOLS
+from .execution_registry import build_execution_registry
+
+
+@dataclass(frozen=True)
+class RoutedMatch:
+    kind: str
+    name: str
+    source_hint: str
+    score: int
+
+
+@dataclass
+class RuntimeSession:
+    prompt: str
+    context: PortContext
+    setup: WorkspaceSetup
+    setup_report: SetupReport
+    system_init_message: str
+    history: HistoryLog
+    routed_matches: list[RoutedMatch]
+    turn_result: TurnResult
+    command_execution_messages: tuple[str, ...]
+    tool_execution_messages: tuple[str, ...]
+    stream_events: tuple[dict[str, object], ...]
+    persisted_session_path: str
+
+    def as_markdown(self) -> str:
+        lines = [
+            '# Runtime Session',
+            '',
+            f'Prompt: {self.prompt}',
+            '',
+            '## Context',
+            render_context(self.context),
+            '',
+            '## Setup',
+            f'- Python: {self.setup.python_version} ({self.setup.implementation})',
+            f'- Platform: {self.setup.platform_name}',
+            f'- Test command: {self.setup.test_command}',
+            '',
+            '## Startup Steps',
+            *(f'- {step}' for step in self.setup.startup_steps()),
+            '',
+            '## System Init',
+            self.system_init_message,
+            '',
+            '## Routed Matches',
+        ]
+        if self.routed_matches:
+            lines.extend(
+                f'- [{match.kind}] {match.name} ({match.score}) — {match.source_hint}'
+                for match in self.routed_matches
+            )
+        else:
+            lines.append('- none')
+        lines.extend([
+            '',
+            '## Command Execution',
+            *(self.command_execution_messages or ('none',)),
+            '',
+            '## Tool Execution',
+            *(self.tool_execution_messages or ('none',)),
+            '',
+            '## Stream Events',
+            *(f"- {event['type']}: {event}" for event in self.stream_events),
+            '',
+            '## Turn Result',
+            self.turn_result.output,
+            '',
+            f'Persisted session path: {self.persisted_session_path}',
+            '',
+            self.history.as_markdown(),
+        ])
+        return '\n'.join(lines)
+
+
+class PortRuntime:
+    def route_prompt(self, prompt: str, limit: int = 5) -> list[RoutedMatch]:
+        tokens = {token.lower() for token in prompt.replace('/', ' ').replace('-', ' ').split() if token}
+        by_kind = {
+            'command': self._collect_matches(tokens, PORTED_COMMANDS, 'command'),
+            'tool': self._collect_matches(tokens, PORTED_TOOLS, 'tool'),
+        }
+
+        selected: list[RoutedMatch] = []
+        for kind in ('command', 'tool'):
+            if by_kind[kind]:
+                selected.append(by_kind[kind].pop(0))
+
+        leftovers = sorted(
+            [match for matches in by_kind.values() for match in matches],
+            key=lambda item: (-item.score, item.kind, item.name),
+        )
+        selected.extend(leftovers[: max(0, limit - len(selected))])
+        return selected[:limit]
+
+    def bootstrap_session(self, prompt: str, limit: int = 5) -> RuntimeSession:
+        context = build_port_context()
+        setup_report = run_setup(trusted=True)
+        setup = setup_report.setup
+        history = HistoryLog()
+        engine = QueryEnginePort.from_workspace()
+        history.add('context', f'python_files={context.python_file_count}, archive_available={context.archive_available}')
+        history.add('registry', f'commands={len(PORTED_COMMANDS)}, tools={len(PORTED_TOOLS)}')
+        matches = self.route_prompt(prompt, limit=limit)
+        registry = build_execution_registry()
+        command_execs = tuple(registry.command(match.name).execute(prompt) for match in matches if match.kind == 'command' and registry.command(match.name))
+        tool_execs = tuple(registry.tool(match.name).execute(prompt) for match in matches if match.kind == 'tool' and registry.tool(match.name))
+        denials = tuple(self._infer_permission_denials(matches))
+        stream_events = tuple(engine.stream_submit_message(
+            prompt,
+            matched_commands=tuple(match.name for match in matches if match.kind == 'command'),
+            matched_tools=tuple(match.name for match in matches if match.kind == 'tool'),
+            denied_tools=denials,
+        ))
+        turn_result = engine.submit_message(
+            prompt,
+            matched_commands=tuple(match.name for match in matches if match.kind == 'command'),
+            matched_tools=tuple(match.name for match in matches if match.kind == 'tool'),
+            denied_tools=denials,
+        )
+        persisted_session_path = engine.persist_session()
+        history.add('routing', f'matches={len(matches)} for prompt={prompt!r}')
+        history.add('execution', f'command_execs={len(command_execs)} tool_execs={len(tool_execs)}')
+        history.add('turn', f'commands={len(turn_result.matched_commands)} tools={len(turn_result.matched_tools)} denials={len(turn_result.permission_denials)} stop={turn_result.stop_reason}')
+        history.add('session_store', persisted_session_path)
+        return RuntimeSession(
+            prompt=prompt,
+            context=context,
+            setup=setup,
+            setup_report=setup_report,
+            system_init_message=build_system_init_message(trusted=True),
+            history=history,
+            routed_matches=matches,
+            turn_result=turn_result,
+            command_execution_messages=command_execs,
+            tool_execution_messages=tool_execs,
+            stream_events=stream_events,
+            persisted_session_path=persisted_session_path,
+        )
+
+    def run_turn_loop(self, prompt: str, limit: int = 5, max_turns: int = 3, structured_output: bool = False) -> list[TurnResult]:
+        engine = QueryEnginePort.from_workspace()
+        engine.config = QueryEngineConfig(max_turns=max_turns, structured_output=structured_output)
+        matches = self.route_prompt(prompt, limit=limit)
+        command_names = tuple(match.name for match in matches if match.kind == 'command')
+        tool_names = tuple(match.name for match in matches if match.kind == 'tool')
+        results: list[TurnResult] = []
+        for turn in range(max_turns):
+            turn_prompt = prompt if turn == 0 else f'{prompt} [turn {turn + 1}]'
+            result = engine.submit_message(turn_prompt, command_names, tool_names, ())
+            results.append(result)
+            if result.stop_reason != 'completed':
+                break
+        return results
+
+    def stream_turn_loop(self, prompt: str, limit: int = 5, max_turns: int = 3, structured_output: bool = False):
+        """Stream turn loop with real-time output from Ollama"""
+        engine = QueryEnginePort.from_workspace()
+        engine.config = QueryEngineConfig(max_turns=max_turns, structured_output=structured_output)
+        matches = self.route_prompt(prompt, limit=limit)
+        command_names = tuple(match.name for match in matches if match.kind == 'command')
+        tool_names = tuple(match.name for match in matches if match.kind == 'tool')
+        
+        for turn in range(max_turns):
+            turn_prompt = prompt if turn == 0 else f'{prompt} [turn {turn + 1}]'
+            for event in engine.stream_submit_message(turn_prompt, command_names, tool_names, ()):
+                yield event
+
+    def _infer_permission_denials(self, matches: list[RoutedMatch]) -> list[PermissionDenial]:
+        denials: list[PermissionDenial] = []
+        for match in matches:
+            if match.kind == 'tool' and 'bash' in match.name.lower():
+                denials.append(PermissionDenial(tool_name=match.name, reason='destructive shell execution remains gated in the Python port'))
+        return denials
+
+    def _collect_matches(self, tokens: set[str], modules: tuple[PortingModule, ...], kind: str) -> list[RoutedMatch]:
+        matches: list[RoutedMatch] = []
+        for module in modules:
+            score = self._score(tokens, module)
+            if score > 0:
+                matches.append(RoutedMatch(kind=kind, name=module.name, source_hint=module.source_hint, score=score))
+        matches.sort(key=lambda item: (-item.score, item.name))
+        return matches
+
+    @staticmethod
+    def _score(tokens: set[str], module: PortingModule) -> int:
+        haystacks = [module.name.lower(), module.source_hint.lower(), module.responsibility.lower()]
+        score = 0
+        for token in tokens:
+            if any(token in haystack for haystack in haystacks):
+                score += 1
+        return score

src/schemas/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `schemas` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'schemas.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/screens/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `screens` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'screens.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/server/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `server` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'server.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/services/__init__.py

@@ -0,0 +1,16 @@
+"""Python package placeholder for the archived `services` subsystem."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / 'reference_data' / 'subsystems' / 'services.json'
+_SNAPSHOT = json.loads(SNAPSHOT_PATH.read_text())
+
+ARCHIVE_NAME = _SNAPSHOT['archive_name']
+MODULE_COUNT = _SNAPSHOT['module_count']
+SAMPLE_FILES = tuple(_SNAPSHOT['sample_files'])
+PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."
+
+__all__ = ['ARCHIVE_NAME', 'MODULE_COUNT', 'PORTING_NOTE', 'SAMPLE_FILES']

src/services/ollama_adapter.py

@@ -0,0 +1,251 @@
+"""
+Ollama integration adapter for local LLM execution without API costs.
+Implements auto-detection of hardware and model selection.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Generator
+
+try:
+    import psutil
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+
+import requests
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class ModelTier:
+    """Model selection tier based on available VRAM"""
+    name: str
+    vram_required_gb: float
+    vram_min_gb: float
+    vram_max_gb: float
+    tokens_per_sec_estimate: str
+    use_case: str
+
+
+# Model registry by tier
+MODEL_TIERS = [
+    ModelTier(
+        name="phi4-mini",
+        vram_required_gb=3.0,
+        vram_min_gb=0,
+        vram_max_gb=8,
+        tokens_per_sec_estimate="15-20",
+        use_case="Low-end machines (M1 MacBook Air, entry laptops)"
+    ),
+    ModelTier(
+        name="qwen2.5-coder:7b",
+        vram_required_gb=6.0,
+        vram_min_gb=8,
+        vram_max_gb=12,
+        tokens_per_sec_estimate="25-40",
+        use_case="Primary recommendation (autocomplete, refactors, tests)"
+    ),
+    ModelTier(
+        name="qwen2.5-coder:14b",
+        vram_required_gb=10.0,
+        vram_min_gb=10,
+        vram_max_gb=float('inf'),
+        tokens_per_sec_estimate="10-20",
+        use_case="Power tier (complex logic, debugging, algorithms)"
+    ),
+]
+
+
+class OllamaAdapter:
+    """Adapter for local Ollama-based LLM execution"""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:11434",
+        model: str | None = None,
+        auto_detect: bool = True,
+        timeout: int = 120,
+    ):
+        """
+        Initialize Ollama adapter.
+
+        Args:
+            base_url: Ollama server URL (default: localhost:11434)
+            model: Model name override. If None and auto_detect=True, will select based on VRAM
+            auto_detect: Whether to auto-detect model based on available VRAM
+            timeout: Request timeout in seconds
+        """
+        self.base_url = base_url
+        self.timeout = timeout
+        self.model = model or (self.recommend_model() if auto_detect else "qwen2.5-coder:7b")
+        self._verify_connection()
+
+    @staticmethod
+    def get_available_vram_gb() -> float:
+        """Get available system VRAM in gigabytes"""
+        if not PSUTIL_AVAILABLE:
+            logger.warning("psutil not available; assuming 8GB VRAM")
+            return 8.0
+        try:
+            return psutil.virtual_memory().total / (1024 ** 3)
+        except Exception as e:
+            logger.warning(f"Failed to detect VRAM: {e}; assuming 8GB")
+            return 8.0
+
+    @classmethod
+    def recommend_model(cls) -> str:
+        """Auto-detect VRAM and recommend optimal model tier"""
+        vram_gb = cls.get_available_vram_gb()
+        logger.info(f"Detected {vram_gb:.1f}GB VRAM; recommending model tier...")
+
+        for tier in MODEL_TIERS:
+            if tier.vram_min_gb <= vram_gb <= tier.vram_max_gb:
+                logger.info(f"Selected {tier.name} for {vram_gb:.1f}GB VRAM")
+                logger.info(f"  Use case: {tier.use_case}")
+                logger.info(f"  Est. speed: {tier.tokens_per_sec_estimate} tokens/sec")
+                return tier.name
+
+        # Fallback to most conservative
+        logger.warning(f"VRAM {vram_gb:.1f}GB outside known ranges; using phi4-mini (conservative)")
+        return "phi4-mini"
+
+    @staticmethod
+    def print_model_roadmap() -> None:
+        """Print model selection roadmap for user reference"""
+        print("\n" + "=" * 65)
+        print("  Ollama Model Selection Roadmap")
+        print("=" * 65 + "\n")
+
+        vram_gb = OllamaAdapter.get_available_vram_gb()
+        print(f"Your system: {vram_gb:.1f}GB VRAM\n")
+
+        for tier in MODEL_TIERS:
+            marker = " ⭐ RECOMMENDED" if tier.vram_min_gb <= vram_gb <= tier.vram_max_gb else ""
+            print(f"[{tier.vram_min_gb:.0f}-{tier.vram_max_gb:.1f}GB] {tier.name}{marker}")
+            print(f"  VRAM: {tier.vram_required_gb}GB | Speed: {tier.tokens_per_sec_estimate} tok/s")
+            print(f"  {tier.use_case}\n")
+
+        print("=" * 65 + "\n")
+
+    def _verify_connection(self) -> None:
+        """Verify Ollama server is reachable"""
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            response.raise_for_status()
+            logger.info(f"✓ Connected to Ollama at {self.base_url}")
+        except requests.RequestException as e:
+            logger.error(f"✗ Cannot connect to Ollama at {self.base_url}: {e}")
+            raise RuntimeError(
+                f"Ollama server not reachable at {self.base_url}\n"
+                f"Start it with: ollama serve"
+            )
+
+    def generate(self, prompt: str) -> str:
+        """
+        Generate response from prompt (non-streaming).
+
+        Args:
+            prompt: Input prompt
+
+        Returns:
+            Generated response text
+        """
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": False,
+                },
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.json()["response"]
+        except requests.RequestException as e:
+            logger.error(f"Generation failed: {e}")
+            raise
+
+    def stream_generate(self, prompt: str) -> Generator[str, None, None]:
+        """
+        Stream-based generation (yields tokens as they arrive).
+
+        Args:
+            prompt: Input prompt
+
+        Yields:
+            Token strings as they are generated
+        """
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": True,
+                },
+                stream=True,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+
+            for line in response.iter_lines():
+                if line:
+                    try:
+                        chunk = json.loads(line)
+                        token = chunk.get("response", "")
+                        if token:
+                            yield token
+                    except json.JSONDecodeError:
+                        logger.warning(f"Failed to parse chunk: {line}")
+                        continue
+
+        except requests.RequestException as e:
+            logger.error(f"Stream generation failed: {e}")
+            raise
+
+    def formats_supported(self) -> dict:
+        """Get supported formats from Ollama server"""
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            response.raise_for_status()
+            return response.json()
+        except requests.RequestException as e:
+            logger.error(f"Failed to fetch formats: {e}")
+            return {}
+
+
+def create_ollama_adapter(
+    base_url: str = "http://localhost:11434",
+    model: str | None = None,
+    auto_detect: bool = True,
+) -> OllamaAdapter:
+    """Factory function for creating OllamaAdapter instances"""
+    return OllamaAdapter(
+        base_url=base_url,
+        model=model,
+        auto_detect=auto_detect,
+    )
+
+
+if __name__ == "__main__":
+    # CLI for testing/demo
+    import sys
+
+    logging.basicConfig(level=logging.INFO)
+
+    if len(sys.argv) > 1 and sys.argv[1] == "roadmap":
+        OllamaAdapter.print_model_roadmap()
+    else:
+        # Test connection
+        print("Testing Ollama adapter...")
+        adapter = OllamaAdapter()
+        print(f"Model: {adapter.model}")
+        print(f"Base URL: {adapter.base_url}")
+        print("✓ Connection verified")