alpiecode 8.0.9__tar.gz → 9.0.1__tar.gz

{alpiecode-8.0.9 → alpiecode-9.0.1}/PKG-INFO

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

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

{alpiecode-8.0.9 → alpiecode-9.0.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.9
+Version: 9.0.1
 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.9 → alpiecode-9.0.1}/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.9 → alpiecode-9.0.1}/src/codeagent/__init__.py

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

{alpiecode-8.0.9 → alpiecode-9.0.1}/src/codeagent/backends/local_backend.py

@@ -43,6 +43,59 @@ class LocalBackend:
         model = self._ensure_model()
         model.load()
 
+    @staticmethod
+    def _sanitize_messages_for_gguf(messages: List[dict]) -> List[dict]:
+        """
+        Sanitize OpenAI-format messages for GGUF Jinja2 chat templates.
+        Fixes 'Can only get item pairs from a mapping' errors by:
+        - Ensuring content is always a string (never None or list)
+        - Stripping tool_calls and tool messages (GGUF templates don't support them)
+        - Removing tool-related role messages
+        """
+        sanitized = []
+        for msg in messages:
+            role = msg.get("role", "")
+            # Skip tool result messages entirely — GGUF models don't understand them
+            if role == "tool":
+                continue
+
+            clean = {"role": role}
+
+            # Ensure content is always a string
+            content = msg.get("content")
+            if content is None:
+                content = ""
+            elif isinstance(content, list):
+                # Multimodal content (image_url + text blocks) — extract text parts
+                text_parts = []
+                for part in content:
+                    if isinstance(part, dict):
+                        if part.get("type") == "text":
+                            text_parts.append(part.get("text", ""))
+                    elif isinstance(part, str):
+                        text_parts.append(part)
+                content = "\n".join(text_parts) if text_parts else ""
+            elif not isinstance(content, str):
+                content = str(content)
+
+            # For assistant messages with tool_calls, embed tool call info in content text
+            if role == "assistant" and msg.get("tool_calls"):
+                tc_descriptions = []
+                for tc in msg["tool_calls"]:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        name = fn.get("name", "unknown")
+                        args = fn.get("arguments", "{}")
+                        tc_descriptions.append(f"[Called tool: {name}({args})]")
+                if tc_descriptions:
+                    content = (content + "\n" + "\n".join(tc_descriptions)).strip()
+                # Do NOT include tool_calls key — GGUF template will crash on it
+
+            clean["content"] = content
+            sanitized.append(clean)
+
+        return sanitized
+
     def chat_completion(
         self,
         messages: List[dict],
@@ -52,8 +105,9 @@ class LocalBackend:
         enable_thinking: bool = True,
     ) -> ChatResponse:
         model = self._ensure_model()
+        sanitized_msgs = self._sanitize_messages_for_gguf(messages)
         resp = model.create_chat_completion(
-            messages=messages,
+            messages=sanitized_msgs,
             tools=tools,
             tool_choice="auto",
             temperature=temperature,

{alpiecode-8.0.9 → alpiecode-9.0.1}/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.9 → alpiecode-9.0.1}/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.9 → alpiecode-9.0.1}/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.9 → alpiecode-9.0.1}/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)