alpiecode 9.0.6__tar.gz → 10.0.1__tar.gz

{alpiecode-9.0.6 → alpiecode-10.0.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.6
-Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
+Version: 10.0.1
+Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
 Requires-Dist: rich>=13.0

{alpiecode-9.0.6 → alpiecode-10.0.1}/README.md

@@ -1,4 +1,4 @@
-# ⚡ AlpieCode: Autonomous AI Software Engineering Agent & Full Developer Platform
+# AlpieCode
 
 [![Python Version](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue.svg)](https://www.python.org/)
 [![Version](https://img.shields.io/badge/alpiecode-v9.0.1-emerald.svg)](https://github.com/169Pi/codeagent-poc)

{alpiecode-9.0.6 → alpiecode-10.0.1}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "9.0.6"
-description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
+version = "10.0.1"
+description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [
     "huggingface_hub>=0.20.0",

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.6
-Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
+Version: 10.0.1
+Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0
 Requires-Dist: rich>=13.0

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/codeagent/__init__.py

@@ -1,6 +1,7 @@
 import warnings
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=SyntaxWarning, message=r".*invalid escape sequence.*")
 warnings.filterwarnings("ignore", module="jupyter_client.*")
 
 """
@@ -16,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "9.0.6"
+__version__ = "10.0.1"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

alpiecode-10.0.1/src/codeagent/backends/local_backend.py

@@ -0,0 +1,314 @@
+"""
+Local GGUF model inference backend.
+"""
+
+from typing import Any, List, Optional
+
+from ..config import Config
+from ..local_model import LocalModel
+from .base import ChatResponse, ToolCall
+
+
+class LocalBackend:
+    """Backend for local GGUF model inference via llama-cpp-python."""
+
+    def __init__(self, cfg: Config):
+        self._cfg = cfg
+        self._model: Optional[LocalModel] = None
+
+    @property
+    def name(self) -> str:
+        return f"Local GGUF ({self._cfg.model_repo})"
+
+    @property
+    def is_available(self) -> bool:
+        return True  # Local model is always available (downloads if missing)
+
+    @property
+    def context_window(self) -> int:
+        return self._cfg.n_ctx
+
+    def _ensure_model(self) -> LocalModel:
+        if self._model is None:
+            self._model = LocalModel(
+                repo_id=self._cfg.model_repo,
+                n_ctx=self._cfg.n_ctx,
+                n_gpu_layers=self._cfg.n_gpu_layers,
+                token=self._cfg.hf_token,
+            )
+        return self._model
+
+    def load_model(self) -> None:
+        """Explicitly load model into VRAM/RAM (warmup)."""
+        model = self._ensure_model()
+        model.load()
+
+    @staticmethod
+    def _sanitize_messages_for_gguf(messages: List[dict]) -> List[dict]:
+        """
+        Sanitize OpenAI-format messages for GGUF Jinja2 chat templates.
+        Fixes 'Can only get item pairs from a mapping' errors by:
+        - Ensuring content is always a string (never None or list)
+        - Stripping tool_calls and tool messages (GGUF templates don't support them)
+        - Removing tool-related role messages
+        """
+        sanitized = []
+        for msg in messages:
+            role = msg.get("role", "")
+            if role == "tool":
+                # Bridge tool execution results into ChatML user turns so local model sees outputs
+                name = msg.get("name") or "tool"
+                raw_content = msg.get("content") or ""
+                if not isinstance(raw_content, str):
+                    raw_content = str(raw_content)
+                # Smart failure-preserving truncation for local offline context
+                from ..tools import _smart_truncate
+                raw_content = _smart_truncate(raw_content, max_chars=1800)
+
+                tool_text = f"[Tool Result for {name}]:\n{raw_content}"
+                if sanitized and sanitized[-1].get("role") == "user":
+                    sanitized[-1]["content"] += "\n\n" + tool_text
+                else:
+                    sanitized.append({"role": "user", "content": tool_text})
+                continue
+
+            clean = {"role": role}
+
+            # Ensure content is always a string
+            content = msg.get("content")
+            if content is None:
+                content = ""
+            elif isinstance(content, list):
+                # Multimodal content (image_url + text blocks) — extract text parts
+                text_parts = []
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text":
+                            text_parts.append(part.get("text", ""))
+                    elif isinstance(part, str):
+                        text_parts.append(part)
+                content = "\n".join(text_parts) if text_parts else ""
+            elif not isinstance(content, str):
+                content = str(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text
+            if role == "assistant" and msg.get("tool_calls"):
+                tc_descriptions = []
+                for tc in msg["tool_calls"]:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        name = fn.get("name", "unknown")
+                        args = fn.get("arguments", "{}")
+                        tc_descriptions.append(f"[Called tool: {name}({args})]")
+                if tc_descriptions:
+                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                # Do NOT include tool_calls key — GGUF template will crash on it
+
+            clean["content"] = content
+            sanitized.append(clean)
+
+        return sanitized
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
+        resp = model.create_chat_completion(
+            messages=sanitized_msgs,
+            tools=tools,
+            tool_choice="auto",
+            temperature=temperature,
+            max_tokens=max_tokens,
+            enable_thinking=enable_thinking,
+        )
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if msg.tool_calls:
+            import json
+            tool_calls = []
+            for tc in msg.tool_calls:
+                args = tc.function.arguments
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args or "{}")
+                    except Exception:
+                        args = {}
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        arguments=args if isinstance(args, dict) else {},
+                    )
+                )
+
+        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
+
+        return ChatResponse(
+            content=msg.content,
+            reasoning=reasoning,
+            tool_calls=tool_calls,
+            raw=resp,
+        )
+
+    def chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        """
+        Stream local GGUF completion yielding progressive thinking deltas,
+        content tokens, and the final ChatResponse.
+        """
+        import time
+        start_time = time.time()
+        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.2)
+        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 2048)
+
+        model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
+
+        chunks = model.create_chat_completion(
+            messages=sanitized_msgs,
+            tools=tools,
+            tool_choice="auto" if tools else None,
+            temperature=temp,
+            max_tokens=m_tokens,
+            enable_thinking=enable_thinking,
+            stream=True,
+        )
+
+        try:
+            from .openai_backend import _repair_and_parse_json_arguments
+        except Exception:
+            import json
+            def _repair_and_parse_json_arguments(raw_args: str) -> dict:
+                try:
+                    return json.loads(raw_args or "{}")
+                except Exception:
+                    return {}
+
+        in_think = enable_thinking
+        think_started = False
+        full_content = []
+        full_reasoning = []
+        tool_calls_dict = {}
+
+        for chunk in chunks:
+            if not chunk or not chunk.get("choices"):
+                continue
+            choice = chunk["choices"][0]
+            delta = choice.get("delta") or {}
+
+            explicit_reasoning = delta.get("reasoning") or delta.get("reasoning_content")
+            if explicit_reasoning:
+                if not think_started:
+                    think_started = True
+                    yield ("thinking_start", {"time": start_time})
+                full_reasoning.append(explicit_reasoning)
+                yield ("thinking_delta", {"delta": explicit_reasoning})
+
+            if delta.get("tool_calls"):
+                for tc in delta["tool_calls"]:
+                    idx = tc.get("index", 0)
+                    if idx not in tool_calls_dict:
+                        fn = tc.get("function") or {}
+                        tool_calls_dict[idx] = {
+                            "id": tc.get("id") or f"call_{idx}",
+                            "name": fn.get("name", ""),
+                            "arguments": fn.get("arguments", ""),
+                        }
+                    else:
+                        if tc.get("id"):
+                            tool_calls_dict[idx]["id"] = tc["id"]
+                        fn = tc.get("function") or {}
+                        if fn.get("name"):
+                            tool_calls_dict[idx]["name"] += fn["name"]
+                        if fn.get("arguments"):
+                            tool_calls_dict[idx]["arguments"] += fn["arguments"]
+
+            text = delta.get("content")
+            if text:
+                if in_think:
+                    if not think_started:
+                        think_started = True
+                        yield ("thinking_start", {"time": start_time})
+
+                    if "</think>" in text:
+                        before, after = text.split("</think>", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        if after.strip():
+                            full_content.append(after)
+                            yield ("token", {"delta": after})
+                    elif "DONE:" in text:
+                        before, after = text.split("DONE:", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        done_chunk = "DONE:" + after
+                        full_content.append(done_chunk)
+                        yield ("token", {"delta": done_chunk})
+                    else:
+                        clean_text = text.replace("<think>", "")
+                        full_reasoning.append(clean_text)
+                        yield ("thinking_delta", {"delta": clean_text})
+                else:
+                    full_content.append(text)
+                    yield ("token", {"delta": text})
+
+        if in_think and think_started:
+            elapsed = time.time() - start_time
+            yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+
+        tool_calls = None
+        if tool_calls_dict:
+            tool_calls = []
+            for idx in sorted(tool_calls_dict.keys()):
+                item = tool_calls_dict[idx]
+                args = _repair_and_parse_json_arguments(item.get("arguments", ""))
+                tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
+
+        final_content_str = "".join(full_content).strip()
+        final_reasoning_str = "".join(full_reasoning).strip()
+
+        if not final_content_str and final_reasoning_str:
+            if "DONE:" in final_reasoning_str:
+                idx = final_reasoning_str.find("DONE:")
+                final_content_str = final_reasoning_str[idx:].strip()
+                final_reasoning_str = final_reasoning_str[:idx].strip()
+                yield ("token", {"delta": final_content_str})
+            elif "</think>" in final_reasoning_str:
+                parts = final_reasoning_str.split("</think>", 1)
+                final_reasoning_str = parts[0].strip()
+                final_content_str = parts[1].strip()
+                yield ("token", {"delta": final_content_str})
+
+        chat_resp = ChatResponse(
+            content=final_content_str,
+            reasoning=final_reasoning_str or None,
+            tool_calls=tool_calls,
+            raw=None,
+        )
+        yield ("done", chat_resp)
+
+    def shutdown(self) -> None:
+        if self._model:
+            self._model._llm = None
+            self._model = None

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/codeagent/config.py

@@ -30,6 +30,8 @@ DEFAULTS = {
     "temperature": 0.1,
     "max_tokens": 8192,
     "enable_thinking": False,  # Reasoning OFF by default
+    "adaptive_thinking": True,  # Adaptive turn-level reasoning dynamics
+    "force_thinking": False,  # Force reasoning on every single turn
     "n_ctx": 32768,  # 32k context window
     "n_gpu_layers": None,  # None = auto-detect GPU
     "config_version": CONFIG_VERSION,
@@ -92,6 +94,8 @@ class Config:
     temperature: float = 0.1
     max_tokens: int = 8192
     enable_thinking: bool = False
+    adaptive_thinking: bool = True
+    force_thinking: bool = False
     n_ctx: int = 32768
     n_gpu_layers: Optional[int] = None
 

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/codeagent/discovery.py

@@ -220,6 +220,11 @@ def scan_repository(workdir: Path) -> dict:
     Designed to run in under 30ms by checking only key indicator files.
     """
     workdir = workdir.resolve()
+    if not workdir.exists():
+        try:
+            workdir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
 
     has_git = (workdir / ".git").is_dir()
     has_venv = (workdir / ".venv").is_dir() or (workdir / "venv").is_dir()
@@ -407,7 +412,7 @@ def _has_test_files(workdir: Path) -> bool:
         for f in workdir.iterdir():
             if f.is_file() and (f.name.startswith("test_") or f.name.endswith("_test.py")):
                 return True
-    except PermissionError:
+    except (PermissionError, FileNotFoundError):
         pass
     return False
 

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/codeagent/doctor.py

@@ -12,7 +12,7 @@ import shutil
 import socket
 import subprocess
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Any, Dict, List, Tuple
 from urllib.parse import urlparse
 
 from .config import load_config, is_server_reachable, is_internet_available
@@ -45,24 +45,54 @@ def _check_command(cmd: str) -> Tuple[bool, str]:
         return True, "installed"
 
 
-def _check_gpu() -> Tuple[bool, str]:
-    """Check NVIDIA GPU and CUDA support."""
-    nvidia_smi = shutil.which("nvidia-smi")
-    if not nvidia_smi:
-        return False, "No NVIDIA GPU detected (CPU mode)"
+def _check_gpu() -> Dict[str, Any]:
+    """Check both physical GPU hardware and llama-cpp runtime offload support."""
+    hardware_gpu = None
+    nvidia_smi = (
+        shutil.which("nvidia-smi")
+        or shutil.which("nvidia-smi.exe")
+        or (shutil.which("/usr/lib/wsl/lib/nvidia-smi") if Path("/usr/lib/wsl/lib/nvidia-smi").exists() else None)
+    )
+    if nvidia_smi:
+        try:
+            res = subprocess.run(
+                [str(nvidia_smi), "--query-gpu=name,memory.total", "--format=csv,noheader"],
+                capture_output=True,
+                text=True,
+                timeout=3,
+            )
+            if res.returncode == 0 and res.stdout.strip():
+                hardware_gpu = f"NVIDIA GPU: {res.stdout.strip().splitlines()[0]}"
+            else:
+                hardware_gpu = "NVIDIA GPU driver present"
+        except Exception:
+            hardware_gpu = "NVIDIA GPU driver present"
+    elif sys.platform == "darwin":
+        import platform
+        if "arm" in platform.processor().lower():
+            hardware_gpu = "Apple Silicon (Metal)"
+
+    runtime_offload = False
+    runtime_backend = "CPU only"
     try:
-        res = subprocess.run(
-            [nvidia_smi, "--query-gpu=name,memory.total", "--format=csv,noheader"],
-            capture_output=True,
-            text=True,
-            timeout=3,
-        )
-        if res.returncode == 0 and res.stdout.strip():
-            gpu_info = res.stdout.strip().split("\n")[0]
-            return True, f"NVIDIA GPU: {gpu_info}"
+        import llama_cpp
+        runtime_offload = bool(getattr(llama_cpp, "llama_supports_gpu_offload", lambda: False)())
+        if runtime_offload:
+            if hardware_gpu and "NVIDIA" in hardware_gpu:
+                runtime_backend = "CUDA"
+            elif hardware_gpu and "Apple" in hardware_gpu:
+                runtime_backend = "Metal"
+            else:
+                runtime_backend = "GPU Offload"
     except Exception:
         pass
-    return True, "NVIDIA GPU driver present"
+
+    return {
+        "has_hardware": hardware_gpu is not None,
+        "hardware_info": hardware_gpu or "No dedicated GPU detected (CPU mode)",
+        "runtime_offload": runtime_offload,
+        "runtime_backend": runtime_backend,
+    }
 
 
 def _check_remote_latency(base_url: str) -> Tuple[bool, str]:
@@ -131,13 +161,23 @@ def run_doctor() -> int:
     # 2. CUDA / Hardware Acceleration
     print()
     print(_colorize("  🖥️  Hardware & GPU Acceleration", "cyan"))
-    has_gpu, gpu_msg = _check_gpu()
-    if has_gpu:
-        print(f"     {_colorize('✅', 'green')} {gpu_msg}")
+    gpu_diag = _check_gpu()
+    if gpu_diag["has_hardware"]:
+        print(f"     {_colorize('✅', 'green')} Hardware: {gpu_diag['hardware_info']}")
         passed_checks += 1
+        if gpu_diag["runtime_offload"]:
+            print(f"     {_colorize('✅', 'green')} Python Runtime: llama-cpp-python ({gpu_diag['runtime_backend']} acceleration enabled)")
+            passed_checks += 1
+        else:
+            print(f"     {_colorize('⚠️ ', 'yellow')} Python Runtime: llama-cpp-python is running in CPU mode (no CUDA build)")
+            print(f"     {_colorize('💡', 'cyan')} To enable 5-10x faster GPU acceleration, install the CUDA wheel:")
+            print(f"        {_colorize('pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124', 'bold')}")
     else:
-        print(f"     {_colorize('ℹ️ ', 'blue')} {gpu_msg}")
-    total_checks += 1
+        print(f"     {_colorize('ℹ️ ', 'blue')} {gpu_diag['hardware_info']}")
+        if gpu_diag["runtime_offload"]:
+            print(f"     {_colorize('ℹ️ ', 'dim')} Python Runtime: llama-cpp-python GPU offload ready")
+        passed_checks += 1
+    total_checks += 2
 
     # 3. Network & Connectivity
     print()
@@ -166,26 +206,26 @@ def run_doctor() -> int:
     print()
     print(_colorize("  🧰 Development Tools & Compilers", "cyan"))
     tools_to_check = [
-        ("node", "Node.js (JavaScript/TypeScript runtime)"),
-        ("npm", "Node Package Manager"),
-        ("gcc", "GNU C Compiler"),
-        ("g++", "GNU C++ Compiler"),
-        ("git", "Git Version Control"),
-        ("go", "Go Programming Language (optional)"),
-        ("rustc", "Rust Compiler (optional)"),
-        ("java", "Java JDK (optional)"),
+        ("git", "Git Version Control", False),
+        ("gcc", "GNU C Compiler", False),
+        ("g++", "GNU C++ Compiler", False),
+        ("node", "Node.js (JavaScript/TypeScript runtime, optional)", True),
+        ("npm", "Node Package Manager (optional)", True),
+        ("go", "Go Programming Language (optional)", True),
+        ("rustc", "Rust Compiler (optional)", True),
+        ("java", "Java JDK (optional)", True),
     ]
-    for tool_name, desc in tools_to_check:
+    for tool_name, desc, is_optional in tools_to_check:
         ok, msg = _check_command(tool_name)
-        is_optional = "optional" in desc
         if ok:
             print(f"     {_colorize('✅', 'green')} {tool_name:8s} : {msg}")
             passed_checks += 1
+            total_checks += 1
         elif is_optional:
             print(f"     {_colorize('ℹ️ ', 'dim')} {tool_name:8s} : not installed (optional)")
         else:
             print(f"     {_colorize('⚠️ ', 'yellow')} {tool_name:8s} : not installed")
-        total_checks += 1
+            total_checks += 1
 
     # 5. VS Code Integration
     print()

{alpiecode-9.0.6 → alpiecode-10.0.1}/src/codeagent/local_model.py

@@ -313,6 +313,7 @@ class LocalModel:
 
         if self.n_gpu_layers != 0 and not has_gpu_offload:
             print("   ⚠️  Warning: Active Python environment has no CUDA llama-cpp support. Running on CPU.")
+            print("   💡 Tip: Run 'alpiecode doctor' for the one-line command to install the CUDA GPU wheel.")
             accel = "CPU (No CUDA in Python env)"
             self.n_gpu_layers = 0
         else:
@@ -362,7 +363,9 @@ class LocalModel:
             model_path=str(model_path),
             n_ctx=self.n_ctx,
             n_batch=2048 if self.n_gpu_layers == 0 else 4096,
+            n_ubatch=512,
             n_threads=n_threads,
+            n_threads_batch=max(1, os.cpu_count() or 4),
             n_gpu_layers=self.n_gpu_layers,
             use_mmap=True,
             flash_attn=(self.n_gpu_layers != 0),  # Flash Attention only for GPU
@@ -381,6 +384,14 @@ class LocalModel:
 
         try:
             self._llm = Llama(**llama_kwargs)
+            # In-Memory KV Prompt Prefix Caching for instant Turn 2+ speedup
+            try:
+                import llama_cpp
+                if hasattr(llama_cpp, "LlamaRAMCache") and hasattr(self._llm, "set_cache"):
+                    cache = llama_cpp.LlamaRAMCache(capacity_bytes=512 * 1024 * 1024)
+                    self._llm.set_cache(cache)
+            except Exception:
+                pass
         finally:
             # Restore stderr
             if _stderr_fd is not None:
@@ -425,15 +436,20 @@ class LocalModel:
         except Exception:
             pass
 
+        stream = kwargs.get("stream", False)
         params = {
             "messages": msgs,
             "temperature": 0.1 if not enable_thinking else temperature,
             "max_tokens": max_tokens,
+            "stream": stream,
         }
         if tools:
             params["tools"] = tools
             params["tool_choice"] = kwargs.get("tool_choice", "auto")
 
+        if stream:
+            return llm.create_chat_completion(**params)
+
         try:
             result_dict = llm.create_chat_completion(**params)
         except ValueError as ve: