alpiecode 8.0.6__tar.gz → 8.0.7__tar.gz

{alpiecode-8.0.6 → alpiecode-8.0.7}/PKG-INFO

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

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

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/alpiecode.egg-info/PKG-INFO

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

@@ -16,7 +16,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "8.0.4"
+__version__ = "8.0.7"
 
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/compaction.py

@@ -10,10 +10,12 @@ Strategy:
   - Summarize older tool calls and results into compact descriptions
   - Preserve all user messages verbatim
   - Track approximate token count using a simple heuristic (4 chars ≈ 1 token)
+  - Generate structured conversation summaries and extract relevant history
+    for the decoupled ContextManager build_context() pipeline.
 """
 
 import json
-from typing import List
+from typing import Any, Dict, List, Optional
 
 # Our model's context window
 MAX_CONTEXT_TOKENS = 262_144
@@ -33,14 +35,16 @@ def estimate_tokens(messages: List[dict]) -> int:
             content = msg.get("content") or ""
             if isinstance(content, str):
                 total_chars += len(content)
+            elif isinstance(content, list):
+                total_chars += sum(len(str(c)) for c in content)
             # Account for tool call arguments
             tool_calls = msg.get("tool_calls", [])
             if tool_calls:
                 for tc in tool_calls:
                     if isinstance(tc, dict):
                         fn = tc.get("function", {})
-                        total_chars += len(fn.get("arguments", ""))
-                        total_chars += len(fn.get("name", ""))
+                        total_chars += len(str(fn.get("arguments", "")))
+                        total_chars += len(str(fn.get("name", "")))
     return total_chars // CHARS_PER_TOKEN
 
 
@@ -83,6 +87,138 @@ def _summarize_tool_result(tool_name: str, content: str) -> str:
     return content[:250] + f"... ({len(content)} chars total)"
 
 
+def extract_conversation_summary(
+    messages: List[dict],
+    metadata: Optional[List[dict]] = None,
+) -> str:
+    """
+    Extract a concise, structured markdown summary of historical turns.
+
+    Extracts:
+      - Initial user task / goal
+      - Key files created, edited, or inspected
+      - Commands executed and their success/failure
+      - Execution plan status
+      - Crucial findings or errors encountered
+    """
+    if not messages:
+        return ""
+
+    initial_task = ""
+    files_touched = set()
+    commands_run = []
+    latest_plan = ""
+    key_events = []
+
+    for i, msg in enumerate(messages):
+        role = msg.get("role", "")
+        content = msg.get("content") or ""
+
+        # Extract initial goal from first non-system user message
+        if role == "user" and not initial_task:
+            if isinstance(content, str) and content.strip():
+                lines = content.strip().splitlines()
+                initial_task = lines[0][:150]
+                if len(lines[0]) > 150:
+                    initial_task += "..."
+
+        # Assistant tool calls
+        if role == "assistant" and msg.get("tool_calls"):
+            for tc in msg.get("tool_calls", []):
+                tc_dict = tc if isinstance(tc, dict) else {}
+                fn = tc_dict.get("function", {})
+                name = fn.get("name", "")
+                args_raw = fn.get("arguments", "{}")
+                try:
+                    args = json.loads(args_raw) if isinstance(args_raw, str) else args_raw
+                except Exception:
+                    args = {}
+
+                if name in ("write_file", "patch_file", "read_file"):
+                    p = args.get("path") or args.get("file_path")
+                    if p:
+                        files_touched.add(f"{name}:{p}")
+                elif name == "bash":
+                    cmd = args.get("command", "")
+                    if cmd:
+                        commands_run.append(cmd[:80])
+
+        # Tool outputs
+        if role == "tool":
+            content_str = str(content)
+            if "[Plan updated]" in content_str or "Plan Status:" in content_str or "## Implementation Plan" in content_str:
+                latest_plan = content_str[-500:]  # Keep latest plan snapshot
+            elif "exit_code" in content_str and '"exit_code": 0' not in content_str:
+                # Capture error indication
+                key_events.append("Command execution returned an error (addressed in subsequent turns)")
+
+    summary_lines = []
+    if initial_task:
+        summary_lines.append(f"- **Initial Goal**: {initial_task}")
+    if files_touched:
+        files_preview = ", ".join(list(files_touched)[:6])
+        if len(files_touched) > 6:
+            files_preview += f" (+{len(files_touched) - 6} more)"
+        summary_lines.append(f"- **Files Touched**: {files_preview}")
+    if commands_run:
+        recent_cmds = ", ".join(commands_run[-4:])
+        summary_lines.append(f"- **Recent Commands Executed**: {recent_cmds}")
+    if latest_plan:
+        summary_lines.append(f"- **Execution Plan Snapshot**:\n  {latest_plan.strip()}")
+    if key_events:
+        summary_lines.append(f"- **Notes**: {key_events[-1]}")
+
+    if not summary_lines:
+        return ""
+
+    return "### Conversation Progress Summary (Prior Turns):\n" + "\n".join(summary_lines)
+
+
+def select_relevant_history(
+    messages: List[dict],
+    metadata: Optional[List[dict]] = None,
+    current_query: str = "",
+    token_budget: int = 2048,
+) -> str:
+    """
+    Select high-value historical anchors from distant history (e.g. plan updates,
+    key decisions, important command outcomes) formatted as concise contextual notes.
+    """
+    if not messages:
+        return ""
+
+    high_value_notes = []
+    seen_plans = set()
+
+    # Search backwards for high-importance messages
+    for i in range(len(messages) - 1, -1, -1):
+        msg = messages[i]
+        role = msg.get("role", "")
+        content = str(msg.get("content") or "")
+
+        # High priority: update_plan outputs
+        if role == "tool" and ("[Plan updated]" in content or "Plan Status:" in content):
+            if "plan" not in seen_plans:
+                seen_plans.add("plan")
+                lines = [l.strip() for l in content.splitlines() if l.strip() and not l.startswith("```")]
+                snippet = "\n".join(lines[:8])
+                high_value_notes.append(f"- **Active Plan Anchor**:\n{snippet}")
+
+        # High priority: stall advice or system corrections
+        if role == "user" and ("[STALL DETECTED]" in content or "[SYSTEM]" in content):
+            high_value_notes.append(f"- **System Intervention**: {content[:200]}")
+
+        # If we have enough context, stop
+        total_len = sum(len(n) for n in high_value_notes)
+        if (total_len // CHARS_PER_TOKEN) >= token_budget:
+            break
+
+    if not high_value_notes:
+        return ""
+
+    return "### Relevant Historical Anchors:\n" + "\n".join(reversed(high_value_notes))
+
+
 def compact_messages(messages: List[dict]) -> List[dict]:
     """
     Compact a message list by summarizing older turns.
@@ -109,7 +245,6 @@ def compact_messages(messages: List[dict]) -> List[dict]:
 
     # Build a compacted summary of old messages
     compacted_old = []
-    summary_parts = []
 
     for msg in old_messages:
         role = msg.get("role", "")

alpiecode-8.0.7/src/codeagent/context.py

@@ -0,0 +1,361 @@
+"""
+Conversation context manager for AlpieCode.
+
+Manages the complete conversation history (_messages), message metadata (_metadata),
+and dynamically assembles token-budgeted context windows via build_context()
+for OpenAI-compatible chat completion endpoints.
+"""
+
+import json
+import time
+from typing import Any, Dict, List, Optional
+
+from .backends.base import ChatResponse, ToolCall
+from .compaction import (
+    CHARS_PER_TOKEN,
+    compact_messages,
+    estimate_tokens,
+    extract_conversation_summary,
+    needs_compaction,
+    select_relevant_history,
+)
+
+
+def _serialize_assistant_message(msg: ChatResponse) -> dict:
+    """Serialize a ChatResponse into OpenAI chat message dict format."""
+    result: Dict[str, Any] = {"role": "assistant"}
+    result["content"] = msg.content if msg.content else None
+
+    if msg.tool_calls:
+        result["tool_calls"] = [
+            {
+                "id": tc.id,
+                "type": "function",
+                "function": {
+                    "name": tc.name,
+                    "arguments": json.dumps(tc.arguments) if isinstance(tc.arguments, dict) else str(tc.arguments or "{}"),
+                },
+            }
+            for tc in msg.tool_calls
+        ]
+    return result
+
+
+class ContextManager:
+    """
+    Decoupled context manager maintaining:
+      - _messages: Complete, uncompressed OpenAI-compatible message history.
+      - _metadata: Parallel metadata tracking per-message (tokens, turn, timestamp, importance, tool info).
+      - build_context(): 5-layer context assembly pipeline for OpenAI API calls.
+    """
+
+    def __init__(self, max_tokens: int = 262_144):
+        self.max_tokens = max_tokens
+        self._messages: List[dict] = []
+        self._metadata: List[Dict[str, Any]] = []
+        self._turn_counter: int = 0
+        self._cached_summary: Optional[str] = None
+
+    def _estimate_single_message_tokens(self, msg: dict) -> int:
+        """Estimate token count for an individual message."""
+        chars = 0
+        content = msg.get("content")
+        if isinstance(content, str):
+            chars += len(content)
+        elif isinstance(content, list):
+            chars += sum(len(str(c)) for c in content)
+
+        tool_calls = msg.get("tool_calls", [])
+        if tool_calls:
+            for tc in tool_calls:
+                if isinstance(tc, dict):
+                    fn = tc.get("function", {})
+                    chars += len(str(fn.get("name", "")))
+                    chars += len(str(fn.get("arguments", "")))
+        return max(1, chars // CHARS_PER_TOKEN)
+
+    def _build_metadata_entry(
+        self,
+        msg: dict,
+        tool_name: Optional[str] = None,
+        importance: Optional[str] = None,
+        custom: Optional[dict] = None,
+    ) -> Dict[str, Any]:
+        """Construct a structured metadata dict for a message."""
+        role = msg.get("role", "unknown")
+        tokens = self._estimate_single_message_tokens(msg)
+        content_str = str(msg.get("content") or "")
+
+        # Infer tool name if not provided
+        resolved_tool_name = tool_name
+        if role == "tool" and not resolved_tool_name:
+            t_id = msg.get("tool_call_id", "")
+            for prev in reversed(self._messages):
+                if prev.get("role") == "assistant" and prev.get("tool_calls"):
+                    for tc in prev["tool_calls"]:
+                        tc_dict = tc if isinstance(tc, dict) else {}
+                        if tc_dict.get("id") == t_id:
+                            resolved_tool_name = tc_dict.get("function", {}).get("name")
+                            break
+                    if resolved_tool_name:
+                        break
+
+        # Infer importance
+        resolved_importance = importance
+        if not resolved_importance:
+            if role == "system":
+                resolved_importance = "high"
+            elif role == "user":
+                resolved_importance = "high" if "[STALL DETECTED]" in content_str or "[SYSTEM]" in content_str else "normal"
+            elif role == "tool":
+                if resolved_tool_name == "update_plan" or "[Plan updated]" in content_str or "Plan Status:" in content_str:
+                    resolved_importance = "high"
+                elif "exit_code" in content_str and '"exit_code": 0' not in content_str:
+                    resolved_importance = "high"
+                elif resolved_tool_name in ("read_file", "list_files") and len(content_str) > 1000:
+                    resolved_importance = "low"
+                else:
+                    resolved_importance = "normal"
+            else:
+                resolved_importance = "normal"
+
+        entry: Dict[str, Any] = {
+            "turn": self._turn_counter,
+            "timestamp": time.time(),
+            "role": role,
+            "tokens": tokens,
+            "tool_name": resolved_tool_name,
+            "tool_call_id": msg.get("tool_call_id"),
+            "importance": resolved_importance,
+            "is_summary": False,
+        }
+        if custom:
+            entry.update(custom)
+        return entry
+
+    def _rebuild_metadata(self) -> None:
+        """Rebuild _metadata to maintain 1-to-1 sync if _messages is reassigned."""
+        self._metadata = [
+            self._build_metadata_entry(m) for m in self._messages
+        ]
+
+    def set_system_prompt(self, prompt: str) -> None:
+        """Set or update the root system prompt (Layer 1)."""
+        sys_msg = {"role": "system", "content": prompt}
+        if self._messages and self._messages[0].get("role") == "system":
+            self._messages[0] = sys_msg
+            if self._metadata:
+                self._metadata[0] = self._build_metadata_entry(sys_msg, importance="high")
+        else:
+            self._messages.insert(0, 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._turn_counter += 1
+        msg = {"role": "user", "content": content}
+        self._messages.append(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:
+            msg = _serialize_assistant_message(response)
+            self._messages.append(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
+            custom_meta["has_tools"] = bool(response.tool_calls)
+            self._metadata.append(self._build_metadata_entry(msg, custom=custom_meta))
+
+    def add_tool_result(
+        self,
+        tool_call_id: str,
+        content: str,
+        tool_name: Optional[str] = None,
+        metadata: Optional[dict] = None,
+    ) -> None:
+        """Append a tool execution result and record metadata."""
+        msg = {
+            "role": "tool",
+            "tool_call_id": tool_call_id,
+            "content": content,
+        }
+        self._messages.append(msg)
+        self._metadata.append(
+            self._build_metadata_entry(msg, tool_name=tool_name, custom=metadata)
+        )
+
+    def rolling_compact_old_tools(self, keep_last_turns: int = 3) -> None:
+        """
+        Truncate large historical tool outputs from turns older than keep_last_turns.
+        Preserves update_plan and short outputs.
+        """
+        assistant_indices = [
+            i for i, m in enumerate(self._messages)
+            if isinstance(m, dict) and m.get("role") == "assistant"
+        ]
+        if len(assistant_indices) <= keep_last_turns:
+            return
+
+        cutoff_idx = assistant_indices[-keep_last_turns]
+        for i in range(cutoff_idx):
+            msg = self._messages[i]
+            if isinstance(msg, dict) and msg.get("role") == "tool":
+                content = str(msg.get("content", ""))
+                # Never truncate update_plan output
+                if "[Plan updated]" in content or "Plan Status:" in content or len(content) <= 300:
+                    continue
+                lines = content.splitlines()
+                if len(lines) > 8:
+                    preview_start = "\n".join(lines[:3])
+                    preview_end = "\n".join(lines[-2:])
+                    msg["content"] = f"[Output: {len(lines)} lines truncated for brevity]\n{preview_start}\n...\n{preview_end}"
+                else:
+                    msg["content"] = content[:150] + f"... [truncated {len(content)} chars]"
+                # Update tokens in metadata
+                if i < len(self._metadata):
+                    self._metadata[i]["tokens"] = self._estimate_single_message_tokens(msg)
+
+    def build_context(
+        self,
+        max_tokens: Optional[int] = None,
+        recent_turns: int = 4,
+    ) -> List[dict]:
+        """
+        Assemble the 5-layer context window:
+          1. system prompt
+          2. summary (of distant turns)
+          3. relevant history (high-value anchors)
+          4. recent messages (intact tool-call pairs)
+          5. current request (tail of conversation)
+        """
+        if not self._messages:
+            return []
+
+        # ── Layer 1: System Prompt ──
+        system_msg: Optional[dict] = None
+        work_messages: List[dict] = []
+        work_metadata: List[dict] = []
+
+        if self._messages[0].get("role") == "system":
+            system_msg = dict(self._messages[0])
+            work_messages = self._messages[1:]
+            work_metadata = self._metadata[1:] if len(self._metadata) > 1 else []
+        else:
+            work_messages = list(self._messages)
+            work_metadata = list(self._metadata)
+
+        if not work_messages:
+            return [system_msg] if system_msg else []
+
+        # ── Determine recent turns cutoff ──
+        assistant_indices = [
+            i for i, m in enumerate(work_messages)
+            if isinstance(m, dict) and m.get("role") == "assistant"
+        ]
+
+        if len(assistant_indices) <= recent_turns:
+            cutoff_idx = 0
+        else:
+            cutoff_idx = assistant_indices[-recent_turns]
+
+        # ── Ensure Strict OpenAI Tool-Call Pairing Integrity ──
+        # If cutoff starts on a 'tool' message, move cutoff backwards to include
+        # the preceding 'assistant' message that owns the tool_call_id.
+        while cutoff_idx > 0 and work_messages[cutoff_idx].get("role") == "tool":
+            cutoff_idx -= 1
+
+        distant_messages = work_messages[:cutoff_idx]
+        distant_metadata = work_metadata[:cutoff_idx]
+        recent_messages = [dict(m) for m in work_messages[cutoff_idx:]]
+
+        # ── Layer 2 & 3: Summary and Relevant History from Distant Turns ──
+        context_blocks = []
+        if system_msg:
+            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 3: Relevant History Anchors
+            relevant_anchors = select_relevant_history(
+                distant_messages, distant_metadata
+            )
+
+            supplemental_parts = []
+            if summary_text:
+                supplemental_parts.append(summary_text)
+            if relevant_anchors:
+                supplemental_parts.append(relevant_anchors)
+
+            if supplemental_parts:
+                context_blocks.append({
+                    "role": "system",
+                    "content": "\n\n".join(supplemental_parts),
+                })
+
+        # ── Layer 4 & 5: Recent Messages and Current Request ──
+        if len(recent_messages) > 6:
+            for i in range(len(recent_messages) - 4):
+                m = recent_messages[i]
+                if m.get("role") == "tool":
+                    c = str(m.get("content") or "")
+                    if len(c) > 400 and "[Plan updated]" not in c and "Plan Status:" not in c:
+                        lines = c.splitlines()
+                        if len(lines) > 8:
+                            m["content"] = f"[Output: {len(lines)} lines truncated]\n" + "\n".join(lines[:3]) + "\n...\n" + "\n".join(lines[-2:])
+                        else:
+                            m["content"] = c[:200] + "... [truncated]"
+
+        context_blocks.extend(recent_messages)
+
+        # ── Budget Verification ──
+        effective_limit = max_tokens or self.max_tokens
+        if estimate_tokens(context_blocks) > effective_limit:
+            context_blocks = compact_messages(context_blocks)
+
+        return context_blocks
+
+    @property
+    def messages(self) -> List[dict]:
+        """Returns the optimized, context-budgeted messages for model consumption."""
+        return self.build_context()
+
+    @messages.setter
+    def messages(self, msgs: List[dict]) -> None:
+        """Replace messages and rebuild metadata."""
+        self._messages = list(msgs)
+        self._rebuild_metadata()
+
+    @property
+    def all_messages(self) -> List[dict]:
+        """Returns the complete, uncompressed historical messages."""
+        return list(self._messages)
+
+    @property
+    def raw_history(self) -> List[dict]:
+        """Alias for all_messages."""
+        return list(self._messages)
+
+    @property
+    def metadata(self) -> List[Dict[str, Any]]:
+        """Returns parallel metadata list for all messages."""
+        return list(self._metadata)
+
+    def estimate_tokens(self) -> int:
+        """Estimate tokens of the active built context."""
+        return estimate_tokens(self.build_context())
+
+    def estimate_total_tokens(self) -> int:
+        """Estimate tokens of the entire raw history."""
+        return estimate_tokens(self._messages)
+
+    def check_and_compact(self) -> bool:
+        """Check if context needs compaction and refresh rolling summary cache."""
+        if needs_compaction(self._messages, max_tokens=self.max_tokens):
+            self._cached_summary = extract_conversation_summary(self._messages, self._metadata)
+            return True
+        return False

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/discovery.py

@@ -521,6 +521,97 @@ COMPLEXITY_CONFIG = {
 }
 
 
+# -- Pre-Read Context Injection ---------------------------------------------
+
+def gather_relevant_context(
+    task: str,
+    workdir: Path,
+    task_context: "TaskContext",
+    max_chars: int = 16000,
+) -> Optional[str]:
+    """Gather relevant project files and inject them as pre-loaded context.
+
+    Reads key files based on task intent so the agent doesn't code blindly.
+    Runs fast (filesystem only, no LLM calls). Returns None if nothing useful found.
+
+    Budget: ~4000 tokens = 16000 chars. Prioritises config > entry points > task-mentioned files.
+    """
+    if not task_context or getattr(task_context, "project_type", "") == "empty" or getattr(task_context, "file_count", 0) == 0:
+        return None
+
+    # Skip for pure Q&A -- no code context needed
+    if getattr(task_context, "intent", "") in ("qa",):
+        return None
+
+    sections: List[str] = []
+    chars_used = 0
+
+    def _add_file(rel_path: str, label: str = "") -> bool:
+        """Read a file and add it to sections. Returns True if added."""
+        nonlocal chars_used
+        fp = workdir / rel_path
+        if not fp.is_file():
+            return False
+        try:
+            content = fp.read_text(errors="replace")
+        except Exception:
+            return False
+        if not content.strip():
+            return False
+        # Truncate individual files at 3000 chars to leave room for others
+        if len(content) > 3000:
+            content = content[:3000] + f"\n... (truncated, {len(content)} chars total)"
+        if chars_used + len(content) > max_chars:
+            return False
+        tag = label or rel_path
+        sections.append(f"### {tag}\n```\n{content}\n```")
+        chars_used += len(content) + 50  # overhead for markdown
+        return True
+
+    # -- Priority 1: Config files (always useful) --
+    config_files = [
+        ("pyproject.toml", "pyproject.toml (project config)"),
+        ("package.json", "package.json (project config)"),
+        ("requirements.txt", "requirements.txt (dependencies)"),
+        ("Cargo.toml", "Cargo.toml (project config)"),
+        ("go.mod", "go.mod (project config)"),
+    ]
+    for rel, label in config_files:
+        _add_file(rel, label)
+
+    # -- Priority 2: Entry points (helps understand project structure) --
+    if task_context.intent in ("modify", "debug", "create"):
+        for ep in task_context.entry_points[:3]:
+            _add_file(ep, f"{ep} (entry point)")
+
+    # -- Priority 3: Files mentioned in the task (fuzzy match) --
+    task_lower = task.lower()
+    try:
+        all_files = []
+        for p in workdir.rglob("*"):
+            if p.is_file() and not any(
+                skip in str(p) for skip in [
+                    ".git/", "__pycache__", "node_modules", ".venv",
+                    ".egg-info", "dist/", "build/", ".mypy_cache",
+                ]
+            ):
+                all_files.append(str(p.relative_to(workdir)))
+        # Match filenames or stems mentioned in the task
+        for rel in all_files:
+            fname = Path(rel).stem.lower()
+            if len(fname) > 2 and fname in task_lower:
+                _add_file(rel, f"{rel} (mentioned in task)")
+                if chars_used > max_chars * 0.8:
+                    break
+    except Exception:
+        pass
+
+    if not sections:
+        return None
+
+    return "## Pre-loaded Project Context\n" + "\n\n".join(sections)
+
+
 # -- Main Entry Point -------------------------------------------------------
 
 def build_task_context(task: str, workdir: Path) -> TaskContext:

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/executor.py

@@ -84,6 +84,68 @@ def parse_text_tool_calls(text: str) -> List[dict]:
     return tool_calls
 
 
+
+def _parse_error_hint(stderr: str, stdout: str) -> str:
+    """Parse common error patterns from bash output and return a targeted hint."""
+    combined = (stderr + " " + stdout).strip()
+    if not combined:
+        return ""
+
+    hints = []
+
+    # Python errors
+    if "ModuleNotFoundError" in combined or "ImportError" in combined:
+        mod_match = re.search(r"(?:No module named|cannot import name)\s+['\"]?([a-zA-Z0-9_\.\-]+)['\"]?", combined)
+        mod = mod_match.group(1) if mod_match else ""
+        target = f"'{mod}' " if mod else ""
+        hints.append(
+            f"Hint: Module {target}not found. Check if it is installed (pip list | grep {mod or 'package'}) "
+            "and that the import path matches the project structure. If using a venv, ensure it is activated."
+        )
+    elif "SyntaxError" in combined:
+        # Extract line number if present
+        line_match = re.search(r"line (\d+)", combined)
+        line_ref = f" at line {line_match.group(1)}" if line_match else ""
+        hints.append(
+            f"Hint: Python SyntaxError{line_ref}. Use read_file to inspect the exact lines "
+            "around the error before attempting a fix. Do NOT guess -- read first, fix once."
+        )
+    elif "FileNotFoundError" in combined or "No such file or directory" in combined:
+        hints.append(
+            "Hint: File or directory not found. Use list_files to verify the correct path "
+            "before retrying. The file may be in a different directory than expected."
+        )
+    elif "TypeError" in combined or "AttributeError" in combined:
+        hints.append(
+            "Hint: Type or attribute error. Use read_file to check the function/class definition "
+            "and verify the correct argument types and available attributes."
+        )
+    elif "NameError" in combined:
+        hints.append(
+            "Hint: NameError -- a variable or function is used before definition. "
+            "Read the file to check for typos, missing imports, or incorrect scope."
+        )
+    elif "IndentationError" in combined or "TabError" in combined:
+        hints.append(
+            "Hint: Indentation error. Read the full file with read_file to see the actual "
+            "whitespace. Do NOT guess indentation levels -- verify from the source."
+        )
+    elif "Permission denied" in combined:
+        hints.append(
+            "Hint: Permission denied. Check file permissions or if the path is correct. "
+            "You may need to use chmod or run with appropriate privileges."
+        )
+    elif "command not found" in combined:
+        cmd_match = combined.split("command not found")[0].strip().split()
+        cmd = cmd_match[-1] if cmd_match else "unknown"
+        hints.append(
+            f"Hint: Command '{cmd}' not found. It may not be installed or not in PATH. "
+            "Check available commands or install the required package."
+        )
+
+    return "\n".join(hints)
+
+
 class ToolExecutor:
     """Executes tool calls for a workspace."""
 
@@ -240,6 +302,20 @@ class ToolExecutor:
                         "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
                     )
 
+                # Smart error hint injection for failed bash commands
+                if tc.name == "bash" and '"exit_code"' in res_str:
+                    try:
+                        _res_parsed = json.loads(res_str.split("\n", 1)[-1] if res_str.startswith("\u26a0") else res_str)
+                        if _res_parsed.get("exit_code", 0) != 0:
+                            _hint = _parse_error_hint(
+                                _res_parsed.get("stderr", ""),
+                                _res_parsed.get("stdout", ""),
+                            )
+                            if _hint:
+                                res_str += "\n\n" + _hint
+                    except Exception:
+                        pass
+
                 # Compilation failure recovery hint
                 if tc.name == "bash":
                     cmd = tc.arguments.get("command", "") if isinstance(tc.arguments, dict) else ""

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/guardrails.py

@@ -37,6 +37,10 @@ def validate_code_syntax(file_path: str, content: str) -> Tuple[bool, Optional[s
     if ext == ".py":
         try:
             ast.parse(content, filename=file_path)
+            # Syntax OK -- run semantic checks
+            sem_ok, sem_err = check_python_semantics(content, file_path)
+            if not sem_ok:
+                return False, sem_err
             return True, None
         except SyntaxError as e:
             line = e.lineno or 0
@@ -94,6 +98,68 @@ def validate_code_syntax(file_path: str, content: str) -> Tuple[bool, Optional[s
     return True, None
 
 
+def check_python_semantics(content: str, file_path: str) -> Tuple[bool, Optional[str]]:
+    """Lightweight semantic checks for Python files using AST.
+
+    Catches common first-attempt errors that pass syntax validation but
+    would fail at runtime. Runs in < 10ms.
+    """
+    try:
+        tree = ast.parse(content, filename=file_path)
+    except SyntaxError:
+        return True, None  # Syntax errors are caught elsewhere
+
+    warnings = []
+
+    # 1. Detect duplicate function/class definitions at module level
+    seen_names = {}
+    for node in ast.iter_child_nodes(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            name = node.name
+            if name in seen_names:
+                warnings.append(
+                    f"Duplicate definition of '{name}' at line {node.lineno} "
+                    f"(first defined at line {seen_names[name]})"
+                )
+            else:
+                seen_names[name] = node.lineno
+
+    # 2. Detect stub-only functions (body is just `pass` or `...`)
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            body = node.body
+            if len(body) == 1:
+                stmt = body[0]
+                is_pass = isinstance(stmt, ast.Pass)
+                is_ellipsis = (
+                    isinstance(stmt, ast.Expr)
+                    and isinstance(stmt.value, ast.Constant)
+                    and stmt.value.value is ...
+                )
+                is_docstring_only = (
+                    isinstance(stmt, ast.Expr)
+                    and isinstance(stmt.value, ast.Constant)
+                    and isinstance(stmt.value.value, str)
+                )
+                # Skip __init__ with just pass (common pattern)
+                if node.name == "__init__":
+                    continue
+                if is_pass or is_ellipsis:
+                    warnings.append(
+                        f"Function '{node.name}' at line {node.lineno} is a stub "
+                        f"(body is only 'pass' or '...'). Implement the actual logic."
+                    )
+
+    if warnings:
+        return False, (
+            f"Semantic warnings in '{file_path}':\n"
+            + "\n".join(f"  - {w}" for w in warnings)
+            + "\nPlease fix these issues before writing the file."
+        )
+
+    return True, None
+
+
 def check_bracket_balance(code: str) -> Tuple[bool, Optional[str]]:
     """Fast lexical check for unclosed brackets or strings in code."""
     stack = []

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/orchestrator.py

@@ -48,7 +48,7 @@ from .backends.openai_backend import OpenAIBackend
 from .cache import get_cache
 from .config import Config, is_server_reachable
 from .memory import extract_and_save_memories
-from .discovery import build_task_context, COMPLEXITY_CONFIG
+from .discovery import build_task_context, gather_relevant_context, COMPLEXITY_CONFIG
 from .progress import ProgressMonitor
 from .rephraser import PromptRephraser
 from .prompt import PromptBuilder, classify_task
@@ -174,8 +174,20 @@ class AgentOrchestrator:
             "rephrased": rephrased_task,
         })
 
+        # ── Phase 0.7: Pre-Read Context Injection ──
+        pre_read_ctx = None
+        try:
+            pre_read_ctx = gather_relevant_context(task, session.workdir, task_context)
+        except Exception:
+            pass  # Fail open -- never block the agent
+
+        # Append pre-read context to the rephrased task so the agent sees it
+        effective_task = rephrased_task
+        if pre_read_ctx:
+            effective_task = rephrased_task + "\n\n" + pre_read_ctx
+
         user_content = self.prompt_builder.build_user_content(
-            task=rephrased_task,
+            task=effective_task,
             image_path=image_path,
             video_path=video_path,
             url=url,
@@ -340,7 +352,7 @@ class AgentOrchestrator:
                 if not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
                     yield AgentEvent("message", {"content": resp.content})
 
-                extract_and_save_memories(session.workdir, session.context.messages)
+                extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
 
                 # Generate and write real walkthrough.md file to the project workspace
                 from pathlib import Path as _Path
@@ -364,6 +376,28 @@ class AgentOrchestrator:
                     "commands": session_executed_commands,
                 })
 
+                # ── Soft Verification Gate ──
+                # If files were written/modified but no verification was run, nudge the agent
+                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 getattr(self, "_verification_nudge", False):
+                    self._verification_nudge = 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
+
                 # Cache if single-turn
                 if is_cacheable and turn == 0:
                     try:
@@ -444,15 +478,15 @@ class AgentOrchestrator:
                 if not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
                     yield AgentEvent("message", {"content": resp.content})
 
-                extract_and_save_memories(session.workdir, session.context.messages)
+                extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
                 yield AgentEvent("done", {"summary": resp.content})
                 return
 
             # Empty response
-            extract_and_save_memories(session.workdir, session.context.messages)
+            extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))
             yield AgentEvent("done", {"summary": "Task completed."})
             return
 
         status = progress_monitor.get_status_summary()
         yield AgentEvent("max_turns_reached", {"max_turns": safety_ceiling, "progress": status})
-        extract_and_save_memories(session.workdir, session.context.messages)
+        extract_and_save_memories(session.workdir, getattr(session.context, 'all_messages', session.context.messages))

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/progress.py

@@ -128,8 +128,11 @@ class ProgressMonitor:
 
         recent = self.history[-3:] if len(self.history) >= 3 else self.history
         deleted = set()
+        last_error_text = ""
         for snap in recent:
             deleted.update(snap.files_deleted)
+            if snap.errors:
+                last_error_text = snap.errors[-1][:200]
 
         created_names = {Path(f).name for f in self.all_files_created}
         thrashing = deleted & created_names
@@ -143,18 +146,23 @@ class ProgressMonitor:
             )
 
         if all(snap.errors or (snap.bash_exit_codes and 0 not in snap.bash_exit_codes) for snap in recent):
+            err_msg = f"\nLast error encountered: {last_error_text}\n" if last_error_text else ""
             return (
                 "[SYSTEM - PROGRESS MONITOR] You have encountered errors for 3 consecutive turns. "
-                "STOP retrying the same approach. Instead:\n"
+                f"STOP retrying the same approach.{err_msg} Instead:\n"
                 "1. Use read_file to examine the FULL current state of the file(s) you\'re editing\n"
                 "2. Identify the root cause of the error (not the symptom)\n"
                 "3. Make ONE comprehensive fix that addresses all issues\n"
                 "If the task approach is fundamentally wrong, start with a simpler design."
             )
 
+        error_context = ""
+        if last_error_text:
+            error_context = f"\nLast error encountered: {last_error_text}\n"
         return (
             "[SYSTEM - PROGRESS MONITOR] No measurable progress detected for 3 turns. "
-            "You may be stuck in a loop. Either:\n"
+            f"You may be stuck in a loop.{error_context}"
+            "Either:\n"
             "1. Complete your current work and output DONE: <summary>\n"
             "2. Try a completely different approach to the problem\n"
             "3. If the code is written and working, verify with bash and finish."

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/prompt.py

@@ -442,6 +442,15 @@ GOAL_DRIVEN_RULES = """\
 - No Thrashing: NEVER delete a file (e.g. `rm <file>`) immediately after creating it to start over. Use `edit_file` to modify what needs fixing.
 - Immediate Completion: As soon as your code is written and verified, output `DONE: <summary>`. Do NOT linger or rerun commands that already passed.
 - Targeted Editing: If `edit_file` fails, use `read_file` to inspect the exact lines and whitespace before attempting another edit.
+
+## Mandatory Verification Before Completion
+- Before outputting DONE, you MUST verify your work:
+  - For Python: Run the script or run `python3 -c "import ast; ast.parse(open('<file>').read())"` for syntax check
+  - For JavaScript/TypeScript: Run `node --check <file>` for syntax check
+  - For any executable code: Run it at least once with bash
+  - If tests exist in the project: Run the test suite
+- NEVER say DONE if your last bash command returned a non-zero exit code
+- If you created or modified files but haven't run ANY verification command, you must verify before finishing
 """
 
 INTENT_MODIFY = """\

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/rephraser.py

@@ -104,9 +104,21 @@ class PromptRephraser:
             return task
 
         try:
+            # Inject project context if available so rephrased spec is project-aware
+            project_hint = ""
+            if task_context:
+                _fw = ", ".join(getattr(task_context, "frameworks", []) or []) or "none"
+                _pt = getattr(task_context, "project_type", "unknown")
+                _fc = getattr(task_context, "file_count", 0)
+                _deps = ", ".join((getattr(task_context, "dependencies", []) or [])[:6]) or "none"
+                project_hint = (
+                    f"\nProject Context: type={_pt}, frameworks={_fw}, "
+                    f"files={_fc}, key_deps={_deps}"
+                )
+
             messages = [
                 {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": f"User Task:\n{task.strip()}"},
+                {"role": "user", "content": f"User Task:\n{task.strip()}{project_hint}"},
             ]
 
             # Invoke backend with enable_thinking=False for ultra-fast, deterministic response

{alpiecode-8.0.6 → alpiecode-8.0.7}/src/codeagent/session.py

@@ -64,6 +64,7 @@ class SessionManager:
                 "workdir": str(s.workdir),
                 "created_at": s.created_at,
                 "estimated_tokens": s.context.estimate_tokens(),
+                "total_history_tokens": getattr(s.context, "estimate_total_tokens", s.context.estimate_tokens)(),
             }
             for s in self._sessions.values()
         ]

alpiecode-8.0.6/src/codeagent/context.py

@@ -1,106 +0,0 @@
-"""
-Conversation context manager for AlpieCode.
-
-Manages the list of messages in a conversation session, tracking estimated tokens
-and performing compaction when context limits are approached.
-"""
-
-from typing import Any, Dict, List, Optional
-
-from .backends.base import ChatResponse, ToolCall
-from .compaction import compact_messages, estimate_tokens, needs_compaction
-
-
-def _serialize_assistant_message(msg: ChatResponse) -> dict:
-    """Serialize a ChatResponse into OpenAI chat message dict format."""
-    result = {"role": "assistant"}
-    result["content"] = msg.content if msg.content else None
-
-    if msg.tool_calls:
-        import json
-        result["tool_calls"] = [
-            {
-                "id": tc.id,
-                "type": "function",
-                "function": {
-                    "name": tc.name,
-                    "arguments": json.dumps(tc.arguments) if isinstance(tc.arguments, dict) else tc.arguments,
-                },
-            }
-            for tc in msg.tool_calls
-        ]
-    return result
-
-
-class ContextManager:
-    """Manages session messages and context window token budgeting."""
-
-    def __init__(self, max_tokens: int = 262_144):
-        self.max_tokens = max_tokens
-        self._messages: List[dict] = []
-
-    def rolling_compact_old_tools(self, keep_last_turns: int = 3) -> None:
-        """Truncate large historical tool outputs from turns older than keep_last_turns."""
-        assistant_indices = [
-            i for i, m in enumerate(self._messages)
-            if isinstance(m, dict) and m.get("role") == "assistant"
-        ]
-        if len(assistant_indices) <= keep_last_turns:
-            return
-
-        cutoff_idx = assistant_indices[-keep_last_turns]
-        for i in range(cutoff_idx):
-            msg = self._messages[i]
-            if isinstance(msg, dict) and msg.get("role") == "tool":
-                content = str(msg.get("content", ""))
-                # Never truncate update_plan output
-                if "[Plan updated]" in content or len(content) <= 300:
-                    continue
-                lines = content.splitlines()
-                if len(lines) > 8:
-                    preview_start = "\n".join(lines[:3])
-                    preview_end = "\n".join(lines[-2:])
-                    msg["content"] = f"[Output: {len(lines)} lines truncated for brevity]\n{preview_start}\n...\n{preview_end}" 
-                else:
-                    msg["content"] = content[:150] + f"... [truncated {len(content)} chars]"
-
-    @property
-    def messages(self) -> List[dict]:
-        self.rolling_compact_old_tools(keep_last_turns=3)
-        return self._messages
-
-
-    @messages.setter
-    def messages(self, msgs: List[dict]) -> None:
-        self._messages = msgs
-
-    def set_system_prompt(self, prompt: str) -> None:
-        if self._messages and self._messages[0].get("role") == "system":
-            self._messages[0]["content"] = prompt
-        else:
-            self._messages.insert(0, {"role": "system", "content": prompt})
-
-    def add_user_message(self, content: Any) -> None:
-        self._messages.append({"role": "user", "content": content})
-
-    def add_assistant_response(self, response: ChatResponse) -> None:
-        if response.tool_calls or response.content:
-            serialized = _serialize_assistant_message(response)
-            self._messages.append(serialized)
-
-    def add_tool_result(self, tool_call_id: str, content: str) -> None:
-        self._messages.append({
-            "role": "tool",
-            "tool_call_id": tool_call_id,
-            "content": content,
-        })
-
-    def estimate_tokens(self) -> int:
-        return estimate_tokens(self._messages)
-
-    def check_and_compact(self) -> bool:
-        """Compact context if approaching limit. Returns True if compaction occurred."""
-        if needs_compaction(self._messages, max_tokens=self.max_tokens):
-            self._messages = compact_messages(self._messages)
-            return True
-        return False