claw-code 0.2.0__tar.gz → 0.2.2__tar.gz

{claw_code-0.2.0 → claw_code-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claw-code
-Version: 0.2.0
+Version: 0.2.2
 Summary: Local Claude Code alternative powered by Ollama - zero API costs
 Author-email: Claw Code Contributors <instructkr@github.com>
 License: Apache-2.0

{claw_code-0.2.0 → claw_code-0.2.2}/claw_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claw-code
-Version: 0.2.0
+Version: 0.2.2
 Summary: Local Claude Code alternative powered by Ollama - zero API costs
 Author-email: Claw Code Contributors <instructkr@github.com>
 License: Apache-2.0

{claw_code-0.2.0 → claw_code-0.2.2}/claw_code.egg-info/SOURCES.txt

@@ -1,7 +1,5 @@
 LICENSE
 MANIFEST.in
-PHASE1_COMPLETE.md
-PHASE1_IMPLEMENTATION.md
 README.md
 pyproject.toml
 setup.py

{claw_code-0.2.0 → claw_code-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claw-code"
-version = "0.2.0"
+version = "0.2.2"
 description = "Local Claude Code alternative powered by Ollama - zero API costs"
 readme = "README.md"
 requires-python = ">=3.9"

{claw_code-0.2.0 → claw_code-0.2.2}/src/config.py

@@ -48,6 +48,36 @@ def load_config() -> ClaudeConfig:
         except (json.JSONDecodeError, IOError) as e:
             logger.warning(f"Failed to load config from {config_path}: {e}, using defaults")
 
+
+def write_model_to_config(model: str) -> None:
+    """Write the selected model name to ~/.claude.json"""
+    config_path = Path.home() / ".claude.json"
+    
+    try:
+        # Load existing config
+        if config_path.exists():
+            with open(config_path) as f:
+                config = json.load(f)
+        else:
+            config = {
+                "provider": "ollama",
+                "ollama_base_url": "http://localhost:11434",
+                "max_tokens": 2048,
+                "temperature": 0.7,
+                "auto_detect_vram": True,
+            }
+        
+        # Update model
+        config["model"] = model
+        
+        # Write back
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        
+        logger.info(f"Updated config with model: {model}")
+    except Exception as e:
+        logger.warning(f"Failed to write model to config: {e}")
+
     return ClaudeConfig(
         provider=defaults.get("provider", "ollama"),
         ollama_base_url=defaults.get("ollama_base_url", "http://localhost:11434"),

{claw_code-0.2.0 → claw_code-0.2.2}/src/init_wizard.py

@@ -98,8 +98,8 @@ def step_5_pull_model(recommended_model: str, available_models: list[str] | None
     """Step 5: Pull model if needed"""
     print("📋 Step 5: Model setup...")
     
-    # Check if recommended is already available
-    if available_models and recommended_model in available_models:
+    # Check if recommended is already available (handles :latest suffix)
+    if available_models and any(recommended_model in m for m in available_models):
         print(f"✓ {recommended_model} already installed\n")
         return recommended_model
     
@@ -190,12 +190,30 @@ def print_next_steps():
 
 
 def run_init_wizard() -> bool:
-    """Run the complete initialization wizard"""
+    """Run the complete initialization wizard with smart skipping"""
+    from .services.ollama_setup import check_ollama_installed
+    
+    # Check if already fully set up
+    try:
+        available = get_available_models()
+        if available and len(available) > 0:
+            # At least one model is already installed
+            print("✓ Ollama and model already installed. Skipping wizard.\n")
+            return True
+    except Exception:
+        pass
+    
     print_banner()
     
-    # Step 1: Check Ollama
-    if not step_1_check_ollama():
+    # Step 1: Check Ollama installation
+    if not check_ollama_installed():
+        print("📋 Step 1: Checking Ollama installation...")
+        print("✗ Ollama not installed")
+        print("\n→ Download from: https://ollama.ai")
+        print("→ Then run: claw-code init\n")
         return False
+    else:
+        print("📋 Step 1: Ollama found ✓\n")
     
     # Step 2: Detect system
     vram_gb = step_2_detect_system()
@@ -206,14 +224,17 @@ def run_init_wizard() -> bool:
     # Step 4: Check available models
     available = step_4_check_models()
     
-    # Step 5: Pull model if needed
-    model = step_5_pull_model(recommended, available)
-    
-    # Step 6: Check if Ollama is running
+    # Step 5: Check if Ollama is running (before pull, so server is available)
     ollama_running = step_6_start_ollama()
     
-    # Step 7: Create config
-    step_7_create_config()
+    # Step 6: Pull model if needed
+    model = step_5_pull_model(recommended, available)
+    
+    # Step 7: Create config and write model name
+    config_path = step_7_create_config()
+    if model:
+        from .config import write_model_to_config
+        write_model_to_config(model)
     
     # Step 8: Validate
     ready = step_8_validate()

{claw_code-0.2.0 → claw_code-0.2.2}/src/main.py

@@ -133,8 +133,16 @@ def main(argv: list[str] | None = None) -> int:
             print(f"✗ Failed to load session: {e}")
             return 1
     
-    # Default to REPL if no command
+    # Default: smart flow for REPL (init wizard if first-time, else REPL)
     if not args.command:
+        from pathlib import Path
+        config_path = Path.home() / ".claude.json"
+        
+        # First time: run wizard automatically
+        if not config_path.exists():
+            run_init_wizard()
+        
+        # Then launch REPL (whether first-time or returning user)
         run_repl()
         return 0
     

{claw_code-0.2.0 → claw_code-0.2.2}/src/services/ollama_adapter.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 
 import json
 import logging
+import subprocess
 from dataclasses import dataclass
 from typing import Generator
 
@@ -88,15 +89,71 @@ class OllamaAdapter:
 
     @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
+        """Get available GPU VRAM in gigabytes, with GPU detection fallback chain"""
+        # Try NVIDIA GPU via nvidia-smi
         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
+            result = subprocess.run(
+                ["nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits"],
+                capture_output=True, text=True, timeout=5, check=True
+            )
+            if result.stdout.strip():
+                vram_mib = float(result.stdout.strip().split('\n')[0])
+                vram_gb = vram_mib / 1024
+                logger.info(f"Detected {vram_gb:.1f}GB NVIDIA GPU VRAM")
+                return vram_gb
+        except (FileNotFoundError, subprocess.TimeoutExpired, ValueError):
+            pass
+
+        # Try Apple Silicon / macOS via system_profiler
+        try:
+            result = subprocess.run(
+                ["system_profiler", "SPHardwareDataType"],
+                capture_output=True, text=True, timeout=5, check=True
+            )
+            for line in result.stdout.split('\n'):
+                if 'Memory:' in line:
+                    # Parse "Memory: 16 GB" format
+                    parts = line.split(':')
+                    if len(parts) > 1:
+                        mem_str = parts[1].strip().split()[0]
+                        vram_gb = float(mem_str)
+                        logger.info(f"Detected {vram_gb:.1f}GB Apple Silicon unified memory")
+                        return vram_gb
+        except (FileNotFoundError, subprocess.TimeoutExpired, ValueError):
+            pass
+
+        # Try AMD GPU via rocm-smi
+        try:
+            result = subprocess.run(
+                ["rocm-smi", "--showmeminfo", "vram", "--csv"],
+                capture_output=True, text=True, timeout=5, check=True
+            )
+            if result.stdout.strip():
+                lines = result.stdout.strip().split('\n')
+                if len(lines) > 1:
+                    try:
+                        vram_mb = float(lines[1].split(',')[0].strip())
+                        vram_gb = vram_mb / 1024
+                        logger.info(f"Detected {vram_gb:.1f}GB AMD GPU VRAM")
+                        return vram_gb
+                    except (IndexError, ValueError):
+                        pass
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+
+        # Fallback: 50% of system RAM (GPU rarely gets full RAM allocation)
+        if PSUTIL_AVAILABLE:
+            try:
+                system_ram = psutil.virtual_memory().total / (1024 ** 3)
+                fallback_vram = system_ram * 0.5
+                logger.info(f"No GPU detected; using 50% of RAM: {fallback_vram:.1f}GB")
+                return fallback_vram
+            except Exception as e:
+                logger.warning(f"Failed to detect system RAM: {e}; assuming 8GB")
+                return 8.0
+
+        logger.warning("Could not detect VRAM; assuming 8GB")
+        return 8.0
 
     @classmethod
     def recommend_model(cls) -> str:

{claw_code-0.2.0 → claw_code-0.2.2}/src/services/ollama_setup.py

@@ -9,6 +9,7 @@ import json
 import logging
 import subprocess
 import sys
+import time
 from pathlib import Path
 
 from .ollama_adapter import OllamaAdapter, MODEL_TIERS
@@ -52,14 +53,28 @@ def check_ollama_installed() -> bool:
 
 
 def pull_model(model: str) -> bool:
-    """Pull the specified model using Ollama CLI"""
+    """Pull the specified model using Ollama CLI with auto-start of ollama serve"""
     if not check_ollama_installed():
         logger.error("Ollama CLI not found. Install from https://ollama.ai")
         return False
 
     try:
+        # Try to ensure ollama serve is running in background
+        try:
+            logger.info("Starting ollama serve in background...")
+            subprocess.Popen(
+                ["ollama", "serve"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True if sys.platform != "win32" else False
+            )
+            time.sleep(2)  # Give it a moment to start
+        except Exception as e:
+            logger.warning(f"Could not auto-start ollama serve: {e}")
+        
         logger.info(f"Pulling {model}...")
-        subprocess.run(["ollama", "pull", model], check=True)
+        # Don't capture output so Ollama's progress bar displays to user
+        subprocess.run(["ollama", "pull", model], check=True, text=True)
         logger.info(f"✓ Successfully pulled {model}")
         return True
     except subprocess.CalledProcessError as e:

claw_code-0.2.0/PHASE1_COMPLETE.md

@@ -1,317 +0,0 @@
-# Phase 1 Complete: Ollama as the Backbone
-
-**Status:** ✅ **COMPLETE** — April 10, 2026  
-**Duration:** Weeks 1–2 (Python only)  
-**Goal:** Replace Anthropic API with local Ollama, zero API costs  
-
----
-
-## 🎯 Milestone Achieved
-
-**Claw Code now works end-to-end with Ollama:**
-```bash
-python -m src turn-loop "write a Python quicksort"
-# ✓ Auto-detects VRAM
-# ✓ Selects best model tier (phi4-mini / qwen2.5-coder:7b / qwen2.5-coder:14b)
-# ✓ Queries local Ollama
-# ✓ No API keys required
-# ✓ Zero costs
-```
-
----
-
-## 📋 Work Completed
-
-### 1. ✅ API Client → Ollama Adapter Integration
-
-**File:** `src/services/ollama_adapter.py` (already done)
-
-**Features:**
-- Auto-detect VRAM and select model tier
-- Non-streaming generation (`generate()`)
-- Real-time streaming (`stream_generate()`)
-- Connection verification
-- Graceful fallback error handling
-
-### 2. ✅ Dynamic Model Detection
-
-**File:** `src/model_detection.py` (NEW)
-
-**Features:**
-- `get_available_models()` — calls `ollama list` to discover installed models
-- `select_best_model()` — picks best from available (prefers qwen2.5-coder:7b)
-- `detect_best_model()` — main entry point with auto-detection
-- Falls back gracefully if no models found
-
-### 3. ✅ Configuration System
-
-**File:** `src/config.py` (NEW)
-
-**Features:**
-- `load_config()` — reads `~/.claude.json` or uses defaults
-- `ClaudeConfig` dataclass with:
-  - `provider` (ollama)
-  - `ollama_base_url` (localhost:11434)
-  - `model` (auto-detect by default)
-  - `max_tokens`, `temperature`, etc.
-- Zero Anthropic API key logic — all removed
-
-### 4. ✅ Query Engine Integration
-
-**File:** `src/query_engine.py` (MODIFIED)
-
-**Changes:**
-- Import OllamaAdapter and model detection
-- Add `ollama_client` field to QueryEnginePort
-- `from_workspace()` now:
-  - Loads config from `~/.claude.json`
-  - Auto-detects model (calls `ollama list`)
-  - Initializes OllamaAdapter
-  - Gracefully falls back if Ollama unavailable
-- `submit_message()` now:
-  - Calls Ollama for actual LLM generation
-  - Builds context from matched commands/tools
-  - Returns real model output (not just summaries)
-- `stream_submit_message()` now:
-  - Streams tokens in real-time from Ollama
-  - Yields events for UI integration
-
-### 5. ✅ Streaming Support
-
-**Files:** `src/main.py`, `src/runtime.py` (MODIFIED)
-
-**Features:**
-- New `stream_turn_loop()` method in PortRuntime
-- CLI flag `--stream` for real-time output:
-  ```bash
-  python -m src turn-loop "prompt" --stream
-  # Shows tokens as they arrive in real-time
-  ```
-- Events streamed:
-  - `message_start` — session info
-  - `command_match` / `tool_match` — routing results
-  - `message_delta` — token text
-  - `message_stop` — usage & stop reason
-
-### 6. ✅ End-to-End Test Suite
-
-**File:** `test_phase1.py` (NEW)
-
-**Tests:**
-1. Configuration loading
-2. Model detection (`ollama list`)
-3. Ollama connection
-4. QueryEngine initialization
-5. Single-turn code generation (quicksort)
-6. Multi-turn conversation
-
-**Run with:**
-```bash
-python test_phase1.py
-```
-
-**Expected output:**
-```
-🧪 CLAW CODE PHASE 1 - END-TO-END TEST SUITE
-
-TEST 1: Configuration Loading
-✓ Provider: ollama
-✓ Ollama URL: http://localhost:11434
-...
-
-TEST 5: Single Turn (Generate Python Quicksort)
-Prompt: Write a Python function that implements quicksort algorithm
-
-Querying Ollama...
-
-Response (512 chars):
-def quicksort(arr):
-    if len(arr) <= 1:
-        return arr
-    pivot = arr[len(arr) // 2]
-    ...
-
-🎉 ALL TESTS PASSED! Phase 1 is complete.
-```
-
----
-
-## 🏗️ Architecture
-
-### Flow: `python -m src turn-loop "write code"`
-
-```
-main.py
-  ↓
-PortRuntime.run_turn_loop()
-  ↓
-QueryEnginePort.from_workspace()
-  ├─ load_config() from ~/.claude.json
-  ├─ detect_best_model() via `ollama list`
-  └─ OllamaAdapter(model="qwen2.5-coder:7b")
-  ↓
-submit_message(prompt)
-  ├─ Build context from commands/tools
-  ├─ ollama_client.generate(full_prompt)
-  └─ Return TurnResult with model output
-  ↓
-Display response
-```
-
-### Streaming Flow: `python -m src turn-loop "write code" --stream`
-
-```
-main.py --stream flag
-  ↓
-PortRuntime.stream_turn_loop()
-  ↓
-QueryEnginePort.stream_submit_message()
-  ├─ ollama_client.stream_generate(prompt)
-  └─ yield tokens as they arrive
-  ↓
-main.py displays tokens in real-time
-```
-
----
-
-## 📁 Files Modified/Created
-
-| File | Type | Purpose |
-|------|------|---------|
-| `src/config.py` | ✨ NEW | Configuration loading from ~/.claude.json |
-| `src/model_detection.py` | ✨ NEW | Dynamic model detection via `ollama list` |
-| `src/query_engine.py` | 📝 MOD | Ollama integration, real LLM calls |
-| `src/main.py` | 📝 MOD | Added `--stream` flag, streaming logic |
-| `src/runtime.py` | 📝 MOD | Added `stream_turn_loop()` method |
-| `test_phase1.py` | ✨ NEW | End-to-end test suite |
-
----
-
-## 🚀 Quick Start
-
-### Prerequisites
-```bash
-# 1. Install Ollama from ollama.ai
-# 2. Pull a model
-ollama pull qwen2.5-coder:7b
-# 3. Start Ollama
-ollama serve
-```
-
-### Usage
-```bash
-# Single prompt
-python -m src turn-loop "write a Python quicksort"
-
-# With streaming output
-python -m src turn-loop "write a Python quicksort" --stream
-
-# Multi-turn conversation
-python -m src turn-loop "explain quicksort" --max-turns 3
-
-# Run validation tests
-python test_phase1.py
-```
-
----
-
-## ✅ Phase 1 Checklist
-
-- ✅ Swap API client — Anthropic → Ollama
-- ✅ Support streaming (stream:true)
-- ✅ Model auto-detection (VRAM-based + `ollama list`)
-- ✅ Config layer (.claude.json, provider defaults)
-- ✅ Remove Anthropic API key logic
-- ✅ End-to-end test — `turn-loop` works with qwen2.5-coder:7b
-- ✅ Zero API keys required
-- ✅ Real model outputs (not stubs)
-- ✅ Streaming support for real-time responses
-- ✅ Model tier selection working
-
----
-
-## 🎯 Verification
-
-To verify Phase 1 is complete:
-
-```bash
-# 1. Run the test suite
-python test_phase1.py
-
-# 2. Manual test—generate quicksort
-python -m src turn-loop "write a Python function that implements quicksort algorithm"
-
-# 3. Streaming test
-python -m src turn-loop "write a test case" --stream
-
-# Expected: Real code output from local Ollama, no API costs
-```
-
----
-
-## 📊 Model Tiers (Auto-Selected)
-
-| VRAM | Model | Speed | Status |
-|------|-------|-------|--------|
-| ≤8GB | phi4-mini (3.8B) | 15-20 tok/s | ✅ Ready |
-| 8-12GB | qwen2.5-coder:7b | 25-40 tok/s | ✅ PRIMARY |
-| 10GB+ | qwen2.5-coder:14b | 10-20 tok/s | ✅ Ready |
-
----
-
-## 🔗 Configuration File
-
-**Location:** `~/.claude.json`  
-**Auto-created by:** `src/services/ollama_setup.py`
-
-```json
-{
-  "provider": "ollama",
-  "ollama_base_url": "http://localhost:11434",
-  "model": "auto-detect",
-  "auto_detect_vram": true,
-  "use_api_key": false,
-  "max_tokens": 2048,
-  "temperature": 0.7
-}
-```
-
----
-
-## 🎓 What Changed
-
-### Before Phase 1
-- Only stub responses (no actual LLM calls)
-- Anthropic API client (unused)
-- No model selection logic
-- "write a Python quicksort" → summary, not code
-
-### After Phase 1
-- Real Ollama calls
-- Auto-model detection
-- Actual code generation
-- "write a Python quicksort" → **working Python code in real-time**
-- Streaming support
-- Zero API costs
-
----
-
-## 🚧 Next Steps (Phase 2+)
-
-1. **Tool integration** — Wire up actual tool execution (file ops, git, etc.)
-2. **Permission system** — Enforce tool access controls
-3. **Session persistence** — Save/resume multi-turn conversations
-4. **MCP integration** — Connect Model Context Protocol tools
-5. **Rust runtime** — Performance improvements
-6. **VSCode extension** — UI wrapper
-
----
-
-## 📝 Summary
-
-**Phase 1 transforms Claw Code from a API-dependent stub into a fully-functional local coding agent powered by Ollama. Users can now generate, refactor, and debug code locally with zero API costs.**
-
-✅ **Milestone: Achieved**  
-🎯 **Ready for Phase 2**  
-📊 **Status: Production-Ready (Python)**
-