alpiecode 8.0.8__tar.gz → 9.0.0__tar.gz

{alpiecode-8.0.8 → alpiecode-9.0.0}/PKG-INFO

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

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

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/alpiecode.egg-info/PKG-INFO

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

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

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/__init__.py

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

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/backends/openai_backend.py

@@ -2,9 +2,103 @@
 OpenAI-compatible API inference backend with smart model resolution.
 """
 
+import ast
+import json
+import logging
+import re
 from typing import Any, List, Optional
 from openai import OpenAI, NotFoundError
 
+logger = logging.getLogger(__name__)
+
+
+def _repair_and_parse_json_arguments(raw_args: str) -> dict:
+    """
+    Robustly parse tool call arguments from potentially partial or malformed streaming strings.
+    Handles:
+      - Clean JSON
+      - Single-quoted JSON / Python dict strings via ast.literal_eval
+      - Truncated strings / missing closing quotes & braces from stream cutoffs
+      - Trailing commas
+    Returns a dict of parsed arguments. If unparseable, returns a dict preserving _raw_arguments
+    and _parse_error so the tool dispatcher can provide actionable error reporting.
+    """
+    if not raw_args or not raw_args.strip():
+        return {}
+
+    text = raw_args.strip()
+
+    # 1. Direct standard JSON
+    try:
+        parsed = json.loads(text)
+        if isinstance(parsed, dict):
+            return parsed
+        return {"value": parsed}
+    except Exception:
+        pass
+
+    # 2. Try ast.literal_eval (handles Python single quotes, True/False/None)
+    try:
+        parsed = ast.literal_eval(text)
+        if isinstance(parsed, dict):
+            return parsed
+    except Exception:
+        pass
+
+    # 3. Structural repair for streaming cutoffs / trailing commas
+    repaired = text
+
+    # Remove trailing commas like `..., }` or `..., ]`
+    repaired = re.sub(r",\s*([\}\]])", r"\1", repaired)
+
+    # If trailing comma at end: `{"a": 1,` -> `{"a": 1`
+    repaired = re.sub(r",\s*$", "", repaired)
+
+    # Check unclosed quotes: count non-escaped double quotes
+    quote_count = len(re.findall(r'(?<!\\)"', repaired))
+    if quote_count % 2 != 0:
+        repaired += '"'
+
+    # Balance unclosed brackets and braces
+    open_curly = repaired.count("{") - repaired.count("}")
+    open_square = repaired.count("[") - repaired.count("]")
+
+    if open_square > 0:
+        repaired += "]" * open_square
+    if open_curly > 0:
+        repaired += "}" * open_curly
+
+    try:
+        parsed = json.loads(repaired)
+        if isinstance(parsed, dict):
+            return parsed
+    except Exception:
+        pass
+
+    # 4. If still failing, attempt regex key-value extraction for simple {"key": "val"} forms
+    extracted = {}
+    pattern = r"""['"]([a-zA-Z0-9_-]+)['"]\s*:\s*(?:['"](.*?)['"]|([0-9.]+|true|false|null))"""
+    for kv in re.finditer(pattern, text, re.IGNORECASE):
+        k = kv.group(1)
+        v_str = kv.group(2)
+        v_lit = kv.group(3)
+        if v_str is not None:
+            extracted[k] = v_str
+        elif v_lit is not None:
+            try:
+                extracted[k] = json.loads(v_lit.lower())
+            except Exception:
+                extracted[k] = v_lit
+
+    if extracted:
+        return extracted
+
+    logger.warning("Failed to parse tool call arguments: %s", raw_args[:200])
+    return {
+        "_raw_arguments": raw_args,
+        "_parse_error": "Failed to parse streaming JSON arguments",
+    }
+
 from ..config import Config, get_shared_http_client, is_server_reachable
 from .base import ChatResponse, ToolCall
 
@@ -185,10 +279,7 @@ class OpenAIBackend:
             tool_calls = []
             for idx in sorted(tool_calls_dict.keys()):
                 item = tool_calls_dict[idx]
-                try:
-                    args = json.loads(item["arguments"])
-                except Exception:
-                    args = {}
+                args = _repair_and_parse_json_arguments(item.get("arguments", ""))
                 tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
 
         final_content_str = "".join(full_content).strip()
@@ -260,15 +351,10 @@ class OpenAIBackend:
 
         tool_calls = None
         if msg.tool_calls:
-            import json
             tool_calls = []
             for tc in msg.tool_calls:
-                try:
-                    args = json.loads(tc.function.arguments or "{}")
-                except (json.JSONDecodeError, TypeError):
-                    args = {}
-                if not isinstance(args, dict):
-                    args = {}
+                raw_args = tc.function.arguments or "{}"
+                args = _repair_and_parse_json_arguments(raw_args)
                 tool_calls.append(
                     ToolCall(
                         id=tc.id,

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/client.py

@@ -102,31 +102,39 @@ class AlpieCodeClient:
         try:
             with urllib.request.urlopen(req, timeout=self.timeout) as resp:
                 current_event_type = "message"
-                current_data_str = ""
+                current_data_lines: List[str] = []
 
                 for raw_line in resp:
-                    line = raw_line.decode("utf-8").strip()
+                    line = raw_line.decode("utf-8").rstrip("\r\n")
                     if not line:
-                        if current_data_str:
+                        if current_data_lines:
+                            raw_data = "\n".join(current_data_lines)
                             try:
-                                event_data = json.loads(current_data_str)
+                                event_data = json.loads(raw_data)
                             except Exception:
-                                event_data = {"content": current_data_str}
+                                event_data = {"content": raw_data}
                             yield AgentEvent(type=current_event_type, data=event_data)
                             current_event_type = "message"
-                            current_data_str = ""
+                            current_data_lines = []
                         continue
 
-                    if line.startswith("event:"):
+                    if line.startswith(":"):
+                        # SSE comment/keepalive ping - ignore
+                        continue
+                    elif line.startswith("event:"):
                         current_event_type = line[6:].strip()
                     elif line.startswith("data:"):
-                        current_data_str = line[5:].strip()
+                        chunk = line[5:]
+                        if chunk.startswith(" "):
+                            chunk = chunk[1:]
+                        current_data_lines.append(chunk)
 
-                if current_data_str:
+                if current_data_lines:
+                    raw_data = "\n".join(current_data_lines)
                     try:
-                        event_data = json.loads(current_data_str)
+                        event_data = json.loads(raw_data)
                     except Exception:
-                        event_data = {"content": current_data_str}
+                        event_data = {"content": raw_data}
                     yield AgentEvent(type=current_event_type, data=event_data)
         except Exception as e:
             yield AgentEvent(type="error", data={"error": f"Server connection failed: {e}"})

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/context.py

@@ -6,6 +6,7 @@ and dynamically assembles token-budgeted context windows via build_context()
 for OpenAI-compatible chat completion endpoints.
 """
 
+import copy
 import json
 import time
 from typing import Any, Dict, List, Optional
@@ -52,9 +53,19 @@ class ContextManager:
     def __init__(self, max_tokens: int = 262_144):
         self.max_tokens = max_tokens
         self._messages: List[dict] = []
+        self._raw_messages: List[dict] = []
         self._metadata: List[Dict[str, Any]] = []
         self._turn_counter: int = 0
         self._cached_summary: Optional[str] = None
+        self._cached_summary_len: int = 0
+        self._cached_context: Optional[List[dict]] = None
+
+    def invalidate_cache(self, reset_summary: bool = False) -> None:
+        """Invalidate cached context assembly."""
+        self._cached_context = None
+        if reset_summary:
+            self._cached_summary = None
+            self._cached_summary_len = 0
 
     def _estimate_single_message_tokens(self, msg: dict) -> int:
         """Estimate token count for an individual message."""
@@ -141,27 +152,37 @@ class ContextManager:
 
     def set_system_prompt(self, prompt: str) -> None:
         """Set or update the root system prompt (Layer 1)."""
+        self.invalidate_cache(reset_summary=True)
         sys_msg = {"role": "system", "content": prompt}
         if self._messages and self._messages[0].get("role") == "system":
-            self._messages[0] = sys_msg
+            self._messages[0] = dict(sys_msg)
+            if self._raw_messages and self._raw_messages[0].get("role") == "system":
+                self._raw_messages[0] = copy.deepcopy(sys_msg)
+            else:
+                self._raw_messages.insert(0, copy.deepcopy(sys_msg))
             if self._metadata:
                 self._metadata[0] = self._build_metadata_entry(sys_msg, importance="high")
         else:
-            self._messages.insert(0, sys_msg)
+            self._messages.insert(0, dict(sys_msg))
+            self._raw_messages.insert(0, copy.deepcopy(sys_msg))
             self._metadata.insert(0, self._build_metadata_entry(sys_msg, importance="high"))
 
     def add_user_message(self, content: Any, metadata: Optional[dict] = None) -> None:
         """Append a user request and record metadata."""
+        self.invalidate_cache()
         self._turn_counter += 1
         msg = {"role": "user", "content": content}
-        self._messages.append(msg)
+        self._messages.append(dict(msg))
+        self._raw_messages.append(copy.deepcopy(msg))
         self._metadata.append(self._build_metadata_entry(msg, custom=metadata))
 
     def add_assistant_response(self, response: ChatResponse, metadata: Optional[dict] = None) -> None:
         """Append an assistant response with tool calls and record metadata."""
         if response.tool_calls or response.content:
+            self.invalidate_cache()
             msg = _serialize_assistant_message(response)
-            self._messages.append(msg)
+            self._messages.append(dict(msg))
+            self._raw_messages.append(copy.deepcopy(msg))
             tool_names = [tc.name for tc in response.tool_calls] if response.tool_calls else []
             custom_meta = metadata.copy() if metadata else {}
             custom_meta["tool_names"] = tool_names
@@ -176,12 +197,14 @@ class ContextManager:
         metadata: Optional[dict] = None,
     ) -> None:
         """Append a tool execution result and record metadata."""
+        self.invalidate_cache()
         msg = {
             "role": "tool",
             "tool_call_id": tool_call_id,
             "content": content,
         }
-        self._messages.append(msg)
+        self._messages.append(dict(msg))
+        self._raw_messages.append(copy.deepcopy(msg))
         self._metadata.append(
             self._build_metadata_entry(msg, tool_name=tool_name, custom=metadata)
         )
@@ -190,7 +213,9 @@ class ContextManager:
         """
         Truncate large historical tool outputs from turns older than keep_last_turns.
         Preserves update_plan and short outputs.
+        Note: Operates on working _messages, while _raw_messages / raw_history remains pristine.
         """
+        self.invalidate_cache()
         assistant_indices = [
             i for i, m in enumerate(self._messages)
             if isinstance(m, dict) and m.get("role") == "assistant"
@@ -206,6 +231,8 @@ class ContextManager:
                 # Never truncate update_plan output
                 if "[Plan updated]" in content or "Plan Status:" in content or len(content) <= 300:
                     continue
+                msg = dict(msg)
+                self._messages[i] = msg
                 lines = content.splitlines()
                 if len(lines) > 8:
                     preview_start = "\n".join(lines[:3])
@@ -215,6 +242,7 @@ class ContextManager:
                     msg["content"] = content[:150] + f"... [truncated {len(content)} chars]"
                 # Update tokens in metadata
                 if i < len(self._metadata):
+                    self._metadata[i] = dict(self._metadata[i])
                     self._metadata[i]["tokens"] = self._estimate_single_message_tokens(msg)
 
     def build_context(
@@ -230,6 +258,10 @@ class ContextManager:
           4. recent messages (intact tool-call pairs)
           5. current request (tail of conversation)
         """
+        is_default_params = (max_tokens is None or max_tokens == self.max_tokens) and recent_turns == 4
+        if is_default_params and self._cached_context is not None:
+            return [dict(m) for m in self._cached_context]
+
         if not self._messages:
             return []
 
@@ -276,10 +308,15 @@ class ContextManager:
             context_blocks.append(system_msg)
 
         if distant_messages:
-            # Layer 2: Distant Summary
-            summary_text = self._cached_summary or extract_conversation_summary(
-                distant_messages, distant_metadata
-            )
+            # Layer 2: Distant Summary (Lazy-cached)
+            if self._cached_summary is not None and len(distant_messages) == self._cached_summary_len:
+                summary_text = self._cached_summary
+            else:
+                summary_text = extract_conversation_summary(
+                    distant_messages, distant_metadata
+                )
+                self._cached_summary = summary_text
+                self._cached_summary_len = len(distant_messages)
             # Layer 3: Relevant History Anchors
             relevant_anchors = select_relevant_history(
                 distant_messages, distant_metadata
@@ -292,10 +329,16 @@ class ContextManager:
                 supplemental_parts.append(relevant_anchors)
 
             if supplemental_parts:
-                context_blocks.append({
-                    "role": "system",
-                    "content": "\n\n".join(supplemental_parts),
-                })
+                supp_text = "=== CONVERSATION SUMMARY & RELEVANT HISTORY ===\n" + "\n\n".join(supplemental_parts)
+                if context_blocks and context_blocks[0].get("role") == "system":
+                    # Merge into the existing primary system prompt to ensure strictly one system message at the beginning
+                    context_blocks[0] = dict(context_blocks[0])
+                    context_blocks[0]["content"] = (context_blocks[0].get("content") or "") + "\n\n" + supp_text
+                else:
+                    context_blocks.insert(0, {
+                        "role": "system",
+                        "content": supp_text,
+                    })
 
             # Ensure user query anchor: endpoint requires at least one 'user' message
             has_user_in_recent = any(m.get("role") == "user" for m in recent_messages)
@@ -325,7 +368,10 @@ class ContextManager:
         if estimate_tokens(context_blocks) > effective_limit:
             context_blocks = compact_messages(context_blocks)
 
-        return context_blocks
+        if is_default_params:
+            self._cached_context = [dict(m) for m in context_blocks]
+
+        return [dict(m) for m in context_blocks]
 
     @property
     def messages(self) -> List[dict]:
@@ -335,18 +381,20 @@ class ContextManager:
     @messages.setter
     def messages(self, msgs: List[dict]) -> None:
         """Replace messages and rebuild metadata."""
-        self._messages = list(msgs)
+        self.invalidate_cache(reset_summary=True)
+        self._messages = [dict(m) for m in msgs]
+        self._raw_messages = [copy.deepcopy(m) for m in msgs]
         self._rebuild_metadata()
 
     @property
     def all_messages(self) -> List[dict]:
         """Returns the complete, uncompressed historical messages."""
-        return list(self._messages)
+        return [copy.deepcopy(m) for m in self._raw_messages]
 
     @property
     def raw_history(self) -> List[dict]:
         """Alias for all_messages."""
-        return list(self._messages)
+        return [copy.deepcopy(m) for m in self._raw_messages]
 
     @property
     def metadata(self) -> List[Dict[str, Any]]:

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/memory.py

@@ -47,36 +47,64 @@ def load_memories(workdir: Path) -> List[dict]:
         return []
 
 
-def save_memory(workdir: Path, content: str, memory_type: str = "learning") -> None:
+def save_memories_batch(workdir: Path, entries: List[dict]) -> None:
     """
-    Save a memory entry for a project.
+    Save multiple memory entries for a project in a single atomic disk write.
 
     Args:
         workdir: Project directory
-        content: The memory content to save
-        memory_type: Type of memory (learning, structure, command, pattern)
+        entries: List of dicts, each with 'content' and optional 'type'
     """
+    if not entries:
+        return
+
     MEMORY_DIR.mkdir(parents=True, exist_ok=True)
     path = _memory_path(workdir)
 
     existing = load_memories(workdir)
-    existing.append({
-        "content": content,
-        "type": memory_type,
-        "timestamp": time.time(),
-        "workdir": str(workdir.resolve()),
-    })
+    existing_contents = {m.get("content") for m in existing}
+    now = time.time()
+    workdir_str = str(workdir.resolve())
+
+    added = False
+    for entry in entries:
+        c = entry.get("content", "").strip()
+        if not c or c in existing_contents:
+            continue
+        existing.append({
+            "content": c,
+            "type": entry.get("type", "learning"),
+            "timestamp": now,
+            "workdir": workdir_str,
+        })
+        existing_contents.add(c)
+        added = True
+
+    if not added:
+        return
 
     # Keep only the last 20 memories per project (FIFO)
     if len(existing) > 20:
         existing = existing[-20:]
 
     path.write_text(json.dumps({
-        "project": str(workdir.resolve()),
+        "project": workdir_str,
         "memories": existing,
     }, indent=2))
 
 
+def save_memory(workdir: Path, content: str, memory_type: str = "learning") -> None:
+    """
+    Save a single memory entry for a project.
+
+    Args:
+        workdir: Project directory
+        content: The memory content to save
+        memory_type: Type of memory (learning, structure, command, pattern)
+    """
+    save_memories_batch(workdir, [{"content": content, "type": memory_type}])
+
+
 def format_memories_for_prompt(workdir: Path) -> Optional[str]:
     """
     Format memories into a string suitable for injection into the system prompt.
@@ -102,13 +130,14 @@ def format_memories_for_prompt(workdir: Path) -> Optional[str]:
 def extract_and_save_memories(workdir: Path, messages: list) -> None:
     """
     After a session ends, extract key learnings from the conversation
-    and save them as memories.
+    and save them as memories in a single atomic batch.
 
     Scans tool results for commonly useful information like:
     - Successful build/test commands
     - Project structure (from list_files results)
     - Completion summaries
     """
+    to_save: List[dict] = []
     saved_cmds = set()  # Avoid duplicate command memories
 
     for idx, msg in enumerate(messages):
@@ -137,20 +166,23 @@ def extract_and_save_memories(workdir: Path, messages: list) -> None:
                                         cmd = ""
                                     if cmd and cmd not in saved_cmds:
                                         if any(kw in cmd for kw in ["pytest", "test", "unittest", "npm run test", "cargo test", "go test"]):
-                                            save_memory(workdir, f"Working test command: {cmd}", "command")
+                                            to_save.append({"content": f"Working test command: {cmd}", "type": "command"})
                                             saved_cmds.add(cmd)
                                         elif any(kw in cmd for kw in ["build", "compile", "g++", "gcc", "make", "cargo build", "npm run build"]):
-                                            save_memory(workdir, f"Working build command: {cmd}", "command")
+                                            to_save.append({"content": f"Working build command: {cmd}", "type": "command"})
                                             saved_cmds.add(cmd)
                         break
 
             # ── Save project structure from list_files / tree output ──
             if "├" in content or "└" in content:
                 if len(content) < 2000:
-                    save_memory(workdir, f"Project structure:\n{content[:500]}", "structure")
+                    to_save.append({"content": f"Project structure:\n{content[:500]}", "type": "structure"})
 
         # ── Save completion summaries ──
         if msg.get("role") == "assistant" and msg.get("content"):
             content = msg["content"]
             if content.strip().startswith("DONE"):
-                save_memory(workdir, content.strip()[:200], "completion_summary")
+                to_save.append({"content": content.strip()[:200], "type": "completion_summary"})
+
+    if to_save:
+        save_memories_batch(workdir, to_save)

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/prompt.py

@@ -375,7 +375,7 @@ COMPLEXITY_CONFIG = {
 
 BASH_RULES = """\
 ## Shell Environment: Bash (Linux/macOS)
-- You are ALREADY in the project root directory. NEVER run `cd /home/...` or `cd /testbed`
+- You are ALREADY in the project root directory. Run all commands directly without using `cd`
 - Use `&&` to chain commands
 - Use `export VAR=value` for environment variables
 - Use `python3` (not `python` which may be Python 2)
@@ -386,7 +386,7 @@ BASH_RULES = """\
 
 WSL_RULES = """\
 ## Shell Environment: WSL Bash (Windows Subsystem for Linux)
-- You are ALREADY in the project root directory. NEVER run `cd /home/...` or `cd /testbed`
+- You are ALREADY in the project root directory. Run all commands directly without using `cd`
 - Use bash syntax: `&&` to chain, `export VAR=value` for env vars
 - Use `python3` (not `python`)
 - For testing python code, use `python3 -m unittest`

{alpiecode-8.0.8 → alpiecode-9.0.0}/src/codeagent/tools.py

@@ -425,12 +425,17 @@ def _bash(workdir: Path, command: str) -> str:
                     command = re.sub(r"(?:[^\s;&|]*/)?(?:python3?|py)(?:\.exe)?\s+-m\s+pip3?\s+install\b", f"{uv_bin} pip install", command)
                     command = re.sub(r"(?:[^\s;&|]*/)?pip3?\s+install\b", f"{uv_bin} pip install", command)
 
+        # Strip hallucinated benchmark directory switches (e.g. cd /testbed && ..., cd /root && ...)
+        command = re.sub(r"^\s*cd\s+/(?:testbed|root|home/[^\s;&]+)\s*(&&|;)\s*", "", command)
+
         # Cross-platform shell resolution
         if shutil.which("bash"):
             shell_cmd = ["bash", "-c", command]
         elif os.name == "nt":
+            # PowerShell 5.1 compatibility: replace '&&' with ';'
+            ps_command = re.sub(r"\s+&&\s+", "; ", command)
             if shutil.which("powershell"):
-                shell_cmd = ["powershell", "-NoProfile", "-Command", command]
+                shell_cmd = ["powershell", "-NoProfile", "-Command", ps_command]
             else:
                 shell_cmd = ["cmd.exe", "/c", command]
         else:
@@ -607,10 +612,15 @@ def _list_files(workdir: Path, path: str = ".", max_depth: int = 4) -> str:
     except (subprocess.TimeoutExpired, FileNotFoundError):
         pass
 
-    # Fallback: os.walk
+    # Fallback: os.walk with directory pruning and early termination
+    prune_dirs = {
+        ".git", ".venv", "venv", "node_modules", "__pycache__",
+        "build", "dist", ".pytest_cache", ".ruff_cache", ".mypy_cache",
+        ".idea", ".vscode", ".next", ".nuxt", "target", "vendor",
+    }
     entries = []
     for root, dirs, files in os.walk(target):
-        dirs[:] = [d for d in dirs if not d.startswith(".")]
+        dirs[:] = [d for d in dirs if not d.startswith(".") and d not in prune_dirs]
         rel_root = os.path.relpath(root, target)
         depth = 0 if rel_root == "." else rel_root.count(os.sep) + 1
         if depth >= max_depth:
@@ -621,6 +631,10 @@ def _list_files(workdir: Path, path: str = ".", max_depth: int = 4) -> str:
                 continue
             rel_path = os.path.join(rel_root, fname) if rel_root != "." else fname
             entries.append(rel_path)
+            if len(entries) >= 200:
+                break
+        if len(entries) >= 200:
+            break
     return "\n".join(entries[:200]) or "(empty directory)"
 
 

{alpiecode-8.0.8 → alpiecode-9.0.0}/test/test_phase1.py

@@ -6,11 +6,14 @@ Unit tests verifying Phase 1 stability fixes:
 - BUG-06: orchestrator.py backend immutability / thread safety
 - BUG-09: tools.py bash timeout error message alignment
 - BUG-11: compaction.py tool-call pairing integrity
+- System message single-instance guarantee (prevents 400 'System message must be at the beginning')
+- Benchmark directory stripping (prevents hallucinated cd /testbed failures)
 """
 import ast
 from pathlib import Path
 from unittest.mock import MagicMock, patch
 import json
+import re
 import pytest
 
 from codeagent.executor import ToolExecutor, ToolCall, ToolResult
@@ -21,6 +24,7 @@ from codeagent.config import Config
 from codeagent.backends.base import ChatResponse
 from codeagent.backends.openai_backend import OpenAIBackend
 from codeagent.backends.local_backend import LocalBackend
+from codeagent.context import ContextManager
 
 
 def test_bug01_executor_dead_code_removed():
@@ -203,3 +207,53 @@ def test_bug11_compaction_tool_pairing_guard():
             assert prev_msg.get("role") in ("assistant", "tool"), (
                 f"Tool message at index {idx} was preceded by role '{prev_msg.get('role')}'"
             )
+
+
+def test_strictly_one_system_message_on_distant_turns():
+    """Verify build_context produces strictly ONE system message at index 0, preventing 400 errors."""
+    cm = ContextManager(max_tokens=8192)
+    cm.set_system_prompt("Base system prompt for AlpieCode.")
+
+    # Add 10 turns (exceeding recent_turns=4, triggering distant turn extraction)
+    for i in range(10):
+        cm.add_user_message(f"User request {i}")
+        cm.add_assistant_response(ChatResponse(
+            content=f"Assistant response {i}",
+            reasoning=None,
+            tool_calls=[ToolCall(id=f"c_{i}", name="bash", arguments={"command": f"echo {i}"})]
+        ))
+        cm.add_tool_result(f"c_{i}", f"output {i}", tool_name="bash")
+
+    context = cm.build_context(recent_turns=4)
+    
+    # Must have exactly one system message
+    system_messages = [m for m in context if m.get("role") == "system"]
+    assert len(system_messages) == 1, f"Expected exactly 1 system message, got {len(system_messages)}"
+    
+    # It must be at index 0
+    assert context[0].get("role") == "system"
+    
+    # It should include the merged conversation summary/history
+    assert "CONVERSATION SUMMARY" in context[0]["content"]
+
+
+def test_bash_strips_testbed_hallucination(tmp_path):
+    """Verify tools.py _bash automatically strips 'cd /testbed &&' prefixes."""
+    import subprocess
+    from codeagent.tools import _bash
+
+    captured_cmds = []
+    def fake_run(cmd, **kwargs):
+        captured_cmds.append(cmd)
+        mock = MagicMock()
+        mock.stdout = "OK"
+        mock.stderr = ""
+        mock.returncode = 0
+        return mock
+
+    with patch("subprocess.run", side_effect=fake_run):
+        _bash(tmp_path, "cd /testbed && python -m pytest test_file.py")
+        assert len(captured_cmds) == 1
+        executed_str = " ".join(captured_cmds[0])
+        assert "/testbed" not in executed_str
+        assert "python -m pytest test_file.py" in executed_str

alpiecode-9.0.0/test/test_phase2.py

@@ -0,0 +1,231 @@
+"""
+Unit tests verifying Phase 2 correctness and resilience fixes:
+- BUG-03: context.py context cache and invalidation
+- BUG-07: context.py raw history preservation and deep copy
+- BUG-08: openai_backend.py partial stream JSON argument repair
+- BUG-10: client.py multi-line SSE data accumulation and comment handling
+"""
+
+import copy
+import io
+import json
+from unittest.mock import MagicMock, patch
+import pytest
+
+from codeagent.context import ContextManager
+from codeagent.backends.base import ChatResponse, ToolCall
+from codeagent.backends.openai_backend import _repair_and_parse_json_arguments
+from codeagent.client import AlpieCodeClient
+
+
+# ==============================================================================
+# BUG-07: Raw history preservation & deep copy
+# ==============================================================================
+
+def test_bug07_raw_history_never_mutated_by_rolling_compact():
+    """Verify rolling_compact_old_tools truncates working messages while raw_history remains pristine."""
+    cm = ContextManager(max_tokens=8192)
+    cm.set_system_prompt("System prompt")
+    cm.add_user_message("Task 1")
+
+    # Turn 1
+    cm.add_assistant_response(ChatResponse(
+        content="Running tool",
+        reasoning=None,
+        tool_calls=[ToolCall(id="call_1", name="bash", arguments={"command": "cat long_file"})]
+    ))
+    long_tool_output = "\n".join([f"Line {i}: This is long output that should be truncated in compaction." for i in range(50)])
+    cm.add_tool_result("call_1", long_tool_output, tool_name="bash")
+
+    # Turn 2
+    cm.add_assistant_response(ChatResponse(
+        content="Running second tool",
+        reasoning=None,
+        tool_calls=[ToolCall(id="call_2", name="bash", arguments={"command": "echo done"})]
+    ))
+    cm.add_tool_result("call_2", "short output", tool_name="bash")
+
+    # Turn 3
+    cm.add_assistant_response(ChatResponse(
+        content="Final turn",
+        reasoning=None,
+        tool_calls=[]
+    ))
+
+    # Before compaction, verify raw history contains the full 50 lines
+    raw_before = cm.all_messages
+    tool_msg_raw = [m for m in raw_before if m.get("role") == "tool" and m.get("tool_call_id") == "call_1"][0]
+    assert tool_msg_raw["content"] == long_tool_output
+
+    # Run rolling compact keeping only the last turn
+    cm.rolling_compact_old_tools(keep_last_turns=1)
+
+    # In active messages, call_1 output should now be truncated
+    active_msgs = cm._messages
+    tool_msg_active = [m for m in active_msgs if m.get("role") == "tool" and m.get("tool_call_id") == "call_1"][0]
+    assert "[Output: 50 lines truncated for brevity]" in tool_msg_active["content"]
+
+    # In all_messages and raw_history, it MUST remain completely intact
+    raw_after = cm.all_messages
+    tool_msg_raw_after = [m for m in raw_after if m.get("role") == "tool" and m.get("tool_call_id") == "call_1"][0]
+    assert tool_msg_raw_after["content"] == long_tool_output
+
+    raw_hist_after = cm.raw_history
+    tool_msg_hist_after = [m for m in raw_hist_after if m.get("role") == "tool" and m.get("tool_call_id") == "call_1"][0]
+    assert tool_msg_hist_after["content"] == long_tool_output
+
+
+def test_bug07_raw_history_deep_copy_isolation():
+    """Verify mutating dictionaries in the returned raw_history list cannot corrupt ContextManager internals."""
+    cm = ContextManager(max_tokens=8192)
+    cm.set_system_prompt("System prompt")
+    cm.add_user_message("Original user message")
+
+    history = cm.raw_history
+    assert len(history) == 2
+
+    # Mutate the returned dictionary
+    history[1]["content"] = "CORRUPTED_IN_PLACE"
+
+    # Fetching history again should yield the unmodified original content
+    fresh_history = cm.raw_history
+    assert fresh_history[1]["content"] == "Original user message"
+
+
+# ==============================================================================
+# BUG-03: Context cache and invalidation
+# ==============================================================================
+
+def test_bug03_context_cache_and_invalidation():
+    """Verify build_context caches results and invalidates properly on every mutation."""
+    cm = ContextManager(max_tokens=8192)
+    assert cm._cached_context is None
+
+    cm.set_system_prompt("System prompt")
+    cm.add_user_message("User message 1")
+    assert cm._cached_context is None
+
+    # First access to messages populates cache
+    msgs_1 = cm.messages
+    assert cm._cached_context is not None
+    cached_ref = cm._cached_context
+
+    # Second access returns cached content without rebuilding
+    msgs_2 = cm.messages
+    assert msgs_1 == msgs_2
+    assert cm._cached_context is cached_ref
+
+    # Adding assistant response must invalidate cache
+    cm.add_assistant_response(ChatResponse(content="Response 1", reasoning=None, tool_calls=[]))
+    assert cm._cached_context is None
+
+    # Accessing messages repopulates cache
+    msgs_3 = cm.messages
+    assert len(msgs_3) == 3
+    assert cm._cached_context is not None
+
+    # Adding tool result must invalidate cache
+    cm.add_tool_result("id_1", "output 1")
+    assert cm._cached_context is None
+
+    # Adding user message must invalidate cache
+    cm.messages  # populate
+    assert cm._cached_context is not None
+    cm.add_user_message("User message 2")
+    assert cm._cached_context is None
+
+    # Reassigning messages setter must invalidate cache
+    cm.messages  # populate
+    assert cm._cached_context is not None
+    cm.messages = [{"role": "system", "content": "New sys"}]
+    assert cm._cached_context is None
+    assert len(cm.messages) == 1
+
+
+# ==============================================================================
+# BUG-08: Partial stream JSON argument repair
+# ==============================================================================
+
+def test_bug08_partial_json_repair_clean():
+    """Verify clean JSON parses directly."""
+    res = _repair_and_parse_json_arguments('{"command": "pytest -v", "timeout": 30}')
+    assert res == {"command": "pytest -v", "timeout": 30}
+
+
+def test_bug08_partial_json_repair_truncated_quote_and_brace():
+    """Verify truncated JSON missing closing quotes and braces is automatically repaired."""
+    # Split mid-string: '{"command": "python -m pytest test.py'
+    res = _repair_and_parse_json_arguments('{"command": "python -m pytest test.py')
+    assert res == {"command": "python -m pytest test.py"}
+
+    # Missing closing brace only: '{"path": "foo.py", "content": "abc"}'
+    res2 = _repair_and_parse_json_arguments('{"path": "foo.py", "content": "abc"')
+    assert res2 == {"path": "foo.py", "content": "abc"}
+
+
+def test_bug08_partial_json_repair_trailing_comma():
+    """Verify trailing commas are stripped before parsing."""
+    res = _repair_and_parse_json_arguments('{"path": "foo.py",}')
+    assert res == {"path": "foo.py"}
+
+
+def test_bug08_partial_json_repair_python_syntax():
+    """Verify Python single-quoted dict strings are parsed via literal_eval."""
+    res = _repair_and_parse_json_arguments("{'command': 'ls -la', 'active': True}")
+    assert res == {"command": "ls -la", "active": True}
+
+
+def test_bug08_partial_json_unparseable_preserves_error():
+    """Verify completely unparseable input preserves raw arguments and parse error rather than silent empty dict."""
+    res = _repair_and_parse_json_arguments("invalid garbage text without json structure")
+    assert "_raw_arguments" in res
+    assert res["_raw_arguments"] == "invalid garbage text without json structure"
+    assert "_parse_error" in res
+
+
+def test_bug08_partial_json_empty():
+    """Verify empty or whitespace string returns empty dict."""
+    assert _repair_and_parse_json_arguments("") == {}
+    assert _repair_and_parse_json_arguments("   ") == {}
+
+
+# ==============================================================================
+# BUG-10: Multi-line SSE parser accumulation
+# ==============================================================================
+
+def test_bug10_multiline_sse_parser():
+    """Verify stream_chat correctly accumulates multi-line data fields and ignores comments."""
+    # Construct raw SSE stream simulating multi-line JSON payload and SSE comments
+    sse_payload = (
+        b": keepalive ping\n"
+        b"event: message\n"
+        b"data: {\"role\": \"assistant\",\n"
+        b"data: \"content\": \"hello\\nworld\"}\n"
+        b"\n"
+        b": another comment\n"
+        b"event: token\n"
+        b"data: {\"delta\": \" next token\"}\n"
+        b"\n"
+    )
+
+    mock_resp = MagicMock()
+    mock_resp.__enter__.return_value = io.BytesIO(sse_payload)
+    mock_resp.__exit__.return_value = False
+
+    client = AlpieCodeClient(base_url="http://localhost:8000")
+
+    with patch("urllib.request.urlopen", return_value=mock_resp):
+        events = list(client.stream_chat(task="test multiline"))
+
+    assert len(events) == 2
+
+    # First event: multi-line message
+    evt1 = events[0]
+    assert evt1.type == "message"
+    assert evt1.data["role"] == "assistant"
+    assert evt1.data["content"] == "hello\nworld"
+
+    # Second event: token
+    evt2 = events[1]
+    assert evt2.type == "token"
+    assert evt2.data["delta"] == " next token"

alpiecode-9.0.0/test/test_phase3.py

@@ -0,0 +1,154 @@
+"""
+Unit tests verifying Phase 3 performance optimizations:
+- PERF-01: context.py distant summary lazy caching
+- PERF-06: tools.py _list_files directory pruning and early termination
+- PERF-05: memory.py batched disk writes and deduplication
+"""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+import pytest
+
+from codeagent.context import ContextManager
+from codeagent.backends.base import ChatResponse, ToolCall
+from codeagent.tools import _list_files
+import codeagent.memory as memory_mod
+
+
+# ==============================================================================
+# PERF-01: Distant summary lazy caching
+# ==============================================================================
+
+def test_perf01_summary_lazy_caching():
+    """Verify distant summary is lazy-cached and not re-computed when distant count is unchanged."""
+    cm = ContextManager(max_tokens=8192)
+    cm.set_system_prompt("Base system prompt")
+
+    # Add 6 turns
+    for i in range(6):
+        cm.add_user_message(f"User turn {i}")
+        cm.add_assistant_response(ChatResponse(
+            content=f"Assistant turn {i}",
+            reasoning=None,
+            tool_calls=[ToolCall(id=f"c_{i}", name="bash", arguments={"command": f"echo {i}"})]
+        ))
+        cm.add_tool_result(f"c_{i}", f"output {i}", tool_name="bash")
+
+    # First build with recent_turns=2 (creating distant messages)
+    context_1 = cm.build_context(recent_turns=2)
+    assert cm._cached_summary is not None
+    cached_summary = cm._cached_summary
+    assert cm._cached_summary_len > 0
+
+    # Next call with same distant turns should reuse the cached summary without calling extract_conversation_summary
+    with patch("codeagent.context.extract_conversation_summary", side_effect=RuntimeError("Should NOT be called")):
+        context_2 = cm.build_context(recent_turns=2)
+        assert context_2 == context_1
+        assert cm._cached_summary == cached_summary
+
+
+# ==============================================================================
+# PERF-06: _list_files directory pruning and short-circuit
+# ==============================================================================
+
+def test_perf06_list_files_pruning(tmp_path):
+    """Verify _list_files prunes node_modules, .venv, __pycache__, and hidden dirs."""
+    # Create valid project file
+    src_dir = tmp_path / "src"
+    src_dir.mkdir()
+    (src_dir / "index.py").write_text("print('hello')", encoding="utf-8")
+
+    # Create directories that MUST be pruned
+    node_modules = tmp_path / "node_modules" / "pkg"
+    node_modules.mkdir(parents=True)
+    (node_modules / "index.js").write_text("module.exports = {}", encoding="utf-8")
+
+    venv = tmp_path / ".venv" / "lib"
+    venv.mkdir(parents=True)
+    (venv / "site.py").write_text("# venv file", encoding="utf-8")
+
+    pycache = tmp_path / "__pycache__"
+    pycache.mkdir()
+    (pycache / "index.pyc").write_text("bytes", encoding="utf-8")
+
+    result = _list_files(tmp_path, max_depth=4)
+
+    # Valid file present
+    assert "src/index.py" in result or "src\\index.py" in result
+
+    # Pruned directories absent
+    assert "node_modules" not in result
+    assert ".venv" not in result
+    assert "__pycache__" not in result
+
+
+def test_perf06_list_files_short_circuit(tmp_path):
+    """Verify _list_files stops walking after collecting 200 entries."""
+    # Create 250 files
+    for i in range(250):
+        (tmp_path / f"file_{i:03d}.txt").write_text("content", encoding="utf-8")
+
+    result = _list_files(tmp_path, max_depth=2)
+    lines = result.splitlines()
+    assert len(lines) <= 200
+
+
+# ==============================================================================
+# PERF-05: Batched memory disk writes
+# ==============================================================================
+
+def test_perf05_batched_memory_saves(tmp_path, monkeypatch):
+    """Verify save_memories_batch performs a single atomic disk update with deduplication and FIFO limits."""
+    mem_dir = tmp_path / "memories"
+    monkeypatch.setattr(memory_mod, "MEMORY_DIR", mem_dir)
+
+    workdir = tmp_path / "project"
+    workdir.mkdir()
+
+    entries = [
+        {"content": "Working test command: pytest -v", "type": "command"},
+        {"content": "Working build command: npm run build", "type": "command"},
+        {"content": "Working test command: pytest -v", "type": "command"},  # Duplicate
+    ]
+
+    memory_mod.save_memories_batch(workdir, entries)
+
+    saved = memory_mod.load_memories(workdir)
+    assert len(saved) == 2  # Deduplicated from 3 to 2
+    contents = [m["content"] for m in saved]
+    assert "Working test command: pytest -v" in contents
+    assert "Working build command: npm run build" in contents
+
+
+def test_perf05_extract_and_save_memories_single_batch(tmp_path, monkeypatch):
+    """Verify extract_and_save_memories aggregates all discovered items into exactly one batch call."""
+    mem_dir = tmp_path / "memories"
+    monkeypatch.setattr(memory_mod, "MEMORY_DIR", mem_dir)
+
+    workdir = tmp_path / "project"
+    workdir.mkdir()
+
+    messages = [
+        {
+            "role": "assistant",
+            "tool_calls": [
+                {"id": "c1", "type": "function", "function": {"name": "bash", "arguments": json.dumps({"command": "pytest -v"})}}
+            ]
+        },
+        {
+            "role": "tool",
+            "tool_call_id": "c1",
+            "content": '{"exit_code": 0, "stdout": "All tests passed"}'
+        },
+        {
+            "role": "assistant",
+            "content": "DONE: Task completed successfully"
+        }
+    ]
+
+    with patch.object(memory_mod, "save_memories_batch", wraps=memory_mod.save_memories_batch) as mock_batch:
+        memory_mod.extract_and_save_memories(workdir, messages)
+        assert mock_batch.call_count == 1
+        args, _ = mock_batch.call_args
+        assert len(args[1]) == 2  # 1 test command + 1 completion summary