alpiecode 10.0.1__tar.gz → 10.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.1
+Version: 10.0.3
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

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

@@ -1,7 +1,7 @@
 # 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)
+[![Version](https://img.shields.io/badge/alpiecode-v10.0.2-emerald.svg)](https://github.com/169Pi/codeagent-poc)
 [![VS Code Extension](https://img.shields.io/badge/vscode%20extension-v8.0.8-blueviolet.svg)](https://marketplace.visualstudio.com/)
 [![FastAPI](https://img.shields.io/badge/FastAPI-0.100%2B-009688.svg)](https://fastapi.tiangolo.com/)
 [![Jupyter & Colab](https://img.shields.io/badge/Jupyter%20%7C%20Colab-Ready-f37726.svg)](https://colab.research.google.com/)
@@ -16,16 +16,18 @@
 ## 📑 Table of Contents
 1. [🌟 Overview & Capabilities](#-overview--capabilities)
 2. [🏗️ Core Architecture & Hybrid Dual-Engine](#️-core-architecture--hybrid-dual-engine)
-3. [📦 Complete Installation Guide](#-complete-installation-guide)
-4. [🚀 Backend API Server (`alpiecode serve`)](#-backend-api-server-alpiecode-serve)
-5. [⌨️ Command-Line Interface (CLI) Full Reference](#️-command-line-interface-cli-full-reference)
-6. [💻 VS Code Extension Deep-Dive](#-vs-code-extension-deep-dive)
-7. [🐍 Python SDK Reference (Programmatic Usage)](#-python-sdk-reference-programmatic-usage)
-8. [📓 Jupyter Notebooks, JupyterLab & Google Colab](#-jupyter-notebooks-jupyterlab--google-colab)
-9. [🛠️ 15 Built-In Autonomous Agent Tools](#️-15-built-in-autonomous-agent-tools)
-10. [🛡️ Safety Guardian, Git Checkpoints & Memory System](#️-safety-guardian-git-checkpoints--memory-system)
-11. [⚙️ Configuration & Environment Variables](#️-configuration--environment-variables)
-12. [❓ FAQ & Troubleshooting](#-faq--troubleshooting)
+3. [⚡ System 1 (Jev Architecture) & Performance Engine](#-system-1-jev-architecture--performance-engine)
+4. [📊 Performance & Optimization Benchmarks](#-performance--optimization-benchmarks)
+5. [📦 Complete Installation Guide](#-complete-installation-guide)
+6. [🚀 Backend API Server (`alpiecode serve`)](#-backend-api-server-alpiecode-serve)
+7. [⌨️ Command-Line Interface (CLI) Full Reference](#️-command-line-interface-cli-full-reference)
+8. [💻 VS Code Extension Deep-Dive](#-vs-code-extension-deep-dive)
+9. [🐍 Python SDK Reference (Programmatic Usage)](#-python-sdk-reference-programmatic-usage)
+10. [📓 Jupyter Notebooks, JupyterLab & Google Colab](#-jupyter-notebooks-jupyterlab--google-colab)
+11. [🛠️ 15 Built-In Autonomous Agent Tools](#️-15-built-in-autonomous-agent-tools)
+12. [🛡️ Safety Guardian, Git Checkpoints & Memory System](#️-safety-guardian-git-checkpoints--memory-system)
+13. [⚙️ Configuration & Environment Variables](#️-configuration--environment-variables)
+14. [❓ FAQ & Troubleshooting](#-faq--troubleshooting)
 
 ---
 
@@ -122,6 +124,78 @@ AlpieCode employs an intelligent **Hybrid Dual-Engine** routing system that pair
 
 ---
 
+## ⚡ System 1 (Jev Architecture) & Performance Engine
+
+AlpieCode introduces a **Dual-Process Cognitive Architecture** inspired by TypeSafe AI's **Jev (System 1)** framework:
+- **System 1 (Fast Reflex & Decision Plane)**: A sub-5ms non-autoregressive decision engine that handles routine routing, parameter validation, test parsing, loop prevention, and error triage.
+- **System 2 (Deep Thought & Generative Engine)**: The heavy reasoning LLM (169Pi Cloud VLA / Claude / GPT-4o online, or local Qwen GGUF offline) dedicated purely to code synthesis and architectural reasoning.
+
+```
+                  ┌──────────────────────────────────────────────┐
+                  │              User Coding Task                │
+                  └──────────────────────┬───────────────────────┘
+                                         │
+┌────────────────────────────────────────▼──────────────────────────────────────────────────┐
+│ SYSTEM 1: Jev Decision Plane (<5ms)                                                       │
+│ • Tool Call Validation   • Repeated Loop Detection   • Test Result Triage                 │
+│ • Surgical Diff Enforcement                          • Context Noise Filtering            │
+└────────────────────────────────────────┬──────────────────────────────────────────────────┘
+                                         │
+                     ┌───────────────────┴───────────────────┐
+                     ▼                                       ▼
+       ┌───────────────────────────┐           ┌───────────────────────────┐
+       │   Online Cloud Backend    │           │    Offline Local Engine   │
+       │   (169Pi / Claude / GPT)  │           │   (llama.cpp Qwen GGUF)   │
+       │  • Sub-12s Task Completion│           │  • Zero Context Overflow  │
+       │  • >75% Token Savings     │           │  • Zero Syntax Crash Loops│
+       └───────────────────────────┘           └───────────────────────────┘
+```
+
+### Key Capabilities
+
+1. **⚡ TypeSafe System 1 Decision Loop (`src/codeagent/system1.py`)**:
+   - **Loop & Oscillation Detection**: Tracks tool call signatures. If the agent fails an operation twice (e.g. repeated syntax errors), System 1 intercepts the turn and forces a targeted `edit_file` directive rather than an infinite full-file rewrite.
+   - **Automated Test Health Parser**: Fast regex engine parsing pytest, unittest, and npm test outputs in <1ms to determine test success without burning LLM inference.
+   - **Tool Parameter Validator**: Pre-execution validation preventing malformed or missing parameters.
+
+2. **🚀 Multi-Tier Caching System (`src/codeagent/cache.py`)**:
+   - **`FileReadCache`**: In-memory cache for repeated file reads keyed by `(path, mtime, size, line_range)`. Cuts read latency from 1.2ms to **<0.05ms** (24x speedup).
+   - **`TestResultCache`**: Disk-persisted cache in `~/.alpiecode/cache/test_cache.json` keyed by a workspace file fingerprint (`hash(mtimes)`). Unchanged test suites re-run in **<1ms** with zero redundant execution.
+   - **`ResponseCache`**: Disk-backed LRU cache for pure text explanations and Q&A.
+
+3. **🗜️ Context Noise Filtering (`src/codeagent/context.py`)**:
+   - Compresses 50+ lines of clean passing test noise down to a 2-line summary (`[Clean Test Output]`).
+   - On test failures, preserves critical tracebacks and failure frames while stripping passing test dots, achieving **>75% token reduction**.
+
+4. **📊 Real-Time Performance Observability (`src/codeagent/metrics.py`)**:
+   - At the conclusion of every task, AlpieCode renders an end-of-task summary:
+   ```text
+   ╭──────────────────────── 📊 Task Performance Summary ────────────────────────╮
+   │ ⏱️  Latency: 12.22s  |  🧠 LLM Calls: 2 (5425ms)                           │
+   │ 🛠️  Tools Time: 153.5ms (1 calls)  |  📦 Context Prep: 6253ms  |  ⚡ Cache: 1│
+   ╰─────────────────────────────────────────────────────────────────────────────╯
+   ```
+
+5. **📜 Agent Operational Guidelines (`agents.md`)**:
+   - Operational rules defining the **Investigate → Plan → Surgical Edit → Verify → Complete** cycle, enforcing surgical diffs for files >100 lines and zero stub implementations.
+
+---
+
+## 📊 Performance & Optimization Benchmarks
+
+Comprehensive benchmarks comparing AlpieCode before vs. after the System 1 Jev engine and caching upgrade:
+
+| Benchmark Metric | Baseline (v9.0) | With System 1 & Caching (v10.0.2) | Improvement |
+| :--- | :---: | :---: | :---: |
+| **Simple Test & Verify Task Latency** | 45.57s | **12.22s** | **3.7x faster (73% drop)** |
+| **Repeated File Read Latency** | 1.20 ms | **<0.05 ms** | **24x faster** (In-Memory Cache) |
+| **Unchanged Test Suite Re-run** | 3,500 ms | **<1.0 ms** | **Instant (Zero-Latency Cache)** |
+| **Test Output Context Token Footprint**| ~3,500 tokens (500 lines) | **~80 tokens (4 lines)** | **>75% Context Compression** |
+| **Syntax Error Retry Recovery** | Infinite full-file loop | **Loop intercepted on Turn 2** | Self-healing surgical diff |
+| **Full Regression Test Suite** | 52 passed | **96 passed (100% green)** | Complete reliability |
+
+---
+
 ## 📦 Complete Installation Guide
 
 ### 1. Prerequisites
@@ -177,7 +251,7 @@ pip install dist/alpiecode-9.0.1-py3-none-any.whl
 #### Verify CLI Installation:
 ```bash
 alpiecode version
-# Output: alpiecode 9.0.1
+# Output: alpiecode 10.0.2
 
 alpiecode doctor
 ```

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.0.1"
+version = "10.0.3"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.0.1
+Version: 10.0.3
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/alpiecode.egg-info/SOURCES.txt

@@ -26,12 +26,14 @@ src/codeagent/ipython_ext.py
 src/codeagent/local_model.py
 src/codeagent/media.py
 src/codeagent/memory.py
+src/codeagent/metrics.py
 src/codeagent/orchestrator.py
 src/codeagent/progress.py
 src/codeagent/prompt.py
 src/codeagent/rephraser.py
 src/codeagent/server.py
 src/codeagent/session.py
+src/codeagent/system1.py
 src/codeagent/tools.py
 src/codeagent/updater.py
 src/codeagent/vscode_installer.py
@@ -41,9 +43,17 @@ src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
 test/test_audit_fixes.py
+test/test_benchmark_system1.py
+test/test_cache_reads.py
 test/test_chat_mode.py
 test/test_claude_codex_capabilities.py
+test/test_context_filter.py
+test/test_math_tools.py
+test/test_metrics.py
 test/test_offline_mode.py
+test/test_offline_opt.py
+test/test_palindrome_check.py
 test/test_phase1.py
 test/test_phase2.py
-test/test_phase3.py
+test/test_phase3.py
+test/test_system1.py

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

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.0.1"
+__version__ = "10.0.3"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/agent.py

@@ -432,6 +432,43 @@ def run_agent(
                     style="dim"
                 )
 
+        elif event.type == "system1_intervention" and verbose:
+            data = event.data
+            action = data.get("action", "")
+            err_type = data.get("error_type", "")
+            directive = data.get("directive", "")
+            if HAS_RICH:
+                console.print(Panel(
+                    f"[bold yellow]⚡ System 1 (Jev) Intervention[/bold yellow] (Turn {data.get('turn')})\n"
+                    f"• Action: [cyan]{action}[/cyan] | Error Type: [red]{err_type}[/red]\n"
+                    f"• Directive: {directive}",
+                    border_style="yellow",
+                    padding=(0, 1)
+                ))
+            else:
+                print(f"\n⚡ [System 1 Intervention] {action}: {directive}")
+
+        elif event.type == "metrics" and verbose:
+            data = event.data
+            if HAS_RICH:
+                console.print(Panel(
+                    f"⏱️  [bold]Latency:[/bold] {data.get('total_task_latency_s', 0)}s  |  "
+                    f"🧠 [bold]LLM Calls:[/bold] {data.get('llm_call_count', 0)} ({data.get('llm_inference_time_ms', 0)}ms)\n"
+                    f"🛠️  [bold]Tools Time:[/bold] {data.get('total_tool_execution_ms', 0)}ms ({data.get('tool_call_count', 0)} calls)  |  "
+                    f"📦 [bold]Context Prep:[/bold] {data.get('context_prep_time_ms', 0)}ms  |  "
+                    f"⚡ [bold]Cache Hits:[/bold] {data.get('cache_hits', 0)}",
+                    title="📊 Task Performance Summary",
+                    border_style="cyan",
+                    padding=(0, 1)
+                ))
+            else:
+                print(
+                    f"\n📊 [Metrics] Task Latency: {data.get('total_task_latency_s')}s | "
+                    f"LLM Calls: {data.get('llm_call_count')} | "
+                    f"Tools Time: {data.get('total_tool_execution_ms')}ms | "
+                    f"Cache Hits: {data.get('cache_hits')}"
+                )
+
         elif event.type == "safety_ceiling" and verbose:
             if HAS_RICH:
                 console.print(

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/backends/local_backend.py

@@ -202,6 +202,9 @@ class LocalBackend:
         full_content = []
         full_reasoning = []
         tool_calls_dict = {}
+        # In non-thinking mode, swallow any accidental <think>...</think> generated by model
+        suppress_think = not enable_thinking
+        inside_suppressed_think = False
 
         for chunk in chunks:
             if not chunk or not chunk.get("choices"):
@@ -210,7 +213,7 @@ class LocalBackend:
             delta = choice.get("delta") or {}
 
             explicit_reasoning = delta.get("reasoning") or delta.get("reasoning_content")
-            if explicit_reasoning:
+            if explicit_reasoning and enable_thinking:
                 if not think_started:
                     think_started = True
                     yield ("thinking_start", {"time": start_time})
@@ -238,6 +241,23 @@ class LocalBackend:
 
             text = delta.get("content")
             if text:
+                if suppress_think:
+                    # Silently swallow any think tags/blocks emitted in fast mode
+                    if "<think>" in text:
+                        inside_suppressed_think = True
+                        text = text.replace("<think>", "")
+                    if inside_suppressed_think:
+                        if "</think>" in text:
+                            _, after = text.split("</think>", 1)
+                            inside_suppressed_think = False
+                            text = after
+                        else:
+                            text = ""
+                    else:
+                        text = text.replace("</think>", "")
+                    if not text:
+                        continue
+
                 if in_think:
                     if not think_started:
                         think_started = True
@@ -286,6 +306,10 @@ class LocalBackend:
                 tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
 
         final_content_str = "".join(full_content).strip()
+        if not enable_thinking and final_content_str:
+            import re
+            final_content_str = re.sub(r"^\s*<think>.*?</think>\s*", "", final_content_str, flags=re.DOTALL).strip()
+            final_content_str = re.sub(r"^\s*(?:</think>|<think>)*\s*", "", final_content_str).strip()
         final_reasoning_str = "".join(full_reasoning).strip()
 
         if not final_content_str and final_reasoning_str:

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/cache.py

@@ -193,3 +193,151 @@ def get_cache() -> ResponseCache:
     if _CACHE is None:
         _CACHE = ResponseCache()
     return _CACHE
+
+
+# ── File Read & Test Result Caching ─────────────────────────────────────
+
+class FileReadCache:
+    """In-memory cache for repeated file reads keyed by (path, mtime, size, start_line, end_line)."""
+
+    def __init__(self, max_entries: int = 1000):
+        self.max_entries = max_entries
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, file_path: Path, start_line: Optional[int] = None, end_line: Optional[int] = None) -> Optional[str]:
+        try:
+            st = file_path.stat()
+            key = f"{file_path.resolve()}:{st.st_mtime}:{st.st_size}:{start_line}:{end_line}"
+        except OSError:
+            return None
+
+        entry = self._cache.get(key)
+        if entry is not None:
+            self.hits += 1
+            return entry["content"]
+
+        self.misses += 1
+        return None
+
+    def put(self, file_path: Path, content: str, start_line: Optional[int] = None, end_line: Optional[int] = None) -> None:
+        try:
+            st = file_path.stat()
+            key = f"{file_path.resolve()}:{st.st_mtime}:{st.st_size}:{start_line}:{end_line}"
+        except OSError:
+            return
+
+        if len(self._cache) >= self.max_entries:
+            keys = list(self._cache.keys())[: max(1, self.max_entries // 5)]
+            for k in keys:
+                self._cache.pop(k, None)
+
+        self._cache[key] = {"content": content, "cached_at": time.time()}
+
+    def invalidate(self, file_path: Optional[Path] = None) -> None:
+        if file_path is None:
+            self._cache.clear()
+            return
+        prefix = f"{file_path.resolve()}:"
+        keys_to_del = [k for k in self._cache if k.startswith(prefix)]
+        for k in keys_to_del:
+            self._cache.pop(k, None)
+
+
+class TestResultCache:
+    """Caches test command execution results when workspace files are unchanged.
+    Persists across CLI runs in ~/.alpiecode/cache/test_cache.json
+    """
+    __test__ = False
+
+    def __init__(self, max_entries: int = 100):
+        self.max_entries = max_entries
+        self.disk_file = CACHE_DIR / "test_cache.json"
+        self._cache: Dict[str, Dict[str, Any]] = {}
+        self.hits = 0
+        self.misses = 0
+        self._load_disk()
+
+    def _load_disk(self):
+        if self.disk_file.exists():
+            try:
+                self._cache = json.loads(self.disk_file.read_text(encoding="utf-8"))
+            except Exception:
+                self._cache = {}
+
+    def _save_disk(self):
+        try:
+            CACHE_DIR.mkdir(parents=True, exist_ok=True)
+            self.disk_file.write_text(json.dumps(self._cache, indent=2), encoding="utf-8")
+        except Exception:
+            pass
+
+    def _is_test_cmd(self, cmd: str) -> bool:
+        c = cmd.strip().lower()
+        return (
+            "pytest" in c
+            or "unittest" in c
+            or "npm test" in c
+            or "cargo test" in c
+            or "go test" in c
+        )
+
+    def _get_workspace_fingerprint(self, workdir: Path) -> str:
+        try:
+            mtimes = []
+            for ext in ("*.py", "*.js", "*.ts", "*.json"):
+                for p in workdir.glob(ext):
+                    if p.is_file() and not p.name.startswith("."):
+                        mtimes.append(f"{p.name}:{p.stat().st_mtime_ns}")
+            return hashlib.md5("".join(sorted(mtimes)).encode()).hexdigest()[:12]
+        except Exception:
+            return "0"
+
+    def get(self, workdir: Path, cmd: str) -> Optional[str]:
+        if not self._is_test_cmd(cmd):
+            return None
+        version = self._get_workspace_fingerprint(workdir)
+        key = f"{workdir.resolve()}:{cmd.strip()}:{version}"
+        entry = self._cache.get(key)
+        if entry is not None:
+            self.hits += 1
+            return f"[Cached test result]\n{entry['content']}"
+        self.misses += 1
+        return None
+
+    def put(self, workdir: Path, cmd: str, result: str) -> None:
+        if not self._is_test_cmd(cmd):
+            return
+        version = self._get_workspace_fingerprint(workdir)
+        key = f"{workdir.resolve()}:{cmd.strip()}:{version}"
+        self._cache[key] = {"content": result, "cached_at": time.time()}
+        self._save_disk()
+
+    def invalidate(self, workdir: Optional[Path] = None) -> None:
+        if workdir is None:
+            self._cache.clear()
+        else:
+            prefix = f"{workdir.resolve()}:"
+            keys_to_del = [k for k in self._cache if k.startswith(prefix)]
+            for k in keys_to_del:
+                self._cache.pop(k, None)
+        self._save_disk()
+
+
+_FILE_CACHE: Optional[FileReadCache] = None
+_TEST_CACHE: Optional[TestResultCache] = None
+
+
+def get_file_cache() -> FileReadCache:
+    global _FILE_CACHE
+    if _FILE_CACHE is None:
+        _FILE_CACHE = FileReadCache()
+    return _FILE_CACHE
+
+
+def get_test_cache() -> TestResultCache:
+    global _TEST_CACHE
+    if _TEST_CACHE is None:
+        _TEST_CACHE = TestResultCache()
+    return _TEST_CACHE

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/cli.py

@@ -87,6 +87,7 @@ def main():
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
     common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
     common.add_argument("--offline", "--local", dest="offline", action="store_true", help="Run using local offline GGUF model on GPU without internet")
+    common.add_argument("--ctx-size", type=int, default=None, help="Context size in tokens (default: 4096 offline, 262144 online)")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -174,10 +175,14 @@ def main():
 
     if getattr(args, "offline", False):
         cfg.base_url = "offline"
-        cfg.n_ctx = 16384
+        # 4096 default fits 4.4GB model + KV cache 100% in 6GB VRAM with zero host-paging
         import os
+        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 4096))
         os.environ["ALPIECODE_BASE_URL"] = "offline"
 
+    if getattr(args, "ctx_size", None):
+        cfg.n_ctx = args.ctx_size
+
     if getattr(args, "thinking", False):
         cfg.enable_thinking = True
     elif getattr(args, "no_thinking", False):

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/context.py

@@ -1,3 +1,4 @@
+import re
 """
 Conversation context manager for AlpieCode.
 
@@ -198,10 +199,11 @@ class ContextManager:
     ) -> None:
         """Append a tool execution result and record metadata."""
         self.invalidate_cache()
+        filtered_content = filter_noisy_tool_output(content, tool_name=tool_name)
         msg = {
             "role": "tool",
             "tool_call_id": tool_call_id,
-            "content": content,
+            "content": filtered_content,
         }
         self._messages.append(dict(msg))
         self._raw_messages.append(copy.deepcopy(msg))
@@ -415,3 +417,33 @@ class ContextManager:
             self._cached_summary = extract_conversation_summary(self._messages, self._metadata)
             return True
         return False
+
+def filter_noisy_tool_output(content: str, tool_name: Optional[str] = None) -> str:
+    """
+    Filter noisy tool output to conserve LLM context window.
+    Extracts relevant errors/failures and condenses passing test spam.
+    """
+    if not content or len(content) < 300:
+        return content
+
+    # 1. Pytest / Unittest clean pass compression
+    if "passed in" in content and ("test session starts" in content or "collected" in content):
+        if "FAILED" not in content and "ERROR" not in content and "failed" not in content:
+            m = re.search(r"(=+\s*\d+\s+passed.*in\s+[\d\.]+s\s*=+)", content)
+            if m:
+                return f"[Clean Test Output]\n{m.group(1)}"
+        else:
+            # Tests had failures: strip passing test lines, keep failure traceback
+            lines = content.splitlines()
+            filtered = [
+                line for line in lines
+                if not (" PASSED" in line and ("[" in line and "%]" in line))
+            ]
+            return "\n".join(filtered)
+
+    if "Ran " in content and " tests in " in content and "OK" in content and "FAILED" not in content:
+        m = re.search(r"(Ran \d+ tests? in [\d\.]+s\s+OK)", content)
+        if m:
+            return f"[Clean Test Output]\n{m.group(1)}"
+
+    return content

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

@@ -237,20 +237,41 @@ def _ensure_llama_cpp():
 
     is_win = sys.platform == "win32"
     is_mac = sys.platform == "darwin"
+    # Check if NVIDIA GPU is present on Linux
+    has_nvidia = False
+    if not is_win and not is_mac:
+        for smi in ["nvidia-smi", "/usr/lib/wsl/lib/nvidia-smi"]:
+            try:
+                if subprocess.run([smi], capture_output=True, timeout=2).returncode == 0:
+                    has_nvidia = True
+                    break
+            except Exception:
+                pass
+
     if is_win:
         wheel_url = "https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.34-vulkan/llama_cpp_python-0.3.34-py3-none-win_amd64.whl"
+        install_targets = [wheel_url, "llama-cpp-python"]
     elif is_mac:
         wheel_url = "https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.34-metal/llama_cpp_python-0.3.34-py3-none-macosx_11_0_arm64.whl"
+        install_targets = [wheel_url, "llama-cpp-python"]
+    elif has_nvidia:
+        # Linux with NVIDIA: use pre-compiled CUDA 12.4 / 12.1 wheel index
+        wheel_url = "https://abetlen.github.io/llama-cpp-python/whl/cu124"
+        install_targets = [
+            ["--extra-index-url", wheel_url, "llama-cpp-python"],
+            ["--extra-index-url", "https://abetlen.github.io/llama-cpp-python/whl/cu121", "llama-cpp-python"],
+            "llama-cpp-python",
+        ]
     else:
         wheel_url = "https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.34-vulkan/llama_cpp_python-0.3.34-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl"
-
-    install_targets = [wheel_url, "llama-cpp-python"]
+        install_targets = [wheel_url, "llama-cpp-python"]
     installed = False
     last_error = ""
     for target in install_targets:
+        target_args = target if isinstance(target, list) else [target]
         for cmd_base in [
-            ["uv", "pip", "install", target],
-            [sys.executable, "-m", "pip", "install", target],
+            ["uv", "pip", "install"] + target_args,
+            [sys.executable, "-m", "pip", "install"] + target_args,
         ]:
             try:
                 res = subprocess.run(cmd_base, capture_output=True, text=True, timeout=180)
@@ -421,7 +442,18 @@ class LocalModel:
         enable_thinking = kwargs.get("enable_thinking", True)
         
         if not enable_thinking:
-            msgs = list(messages) + [{"role": "assistant", "content": "<think>\n\n</think>\n\n"}]
+            # Instruct model cleanly in prompt rather than injecting closed assistant turn
+            msgs = []
+            directive_tag = "[Directive: Respond directly with code or tool calls. Do not output <think> tags.]"
+            for i, m in enumerate(messages):
+                if i == len(messages) - 1 and m.get("role") == "user":
+                    content = m.get("content", "")
+                    if isinstance(content, str) and directive_tag not in content:
+                        msgs.append({**m, "content": f"{content}\n\n{directive_tag}"})
+                    else:
+                        msgs.append(m)
+                else:
+                    msgs.append(m)
         else:
             msgs = messages
 
@@ -469,13 +501,13 @@ class LocalModel:
             else:
                 raise
 
-        # Fix prefill response content so chat history remains valid across multi-turn sessions
+        # Clean any accidental think tags from non-thinking responses
         if not enable_thinking and result_dict.get("choices"):
             msg_dict = result_dict["choices"][0].get("message", {})
             raw_content = msg_dict.get("content") or ""
-            # Strip redundant opening/closing think tags output by model after prefill
-            cleaned = re.sub(r"^\s*(?:</think>|<think>)*\s*", "", raw_content)
-            msg_dict["content"] = f"<think>\n\n</think>\n\n{cleaned}"
+            cleaned = re.sub(r"^\s*<think>.*?</think>\s*", "", raw_content, flags=re.DOTALL)
+            cleaned = re.sub(r"^\s*(?:</think>|<think>)*\s*", "", cleaned)
+            msg_dict["content"] = cleaned
 
         return _DictWrapper(result_dict)
 

{alpiecode-10.0.1 → alpiecode-10.0.3}/src/codeagent/memory.py

@@ -105,7 +105,11 @@ def save_memory(workdir: Path, content: str, memory_type: str = "learning") -> N
     save_memories_batch(workdir, [{"content": content, "type": memory_type}])
 
 
-def format_memories_for_prompt(workdir: Path) -> Optional[str]:
+def format_memories_for_prompt(
+    workdir: Path,
+    max_entries: int = 5,
+    max_chars: int = 600,
+) -> Optional[str]:
     """
     Format memories into a string suitable for injection into the system prompt.
 
@@ -116,9 +120,24 @@ def format_memories_for_prompt(workdir: Path) -> Optional[str]:
     if not memories:
         return None
 
-    lines = ["## Recalled memories from previous sessions on this project:\n"]
-    for mem in memories[-10:]:  # Only inject last 10 to save context
-        lines.append(f"- [{mem.get('type', 'note')}] {mem['content']}")
+    lines = ["## Recalled memories from previous sessions on this project:"]
+    total_chars = 0
+    # Use most recent memories first, single-line summarized to keep prompt lean
+    for mem in reversed(memories):
+        c = mem.get("content", "").strip()
+        if not c:
+            continue
+        first_line = c.split("\n")[0][:120]
+        entry = f"- [{mem.get('type', 'note')}] {first_line}"
+        if total_chars + len(entry) > max_chars:
+            break
+        lines.append(entry)
+        total_chars += len(entry)
+        if len(lines) - 1 >= max_entries:
+            break
+
+    if len(lines) <= 1:
+        return None
 
     lines.append(
         "\nNote: These memories are from previous sessions. "