alpiecode 9.0.2__tar.gz → 9.0.4__tar.gz

{alpiecode-9.0.2 → alpiecode-9.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.2
+Version: 9.0.4
 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.2 → alpiecode-9.0.4}/pyproject.toml

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

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 9.0.2
+Version: 9.0.4
 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.2 → alpiecode-9.0.4}/src/alpiecode.egg-info/SOURCES.txt

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

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/__init__.py

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

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/backends/openai_backend.py

@@ -196,6 +196,7 @@ class OpenAIBackend:
             "max_tokens": m_tokens,
             "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
             "stream": True,
+            "timeout": 45.0,
         }
         if tools:
             params["tools"] = tools

{alpiecode-9.0.2 → alpiecode-9.0.4}/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,12 @@ def load_config() -> Config:
         except ValueError:
             pass
 
+    # For offline mode, optimize default context size to 4096 to prevent VRAM/RAM bottleneck
+    # unless explicitly configured by the user
+    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") == 32768:
+            data["n_ctx"] = 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.2 → alpiecode-9.0.4}/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
@@ -442,11 +443,26 @@ def compute_complexity(intent: str, repo_info: dict, task: str) -> str:
     if intent == "qa":
         return "qa"
 
-    task_lower = task.lower()
+    task_lower = task.lower().strip()
     file_count = repo_info.get("file_count", 0)
     frameworks = repo_info.get("frameworks", [])
     project_type = repo_info.get("project_type", "empty")
 
+    # Standalone algorithms / simple scripts: keep 'low' complexity so they
+    # complete in 1-2 turns without creating multi-file architectures or plans.
+    standalone_keywords = [
+        "palindrome", "fibonacci", "quicksort", "bubblesort",
+        "binary search", "factorial", "hello world", "calculator",
+        "is_palindrome", "check palindrome", "reverse string",
+        "prime number", "anagram", "todo script", "simple script",
+    ]
+    project_terms = [
+        "this project", "this repo", "our repo", "our project", "existing",
+        "endpoint", "route", "database", "migration", "service", "component",
+    ]
+    if any(kw in task_lower for kw in standalone_keywords) and not any(pt in task_lower for pt in project_terms):
+        return "low"
+
     # -- HIGH: explicitly complex multi-component tasks --
     high_keywords = [
         "full stack", "fullstack", "full-stack",
@@ -584,6 +600,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:
@@ -614,6 +646,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.
 
@@ -635,7 +709,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.2 → alpiecode-9.0.4}/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."""
 
@@ -160,7 +200,7 @@ class ToolExecutor:
         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 +255,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 +316,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
                     )

{alpiecode-9.0.2 → alpiecode-9.0.4}/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

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/orchestrator.py

@@ -413,27 +413,74 @@ class AgentOrchestrator:
                     "commands": session_executed_commands,
                 })
 
-                # ── Soft Verification Gate ──
-                # If files were written/modified but no verification was run, nudge the agent
+# ── Component 1: Autonomous Verify-Before-Done Gate ──
                 has_code_files = any(
                     f.endswith((".py", ".js", ".ts", ".jsx", ".tsx", ".rs", ".go", ".java", ".c", ".cpp"))
                     for f in session_touched_files
                 )
-                has_successful_verify = any(
-                    c.get("exit_code", -1) == 0 for c in session_executed_commands
-                )
-                if has_code_files and not has_successful_verify and not verification_nudged:
-                    verification_nudged = True
-                    session.context.add_user_message(
-                        "[SYSTEM - VERIFICATION] You created/modified code files but did not run "
-                        "any verification command. Please run a quick syntax check or test before finishing. "
-                        "Then output DONE: <summary>."
-                    )
-                    yield AgentEvent("verification_nudge", {
-                        "files": sorted(list(session_touched_files)),
-                        "message": "Nudging agent to verify before completing",
-                    })
-                    continue
+                auto_verify_passed = getattr(session, "_auto_verify_passed", False)
+                verify_attempts = getattr(session, "_auto_verify_attempts", 0)
+
+                if has_code_files and not auto_verify_passed and verify_attempts < 2:
+                    # 1. In-process Python syntax verification for all modified Python files
+                    syntax_errs = []
+                    for tf in session_touched_files:
+                        if tf.endswith(".py"):
+                            full_tf = session.workdir / tf
+                            if full_tf.exists():
+                                try:
+                                    import ast as _ast
+                                    _ast.parse(full_tf.read_text(encoding="utf-8", errors="replace"))
+                                except SyntaxError as se:
+                                    syntax_errs.append(f"- '{tf}' line {se.lineno}: {se.msg}")
+
+                    if syntax_errs:
+                        session._auto_verify_attempts = verify_attempts + 1
+                        err_msg = "\n".join(syntax_errs)
+                        session.context.add_user_message(
+                            f"[AUTO-VERIFICATION FAILED] Syntax error(s) detected in your code:\n{err_msg}\n"
+                            "Please use edit_file to fix these syntax errors before completing the task."
+                        )
+                        yield AgentEvent("verification_failed", {
+                            "type": "syntax",
+                            "errors": syntax_errs,
+                        })
+                        continue
+
+                    # 2. Automated test verification if project has tests
+                    if task_context.has_tests and not getattr(session, "_has_run_tests_in_session", False):
+                        session._auto_verify_attempts = verify_attempts + 1
+                        session._has_run_tests_in_session = True
+                        test_cmd = "python3 -m pytest -q --tb=short" if task_context.project_type == "python" else "npm test" if task_context.project_type == "node" else None
+                        if test_cmd:
+                            yield AgentEvent("status", {
+                                "phase": "verifying",
+                                "message": f"Auto-running verification test suite ({test_cmd})...",
+                            })
+                            t_res = session.executor.dispatch.get("bash", lambda a: "")({"command": test_cmd})
+                            t_exit = 0
+                            try:
+                                import json as _json
+                                t_data = _json.loads(t_res)
+                                t_exit = t_data.get("exit_code", 0)
+                                t_out = t_data.get("stdout", "")
+                            except Exception:
+                                t_out = str(t_res)
+
+                            if t_exit != 0:
+                                session.context.add_user_message(
+                                    f"[AUTO-VERIFICATION FAILED] Test suite failed (exit_code={t_exit}) after your changes:\n"
+                                    f"{t_out[:1200]}\n"
+                                    "Please analyze the failure, fix the issue, and verify it passes before finishing."
+                                )
+                                yield AgentEvent("verification_failed", {
+                                    "type": "tests",
+                                    "command": test_cmd,
+                                    "exit_code": t_exit,
+                                })
+                                continue
+
+                    session._auto_verify_passed = True
 
                 # Cache if single-turn
                 if is_cacheable and turn == 0:

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/progress.py

@@ -24,6 +24,50 @@ class TurnSnapshot:
     had_progress: bool = False
 
 
+
+@dataclass
+class Milestone:
+    text: str
+    done: bool = False
+
+
+class MilestoneTracker:
+    """Tracks progress against markdown task lists (- [ ] or numbered steps)."""
+
+    def __init__(self, task_text: str = ""):
+        self.milestones: List[Milestone] = []
+        if task_text:
+            self.init_from_text(task_text)
+
+    def init_from_text(self, text: str) -> None:
+        import re
+        lines = text.splitlines()
+        for line in lines:
+            match = re.search(r"^\s*(?:-\s*\[([ xX])\]|\d+\.)\s+(.+)$", line)
+            if match:
+                is_done = match.group(1) in ("x", "X") if match.group(1) else False
+                item_text = match.group(2).strip()
+                if len(item_text) > 3:
+                    self.milestones.append(Milestone(text=item_text, done=is_done))
+
+    def mark_milestone(self, text_fragment: str, done: bool = True) -> None:
+        for m in self.milestones:
+            if text_fragment.lower() in m.text.lower():
+                m.done = done
+
+    def get_pending(self) -> List[str]:
+        return [m.text for m in self.milestones if not m.done]
+
+    def format_checklist(self) -> str:
+        if not self.milestones:
+            return ""
+        lines = ["### Active Task Checklist:"]
+        for m in self.milestones:
+            box = "[x]" if m.done else "[ ]"
+            lines.append(f"- {box} {m.text}")
+        return "\n".join(lines)
+
+
 class ProgressMonitor:
     """Tracks agent progress across turns.
 
@@ -39,6 +83,7 @@ class ProgressMonitor:
         self.all_files_created: Set[str] = set()
         self.consecutive_stalls: int = 0
         self.stall_interventions: int = 0
+        self.milestones = MilestoneTracker()
 
     def record_turn(self, turn: int, tool_calls: list, tool_results: list) -> TurnSnapshot:
         """Record what happened in a turn and determine if progress was made."""

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/prompt.py

@@ -267,9 +267,15 @@ Write the complete code on Turn 1. Verify by running it. Fix if needed.
 Rules:
 1. Write clean code using ONLY Python standard library modules.
 2. NEVER run pip, uv pip, or any package install commands — they will fail offline.
-3. For testing, use `python -m unittest` (stdlib). NEVER use pytest.
-4. Create files with write_file, edit with edit_file, run with bash.
-5. After writing code, always run to verify.
+3. For testing, use `python3 -m unittest` (stdlib).
+4. To execute a tool, output a <tool_call> block:
+<tool_call>
+{"name": "write_file", "arguments": {"path": "<file>", "content": "<full_code>"}}
+</tool_call>
+<tool_call>
+{"name": "bash", "arguments": {"command": "<command>"}}
+</tool_call>
+5. Always create the files and run them to verify.
 6. When done and verified, output: DONE: <summary>.
 """
 

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/rephraser.py

@@ -18,7 +18,10 @@ Your job is to transform the user's raw prompt into a clear, solid, and unambigu
 Guidelines:
 1. If the prompt is a simple Q&A, greeting, or direct conceptual question (e.g. "what is X?", "explain Y", "hi", "how does Z work"):
    - Keep it clean, direct, and concise. Do NOT add unnecessary software development boilerplate.
-2. If the prompt is a coding, debugging, refactoring, testing, or feature creation task:
+2. If the prompt is a standalone algorithm, utility, or single-file script (e.g. "check palindrome", "fibonacci", "calculator", "sort"):
+   - Keep the specification strictly focused on a SINGLE runnable executable script (e.g. `palindrome.py`).
+   - Do NOT turn it into a multi-file architecture, microservice, or web framework (do NOT add FastAPI, Flask, Pydantic, Docker, or separate schemas/models/utils unless the user explicitly requested a web service).
+3. If the prompt is a coding, debugging, refactoring, testing, or feature creation task:
    - Expand it into a solid, structured engineering prompt with:
      * Objective: Explicit statement of what needs to be created, modified, or fixed
      * Scope & Architecture: Target files, patterns, and module structure
@@ -103,10 +106,16 @@ class PromptRephraser:
         if backend is None or not getattr(backend, "is_available", True):
             return task
 
+        # In offline/local GGUF mode, skip redundant rephraser LLM pass to ensure instant turn-0 start
+        if type(backend).__name__ == "LocalBackend" or getattr(backend, "is_offline", False):
+            return task
+
         try:
             # Inject project context if available so rephrased spec is project-aware
             project_hint = ""
-            if task_context:
+            standalone_kws = ["palindrome", "fibonacci", "quicksort", "bubblesort", "factorial", "hello world", "calculator", "reverse string"]
+            is_standalone = any(kw in task.lower() for kw in standalone_kws)
+            if task_context and not is_standalone:
                 _fw = ", ".join(getattr(task_context, "frameworks", []) or []) or "none"
                 _pt = getattr(task_context, "project_type", "unknown")
                 _fc = getattr(task_context, "file_count", 0)

{alpiecode-9.0.2 → alpiecode-9.0.4}/src/codeagent/tools.py

@@ -348,16 +348,33 @@ def _build_venv_env(workdir: Path) -> dict:
 
 
 def _smart_truncate(text: str, max_chars: int = 6000) -> str:
-    """Truncate long output keeping both head and tail (where errors usually are).
-
-    Compiler errors appear at the top (file:line: error: ...) while the
-    bottom often has summary counts. Keeping both ends gives the model
-    far better error visibility than tail-only truncation.
-    """
+    """Truncate long output keeping head/tail, and distilling test failures / compiler traces."""
     if len(text) <= max_chars:
         return text
-    head_size = int(max_chars * 0.6)  # 60% head — where real errors live
-    tail_size = max_chars - head_size  # 40% tail — summaries and counts
+
+    # High-signal error/failure extraction for pytest, jest, compiler outputs
+    failure_markers = ["FAILED", "FAILURES", "ERROR:", "FAIL:", "AssertionError:", "Traceback (most recent call last):"]
+    if any(m in text for m in failure_markers):
+        lines_list = text.splitlines()
+        error_lines = []
+        in_error = False
+        for line in lines_list:
+            if any(m in line for m in failure_markers):
+                in_error = True
+            if in_error:
+                error_lines.append(line)
+                if len(error_lines) >= 70:
+                    break
+        if error_lines:
+            header = "\n".join(lines_list[:15])
+            error_block = "\n".join(error_lines)
+            footer = "\n".join(lines_list[-15:])
+            distilled = f"{header}\n\n... [build logs distilled] ...\n\n### CRITICAL FAILURE DETAILS:\n{error_block}\n\n### SUMMARY:\n{footer}"
+            if len(distilled) <= max_chars:
+                return distilled
+
+    head_size = int(max_chars * 0.6)
+    tail_size = max_chars - head_size
     omitted = len(text) - head_size - tail_size
     return (
         text[:head_size]
@@ -366,7 +383,6 @@ def _smart_truncate(text: str, max_chars: int = 6000) -> str:
     )
 
 
-
 def _extract_script_path(command: str) -> str:
     """Extract the script file path from a bash command, if any."""
     import re as _re
@@ -853,34 +869,82 @@ def _clone_repo(workdir: Path, repo_url: str, branch: str = None) -> str:
 # ── Dispatch factory ──────────────────────────────────────────────────
 
 def make_dispatch(workdir: Path):
-    """Bind tool implementations to a specific working directory."""
+    """Bind tool implementations to a specific working directory with resilient parameter extraction."""
+
+    def _safe_bash(a: dict) -> str:
+        cmd = a.get("command") or a.get("cmd") or a.get("script") or a.get("shell_command") or ""
+        if not str(cmd).strip():
+            return "error: 'command' parameter is required and cannot be empty"
+        return _bash(workdir, str(cmd))
+
+    def _safe_read_file(a: dict) -> str:
+        path = a.get("path") or a.get("file") or a.get("filepath") or a.get("filename") or ""
+        if not str(path).strip():
+            return "error: 'path' parameter is required for read_file"
+        return _read_file(workdir, str(path), a.get("start_line"), a.get("end_line"))
+
+    def _safe_write_file(a: dict) -> str:
+        path = a.get("path") or a.get("file") or a.get("filepath") or a.get("filename") or ""
+        if not str(path).strip():
+            return "error: 'path' parameter is required for write_file"
+        content = None
+        for k in ("content", "code", "text", "body", "file_content", "data", "contents"):
+            if k in a and a[k] is not None:
+                content = str(a[k])
+                break
+        if content is None:
+            return f"error: 'content' parameter is required for write_file to '{path}'. Please provide the file content."
+        return _write_file(workdir, str(path), content)
+
+    def _safe_edit_file(a: dict) -> str:
+        path = a.get("path") or a.get("file") or a.get("filepath") or a.get("filename") or ""
+        if not str(path).strip():
+            return "error: 'path' parameter is required for edit_file"
+        old_str = a.get("old_str") if a.get("old_str") is not None else a.get("old_string") if a.get("old_string") is not None else a.get("target")
+        if old_str is None:
+            return "error: 'old_str' parameter is required for edit_file (the exact string to replace)"
+        new_str = a.get("new_str") if a.get("new_str") is not None else a.get("new_string") if a.get("new_string") is not None else a.get("replacement") if a.get("replacement") is not None else a.get("code") if a.get("code") is not None else ""
+        return _edit_file(workdir, str(path), str(old_str), str(new_str))
+
+    def _safe_file_search(a: dict) -> str:
+        pattern = a.get("pattern") or a.get("query") or a.get("regex") or ""
+        if not str(pattern).strip():
+            return "error: 'pattern' parameter is required for file_search"
+        return _file_search(workdir, str(pattern), a.get("path", "."),
+                           a.get("include"), a.get("case_insensitive", False))
+
+    def _safe_update_plan(a: dict) -> str:
+        plan = a.get("plan") or a.get("content") or a.get("steps") or a.get("summary") or ""
+        if not str(plan).strip():
+            return "error: 'plan' parameter is required for update_plan"
+        return _update_plan(workdir, str(plan))
+
     return {
-        "bash": lambda a: _bash(workdir, a["command"]),
-        "read_file": lambda a: _read_file(workdir, a["path"], a.get("start_line"), a.get("end_line")),
-        "write_file": lambda a: _write_file(workdir, a["path"], a["content"]),
-        "edit_file": lambda a: _edit_file(workdir, a["path"], a["old_str"], a["new_str"]),
-        "list_files": lambda a: _list_files(workdir, a.get("path", "."), a.get("max_depth", 4)),
-        "file_search": lambda a: _file_search(workdir, a["pattern"], a.get("path", "."),
-                                               a.get("include"), a.get("case_insensitive", False)),
-        "apply_patch": lambda a: _apply_patch(workdir, a["path"], a["patch"]),
-        "web_search": lambda a: _web_search(a["query"], a.get("num_results", 5)),
-        "fetch_url": lambda a: _fetch_url(a["url"]),
-        "request_user_input": lambda a: _request_user_input(a["question"]),
-        "update_plan": lambda a: _update_plan(workdir, a["plan"]),
-        "view_image": lambda a: _view_image(workdir, a["path"]),
+        "bash": _safe_bash,
+        "read_file": _safe_read_file,
+        "write_file": _safe_write_file,
+        "edit_file": _safe_edit_file,
+        "list_files": lambda a: _list_files(workdir, a.get("path") or a.get("dir") or ".", a.get("max_depth", 4)),
+        "file_search": _safe_file_search,
+        "apply_patch": lambda a: _apply_patch(workdir, a.get("path") or a.get("file", ""), a.get("patch") or a.get("diff", "")),
+        "web_search": lambda a: _web_search(a.get("query") or a.get("q", ""), a.get("num_results", 5)),
+        "fetch_url": lambda a: _fetch_url(a.get("url") or a.get("uri", "")),
+        "request_user_input": lambda a: _request_user_input(a.get("question") or a.get("prompt", "")),
+        "update_plan": _safe_update_plan,
+        "view_image": lambda a: _view_image(workdir, a.get("path") or a.get("file", "")),
         "github_issues": lambda a: _github_issues(
-            a["owner"], a["repo"],
+            a.get("owner", ""), a.get("repo", ""),
             issue_number=a.get("issue_number"),
             state=a.get("state", "open"),
             max_results=a.get("max_results", 10),
         ),
         "github_browse": lambda a: _github_browse(
-            a["owner"], a["repo"],
+            a.get("owner", ""), a.get("repo", ""),
             path=a.get("path", ""),
             info_only=a.get("info_only", False),
         ),
         "clone_repo": lambda a: _clone_repo(
-            workdir, a["repo_url"],
+            workdir, a.get("repo_url") or a.get("url", ""),
             branch=a.get("branch"),
         ),
     }

alpiecode-9.0.4/test/test_claude_codex_capabilities.py

@@ -0,0 +1,111 @@
+"""
+Unit tests for Claude Code and Codex caliber capabilities added to AlpieCode:
+1. Fast AST Codebase Map (Symbol indexing)
+2. Self-Healing File Suggestions
+3. Smart Failure Distillation in Output Truncation
+4. Milestone & Todo Checklist Tracking
+5. Autonomous Verify-Before-Done Gate
+"""
+
+from pathlib import Path
+import pytest
+
+from codeagent.discovery import build_symbol_index, TaskContext
+from codeagent.executor import suggest_similar_file
+from codeagent.tools import _smart_truncate
+from codeagent.progress import MilestoneTracker, ProgressMonitor
+
+
+def test_ast_symbol_index_extraction(tmp_path: Path):
+    """Verify that build_symbol_index accurately extracts classes, methods, and functions."""
+    sample_file = tmp_path / "sample.py"
+    sample_file.write_text(
+        "class OrderService:\n"
+        "    def create_order(self, item_id, qty):\n"
+        "        pass\n"
+        "    def cancel_order(self, order_id):\n"
+        "        pass\n\n"
+        "def calculate_tax(subtotal, rate=0.05):\n"
+        "    return subtotal * rate\n",
+        encoding="utf-8"
+    )
+
+    symbols = build_symbol_index(tmp_path)
+    assert "sample.py" in symbols
+    syms = symbols["sample.py"]
+    assert any("class OrderService" in s for s in syms)
+    assert any("def calculate_tax" in s for s in syms)
+
+
+def test_suggest_similar_file(tmp_path: Path):
+    """Verify fuzzy file-not-found suggestion matches close typos."""
+    src_dir = tmp_path / "src"
+    src_dir.mkdir(parents=True)
+    real_file = src_dir / "user_repository.py"
+    real_file.write_text("# user repo", encoding="utf-8")
+
+    # Typo: user_repo.py instead of user_repository.py
+    suggestion = suggest_similar_file(tmp_path, "src/user_repo.py")
+    assert suggestion == "src/user_repository.py"
+
+
+def test_smart_truncate_preserves_failures():
+    """Verify _smart_truncate preserves the exact failure traceback when truncating large logs."""
+    noisy_prefix = "PASS test_001.py\n" * 300
+    critical_failure = (
+        "FAILED test_auth.py::test_login - AssertionError: Status code 401 != 200\n"
+        "Traceback (most recent call last):\n"
+        "  File 'test_auth.py', line 45, in test_login\n"
+        "    assert response.status_code == 200\n"
+    )
+    noisy_suffix = "PASS test_100.py\n" * 300
+    summary = "=== 1 failed, 600 passed in 4.25s ==="
+
+    full_log = f"{noisy_prefix}\n{critical_failure}\n{noisy_suffix}\n{summary}"
+    assert len(full_log) > 6000
+
+    truncated = _smart_truncate(full_log, max_chars=3000)
+    assert len(truncated) <= 3000
+    assert "CRITICAL FAILURE DETAILS" in truncated
+    assert "AssertionError: Status code 401 != 200" in truncated
+    assert "test_auth.py" in truncated
+    assert summary in truncated
+
+
+def test_milestone_tracker():
+    """Verify milestone checklist tracking for planned tasks."""
+    plan_markdown = (
+        "Here is the plan:\n"
+        "- [ ] Step 1: Create database schema\n"
+        "- [ ] Step 2: Implement REST endpoints\n"
+        "- [x] Step 3: Set up virtualenv\n"
+    )
+
+    tracker = MilestoneTracker(plan_markdown)
+    assert len(tracker.milestones) == 3
+    assert tracker.milestones[0].done is False
+    assert tracker.milestones[2].done is True
+
+    # Mark step 1 done
+    tracker.mark_milestone("database schema", done=True)
+    assert tracker.milestones[0].done is True
+
+    pending = tracker.get_pending()
+    assert len(pending) == 1
+    assert "REST endpoints" in pending[0]
+
+
+def test_auto_verification_syntax_detection(tmp_path: Path):
+    """Verify that auto-verification catches syntax errors in modified Python files."""
+    import ast
+    bad_file = tmp_path / "broken.py"
+    bad_file.write_text("def broken(\n  return 42", encoding="utf-8")
+
+    syntax_errs = []
+    try:
+        ast.parse(bad_file.read_text(encoding="utf-8"))
+    except SyntaxError as se:
+        syntax_errs.append(f"- '{bad_file.name}' line {se.lineno}: {se.msg}")
+
+    assert len(syntax_errs) == 1
+    assert "broken.py" in syntax_errs[0]