alpiecode 9.0.3__tar.gz → 9.0.6__tar.gz

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

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

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

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

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

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

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/alpiecode.egg-info/SOURCES.txt

@@ -40,6 +40,10 @@ src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
 src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
+test/test_audit_fixes.py
+test/test_chat_mode.py
+test/test_claude_codex_capabilities.py
+test/test_offline_mode.py
 test/test_phase1.py
 test/test_phase2.py
 test/test_phase3.py

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

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

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/codeagent/agent.py

@@ -213,11 +213,15 @@ def run_agent(
     # CLI-as-Client check: auto-detect if local/remote server is running
     from .client import AlpieCodeClient
     target_server = server_url or getattr(cfg, "server_url", None)
-    if not target_server:
-        # Check default local server
-        local_client = AlpieCodeClient("http://127.0.0.1:7169")
-        if local_client.health().get("status") == "online":
-            target_server = "http://127.0.0.1:7169"
+    if not target_server and cfg.base_url != "offline" and not getattr(cfg, "offline", False):
+        # Check default local server (online mode only)
+        try:
+            local_client = AlpieCodeClient("http://127.0.0.1:7169")
+            h = local_client.health()
+            if h.get("status") == "online" and h.get("mode") != "offline":
+                target_server = "http://127.0.0.1:7169"
+        except Exception:
+            pass
 
     if target_server:
         client = AlpieCodeClient(target_server)
@@ -234,7 +238,7 @@ def run_agent(
         backend = resolve_backend(cfg)
         orchestrator = AgentOrchestrator(backend)
         session_mgr = SessionManager()
-        session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+        session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
         event_stream = orchestrator.run_task(
             session=session,
             task=task,
@@ -467,7 +471,7 @@ def run_agent(
     return session.context.messages if "session" in locals() else []
 
 
-def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
+def run_chat(workdir: Path, cfg: Config, verbose: bool = True, debug: bool = False) -> None:
     """Run interactive chat session with Rich presentation."""
     workdir = workdir.resolve()
     _ensure_git(workdir)
@@ -475,7 +479,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
     backend = resolve_backend(cfg)
     orchestrator = AgentOrchestrator(backend)
     session_mgr = SessionManager()
-    session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+    session = session_mgr.create_session(workdir, max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144))
 
     is_offline = isinstance(backend, LocalBackend) or not backend.is_available
     active_tools = PromptBuilder().get_tools(is_offline=is_offline)
@@ -513,7 +517,50 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
             console.print("Goodbye! 👋")
             break
 
+        # In-chat slash commands
+        if user_input.lower() in ("/clear", "/reset"):
+            session = session_mgr.create_session(
+                workdir,
+                max_tokens=backend.context_window if hasattr(backend, 'context_window') and backend.context_window else (cfg.n_ctx if cfg.base_url == 'offline' else 262_144)
+            )
+            if HAS_RICH:
+                console.print("[bold green]✨ Conversation context reset.[/bold green]")
+            else:
+                print("✨ Conversation context reset.")
+            continue
+
+        if user_input.lower() in ("/info", "/status"):
+            mode_str = "OFFLINE (Local GGUF)" if is_offline else "ONLINE (Cloud API)"
+            ctx_tokens = backend.context_window if hasattr(backend, 'context_window') and backend.context_window else cfg.n_ctx
+            user_turns = len([m for m in session.context.messages if m.get("role") == "user"])
+            info_msg = (
+                f"[bold]AlpieCode Session Info[/bold]\n"
+                f" • Mode: {mode_str}\n"
+                f" • Working Dir: {workdir}\n"
+                f" • Context Window: {ctx_tokens} tokens\n"
+                f" • Session Turns: {user_turns}"
+            )
+            if HAS_RICH:
+                console.print(Panel(info_msg, border_style="cyan", title="ℹ️ Status"))
+            else:
+                print(info_msg)
+            continue
+
+        if user_input.lower() in ("/help", "/?"):
+            help_msg = (
+                "Available commands:\n"
+                " • /clear, /reset  - Reset conversation memory\n"
+                " • /info, /status  - View current model and session diagnostics\n"
+                " • exit, quit, q   - Exit interactive chat"
+            )
+            if HAS_RICH:
+                console.print(Panel(help_msg, border_style="dim", title="Help"))
+            else:
+                print(help_msg)
+            continue
+
         has_streamed_chat = False
+        has_printed_chat = False
         for event in orchestrator.run_task(session, user_input, cfg):
             if event.type == "token":
                 delta = event.data.get("delta", "")
@@ -521,6 +568,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                     sys.stdout.write(delta)
                     sys.stdout.flush()
                     has_streamed_chat = True
+                    has_printed_chat = True
 
             elif event.type == "turn_start" and debug:
                 if HAS_RICH:
@@ -532,7 +580,12 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 _print_reasoning(event.data["content"])
 
             elif event.type == "tool_call" and verbose:
+                if has_streamed_chat:
+                    sys.stdout.write("\n")
+                    sys.stdout.flush()
+                    has_streamed_chat = False
                 _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+                has_printed_chat = True
 
             elif event.type == "tool_result":
                 if verbose:
@@ -543,8 +596,9 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                else:
+                elif not has_printed_chat:
                     _print_assistant_message(event.data["content"])
+                has_printed_chat = True
                 _checkpoint(workdir, "checkpoint: done")
 
             elif event.type == "error":
@@ -557,6 +611,7 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 if has_streamed_chat:
                     sys.stdout.write("\n")
                     has_streamed_chat = False
-                elif event.data.get("summary"):
+                elif not has_printed_chat and event.data.get("summary"):
                     _print_assistant_message(event.data["summary"])
+                    has_printed_chat = True
                 break

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/codeagent/backends/local_backend.py

@@ -55,8 +55,25 @@ class LocalBackend:
         sanitized = []
         for msg in messages:
             role = msg.get("role", "")
-            # Skip tool result messages entirely — GGUF models don't understand them
             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 truncate oversized terminal logs to conserve context
+                if len(raw_content) > 1500:
+                    lines = raw_content.splitlines()
+                    if len(lines) > 12:
+                        raw_content = f"[Output: {len(lines)} lines]\n" + "\n".join(lines[:6]) + "\n...\n" + "\n".join(lines[-4:])
+                    else:
+                        raw_content = raw_content[:1500] + "\n... [truncated]"
+
+                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}

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/codeagent/cli.py

@@ -41,6 +41,10 @@ def _normalize_args():
     if not subcommand and len(sys.argv) > 1:
         subcommand = "run"
         sys.argv.insert(1, "run")
+    elif subcommand and subcommand not in ("-h", "--help", "-v", "--version") and sys.argv[1] != subcommand:
+        # Move subcommand to index 1 so subparsers parse arguments correctly without default override
+        sys.argv.remove(subcommand)
+        sys.argv.insert(1, subcommand)
 
     if subcommand in ("run", "plan", "explain") and len(sys.argv) > 2:
         cmd_idx = sys.argv.index(subcommand)
@@ -82,6 +86,7 @@ def main():
     common.add_argument("--no-update", action="store_true", help="Skip automatic update check")
     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")
 
     from . import __version__
     parser = argparse.ArgumentParser(
@@ -145,13 +150,16 @@ def main():
 
     if args.command == "serve":
         _show_banner()
+        if getattr(args, "offline", False):
+            import os
+            os.environ["ALPIECODE_BASE_URL"] = "offline"
         try:
             from .vscode_installer import ensure_vscode_extension
             ensure_vscode_extension()
         except Exception as e:
             pass
         from .server import run_server
-        run_server(host=args.host, port=args.port)
+        run_server(host=args.host, port=args.port, offline=getattr(args, "offline", False))
         return
 
     # Check for auto-updates from GitHub in background
@@ -164,6 +172,12 @@ def main():
 
     cfg = load_config()
 
+    if getattr(args, "offline", False):
+        cfg.base_url = "offline"
+        cfg.n_ctx = 16384
+        import os
+        os.environ["ALPIECODE_BASE_URL"] = "offline"
+
     if getattr(args, "thinking", False):
         cfg.enable_thinking = True
     elif getattr(args, "no_thinking", False):
@@ -188,7 +202,7 @@ def main():
             cfg.max_turns = args.max_turns
         _show_banner()
         from .agent import run_chat
-        run_chat(Path(args.workdir), cfg, verbose=not args.quiet)
+        run_chat(Path(args.workdir), cfg, verbose=not args.quiet, debug=getattr(args, 'debug', False))
 
     elif args.command == "plan":
         plan_task = (

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/codeagent/client.py

@@ -11,7 +11,7 @@ import urllib.parse
 import urllib.request
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Iterator, Optional
+from typing import Any, Dict, Iterator, List, Optional
 
 from .orchestrator import AgentEvent
 

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

@@ -133,6 +133,16 @@ def load_config() -> Config:
             data["api_key"] = os.environ[f"{prefix}API_KEY"]
     if os.environ.get("HF_TOKEN"):
         data["hf_token"] = os.environ["HF_TOKEN"]
+    
+    # Context size overrides from environment
+    for ctx_var in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE", "ALPIECODE_CONTEXT_SIZE", "CODEAGENT_N_CTX"):
+        if os.environ.get(ctx_var):
+            try:
+                data["n_ctx"] = int(os.environ[ctx_var])
+                break
+            except ValueError:
+                pass
+
     if os.environ.get("ALPIECODE_CPU") == "1":
         data["n_gpu_layers"] = 0
     elif os.environ.get("ALPIECODE_GPU_LAYERS"):
@@ -141,6 +151,14 @@ def load_config() -> Config:
         except ValueError:
             pass
 
+    # For offline mode, set high-performance 16k context (16384 tokens) for big multi-file projects
+    # Fits completely in 6GB VRAM on RTX 3050 with zero paging
+    if data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
+        if data.get("n_ctx") in (32768, 4096):
+            data["n_ctx"] = 16384
+        if data.get("max_tokens", 8192) > 4096:
+            data["max_tokens"] = 4096
+
     # Filter data to only keys present in Config fields
     valid_keys = {f.name for f in fields(Config)}
     filtered_data = {k: v for k, v in data.items() if k in valid_keys}

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

@@ -19,7 +19,7 @@ import subprocess
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 
 # -- Task Context ----------------------------------------------------------
@@ -47,6 +47,7 @@ class TaskContext:
     has_tests: bool = False
     entry_points: List[str] = field(default_factory=list)
     dependencies: List[str] = field(default_factory=list)
+    symbol_index: Dict[str, List[str]] = field(default_factory=dict)
 
     # Budget (computed from complexity)
     max_tokens: int = 8192
@@ -558,6 +559,7 @@ def gather_relevant_context(
     if getattr(task_context, "intent", "") in ("qa",):
         return None
 
+    task_lower = task.lower().strip()
     sections: List[str] = []
     chars_used = 0
 
@@ -599,6 +601,22 @@ def gather_relevant_context(
         for ep in task_context.entry_points[:3]:
             _add_file(ep, f"{ep} (entry point)")
 
+    
+    # -- Priority 2.5: Matching Codebase Symbols (quick navigation) --
+    if getattr(task_context, "symbol_index", None):
+        matched_syms = []
+        task_terms = [t for t in task_lower.split() if len(t) > 3]
+        for fpath, syms in task_context.symbol_index.items():
+            rel_lower = fpath.lower()
+            syms_str = " ".join(syms).lower()
+            if any(term in rel_lower or term in syms_str for term in task_terms) or len(matched_syms) < 3:
+                matched_syms.append(f"- `{fpath}`: {', '.join(syms[:4])}")
+                if len(matched_syms) >= 6:
+                    break
+        if matched_syms:
+            sym_section = "### Codebase Symbol Map (Quick Navigation)\n" + "\n".join(matched_syms)
+            sections.append(sym_section)
+
     # -- Priority 3: Files mentioned in the task (fuzzy match) --
     task_lower = task.lower()
     try:
@@ -629,6 +647,48 @@ def gather_relevant_context(
 
 # -- Main Entry Point -------------------------------------------------------
 
+
+def build_symbol_index(workdir: Path, max_files: int = 40) -> Dict[str, List[str]]:
+    """Fast AST-based code symbol indexer (<50ms).
+
+    Extracts classes, methods, and functions across Python files.
+    """
+    symbols: Dict[str, List[str]] = {}
+    count = 0
+    import ast
+
+    skip_dirs = {".git", "__pycache__", "node_modules", ".venv", "venv", "dist", "build", ".egg-info"}
+
+    try:
+        for path in workdir.rglob("*.py"):
+            if any(part in skip_dirs or part.endswith(".egg-info") for part in path.parts):
+                continue
+            try:
+                rel_str = str(path.relative_to(workdir))
+                tree = ast.parse(path.read_text(encoding="utf-8", errors="replace"))
+                file_syms = []
+                for node in tree.body:
+                    if isinstance(node, ast.FunctionDef):
+                        args = [a.arg for a in node.args.args if a.arg != "self"]
+                        sig = f"def {node.name}({', '.join(args[:3])})"
+                        file_syms.append(sig)
+                    elif isinstance(node, ast.ClassDef):
+                        methods = [n.name for n in node.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("__")]
+                        method_str = f" [{', '.join(methods[:3])}]" if methods else ""
+                        file_syms.append(f"class {node.name}{method_str}")
+                if file_syms:
+                    symbols[rel_str] = file_syms[:8]
+                    count += 1
+                    if count >= max_files:
+                        break
+            except Exception:
+                continue
+    except Exception:
+        pass
+
+    return symbols
+
+
 def build_task_context(task: str, workdir: Path) -> TaskContext:
     """Build complete TaskContext by running all discovery phases.
 
@@ -650,7 +710,15 @@ def build_task_context(task: str, workdir: Path) -> TaskContext:
     # Phase 5: Budget from complexity
     budget = COMPLEXITY_CONFIG[complexity]
 
+    symbol_index = {}
+    if repo.get("file_count", 0) > 0 and repo.get("project_type") != "empty":
+        try:
+            symbol_index = build_symbol_index(workdir)
+        except Exception:
+            pass
+
     return TaskContext(
+        symbol_index=symbol_index,
         # Intent
         intent=intent,
         complexity=complexity,

{alpiecode-9.0.3 → alpiecode-9.0.6}/src/codeagent/executor.py

@@ -39,11 +39,15 @@ def parse_text_tool_calls(text: str) -> List[dict]:
 
     tool_calls = []
 
-    # 1. Try parsing JSON blocks inside <tool_call> or ```json
-    json_matches = re.findall(r"(?:<tool_call>|```json)\s*(\{.*?\})\s*(?:</tool_call>|```|$)", text, re.DOTALL)
-    for jm in json_matches:
+    # 1. Try parsing blocks inside <tool_call> or ```json using robust JSON repair
+    from .backends.openai_backend import _repair_and_parse_json_arguments
+    blocks = re.findall(r"(?:<tool_call>|```json)\s*(.*?)\s*(?:</tool_call>|```|$)", text, re.DOTALL)
+    for block in blocks:
+        raw = block.strip()
+        if not raw:
+            continue
         try:
-            data = json.loads(jm.strip())
+            data = _repair_and_parse_json_arguments(raw)
             if isinstance(data, dict) and "name" in data:
                 tool_calls.append({
                     "name": data["name"],
@@ -146,6 +150,42 @@ def _parse_error_hint(stderr: str, stdout: str) -> str:
     return "\n".join(hints)
 
 
+
+def suggest_similar_file(workdir: Path, target_path: str) -> Optional[str]:
+    """Find the closest existing file path in the workspace for typos/misspellings."""
+    import difflib
+    target_name = Path(target_path).name.lower()
+    candidates = []
+    skip_dirs = {".git", "__pycache__", "node_modules", ".venv", "venv"}
+    try:
+        for p in workdir.rglob("*"):
+            if p.is_file() and not any(part in skip_dirs for part in p.parts):
+                candidates.append(str(p.relative_to(workdir)))
+    except Exception:
+        return None
+
+    if not candidates:
+        return None
+
+    # 1. Exact filename match in another directory
+    for c in candidates:
+        if Path(c).name.lower() == target_name:
+            return c
+
+    # 2. Fuzzy match on relative path
+    matches = difflib.get_close_matches(target_path, candidates, n=1, cutoff=0.55)
+    if matches:
+        return matches[0]
+
+    # 3. Fuzzy match on filename
+    file_matches = difflib.get_close_matches(target_name, [Path(c).name.lower() for c in candidates], n=1, cutoff=0.55)
+    if file_matches:
+        for c in candidates:
+            if Path(c).name.lower() == file_matches[0]:
+                return c
+    return None
+
+
 class ToolExecutor:
     """Executes tool calls for a workspace."""
 
@@ -154,13 +194,14 @@ class ToolExecutor:
         self.dispatch = make_dispatch(workdir)
         self.tool_call_history: List[Tuple[str, str]] = []
         self.compile_fail_counts: Dict[str, int] = {}
+        self.successful_bash_commands: set = set()
 
     def extract_tool_calls(self, response: ChatResponse) -> List[ToolCall]:
         """Extract tool calls from response (structured or text format)."""
         if response.tool_calls:
             return response.tool_calls
 
-        if response.content and "<tool_call>" in response.content:
+        if response.content:
             parsed = parse_text_tool_calls(response.content)
             return [
                 ToolCall(
@@ -215,6 +256,12 @@ class ToolExecutor:
                         res_str = f"error: {e}"
                     if on_tool_end:
                         on_tool_end(tc.name, res_str)
+                    if "file not found" in res_str.lower() and isinstance(tc.arguments, dict):
+                        req_path = tc.arguments.get("path") or tc.arguments.get("file", "")
+                        if req_path:
+                            sugg = suggest_similar_file(self.workdir, req_path)
+                            if sugg and sugg != req_path:
+                                res_str += f"\n💡 HINT: Did you mean '{sugg}'? Use that path instead."
                     results_map[tc.id] = ToolResult(
                         tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
                     )
@@ -270,6 +317,12 @@ class ToolExecutor:
                         res_str = f"error: {e}"
                     if on_tool_end:
                         on_tool_end(tc.name, res_str)
+                    if "file not found" in res_str.lower() and isinstance(tc.arguments, dict):
+                        req_path = tc.arguments.get("path") or tc.arguments.get("file", "")
+                        if req_path:
+                            sugg = suggest_similar_file(self.workdir, req_path)
+                            if sugg and sugg != req_path:
+                                res_str += f"\n💡 HINT: Did you mean '{sugg}'? Use that path instead."
                     results_map[tc.id] = ToolResult(
                         tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
                     )
@@ -290,6 +343,10 @@ class ToolExecutor:
                     res_str = f"error: Unknown tool '{tc.name}'"
                 elapsed = (time.monotonic() - t0) * 1000
 
+                # Clear passed verification set whenever code files are written or edited
+                if tc.name in ("write_file", "edit_file", "apply_patch"):
+                    self.successful_bash_commands.clear()
+
                 # Tool loop detection guard
                 call_sig = (tc.name, json.dumps(tc.arguments, sort_keys=True))
                 self.tool_call_history.append(call_sig)
@@ -302,6 +359,19 @@ class ToolExecutor:
                         "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
                     )
 
+                # Repetitive verification sequence guard
+                if tc.name == "bash":
+                    cmd_str = safe_args.get("command", "").strip()
+                    if cmd_str and cmd_str in self.successful_bash_commands:
+                        res_str += (
+                            "\n\n⚠️ REPETITIVE VERIFICATION NOTICE: This exact command has already run and passed with exit code 0, "
+                            "and no files have been modified since. Re-running identical tests is unnecessary. "
+                            "All checks have already passed! Finalize the task now with: DONE: <summary>."
+                        )
+                    elif '"exit_code": 0' in res_str:
+                        if cmd_str:
+                            self.successful_bash_commands.add(cmd_str)
+
                 # Smart error hint injection for failed bash commands
                 if tc.name == "bash" and '"exit_code"' in res_str:
                     try:

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

@@ -68,7 +68,8 @@ def detect_gpu() -> int:
             if res.returncode == 0 and res.stdout.strip():
                 vram_mb = int(res.stdout.strip().split("\n")[0].strip())
                 if vram_mb <= 6500:  # 6GB VRAM (e.g. RTX 3050 Laptop)
-                    return 26  # Partial offload — keep 2GB VRAM free
+                    # Full offload: 4.4GB model + 4096 context fits in 6GB VRAM and runs 5x faster than partial offload
+                    return 33
                 return -1  # 8GB+ VRAM — offload all layers
         except Exception:
             pass
@@ -303,7 +304,19 @@ class LocalModel:
         model_path = self.ensure_model()
         Llama = _ensure_llama_cpp()
 
-        accel = "GPU" if self.n_gpu_layers != 0 else "CPU"
+        has_gpu_offload = False
+        try:
+            import llama_cpp
+            has_gpu_offload = getattr(llama_cpp, "llama_supports_gpu_offload", lambda: False)()
+        except Exception:
+            pass
+
+        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.")
+            accel = "CPU (No CUDA in Python env)"
+            self.n_gpu_layers = 0
+        else:
+            accel = "GPU" if self.n_gpu_layers != 0 else "CPU" 
 
         # ── Smart P-Core Topology Auto-Tuning ─────────────────────────
         # On hybrid CPUs (Intel 12th+), over-subscribing E-cores causes
@@ -401,6 +414,17 @@ class LocalModel:
         else:
             msgs = messages
 
+        # Context headroom safety guard: dynamically clamp max_tokens if prompt is large
+        n_ctx_limit = getattr(self, "n_ctx", 16384)
+        try:
+            total_chars = sum(len(str(m.get("content", ""))) for m in msgs)
+            est_prompt_tokens = int(total_chars / 3.0) + (len(tools or []) * 80) + 100
+            if est_prompt_tokens + max_tokens > n_ctx_limit:
+                available_tokens = max(128, n_ctx_limit - est_prompt_tokens - 32)
+                max_tokens = min(max_tokens, available_tokens)
+        except Exception:
+            pass
+
         params = {
             "messages": msgs,
             "temperature": 0.1 if not enable_thinking else temperature,
@@ -410,7 +434,24 @@ class LocalModel:
             params["tools"] = tools
             params["tool_choice"] = kwargs.get("tool_choice", "auto")
 
-        result_dict = llm.create_chat_completion(**params)
+        try:
+            result_dict = llm.create_chat_completion(**params)
+        except ValueError as ve:
+            err_msg = str(ve)
+            if "exceed context window" in err_msg.lower():
+                # Parse: "Requested tokens (X) exceed context window of Y"
+                m = re.search(r"Requested tokens \((\d+)\) exceed context window of (\d+)", err_msg)
+                if m:
+                    requested = int(m.group(1))
+                    win = int(m.group(2))
+                    excess = requested - win
+                    new_max = max(128, params["max_tokens"] - excess - 32)
+                    params["max_tokens"] = new_max
+                    result_dict = llm.create_chat_completion(**params)
+                else:
+                    raise
+            else:
+                raise
 
         # Fix prefill response content so chat history remains valid across multi-turn sessions
         if not enable_thinking and result_dict.get("choices"):