alpiecode 8.0.1__tar.gz → 8.0.3__tar.gz

{alpiecode-8.0.1 → alpiecode-8.0.3}/PKG-INFO

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

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

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/alpiecode.egg-info/PKG-INFO

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

@@ -21,6 +21,7 @@ src/codeagent/executor.py
 src/codeagent/git_ops.py
 src/codeagent/github.py
 src/codeagent/guardian.py
+src/codeagent/guardrails.py
 src/codeagent/ipython_ext.py
 src/codeagent/local_model.py
 src/codeagent/media.py

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/__init__.py

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

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/context.py

@@ -39,10 +39,37 @@ class ContextManager:
         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

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/executor.py

@@ -171,62 +171,103 @@ class ToolExecutor:
                 tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
             )
 
-        # Stage 2: Sequential mutating tools (write_file, edit_file, bash)
-        for tc in mut_calls:
-            if on_tool_start:
-                on_tool_start(tc.name, tc.arguments)
-            t0 = time.monotonic()
-            safe_args = tc.arguments if isinstance(tc.arguments, dict) else {}
-            fn = self.dispatch.get(tc.name)
-            if fn:
-                try:
-                    res_str = str(fn(safe_args))
-                except Exception as e:
-                    res_str = f"error: {e}"
-            else:
-                res_str = f"error: Unknown tool '{tc.name}'"
-            elapsed = (time.monotonic() - t0) * 1000
-
-            # Tool loop detection guard
-            call_sig = (tc.name, json.dumps(tc.arguments, sort_keys=True))
-            self.tool_call_history.append(call_sig)
-            repeat_count = sum(1 for item in self.tool_call_history[-5:] if item == call_sig)
-
-            if repeat_count >= 3:
-                res_str += (
-                    f"\n\n🛑 REPEATED TOOL CALL LOOP DETECTED (attempt #{repeat_count}). "
-                    f"You have already executed '{tc.name}' with these exact parameters {repeat_count} times in a row. "
-                    "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
-                )
+        # Stage 2: Mutating tools (parallel write_file if distinct paths, otherwise sequential)
+        all_writes = all(tc.name == "write_file" for tc in mut_calls)
+        paths = [
+            tc.arguments.get("path") if isinstance(tc.arguments, dict) else None
+            for tc in mut_calls
+        ]
+        can_parallel_write = (
+            all_writes
+            and len(mut_calls) > 1
+            and len(paths) == len(set(paths))
+            and None not in paths
+        )
+
+        if can_parallel_write:
+            with ThreadPoolExecutor(max_workers=min(4, len(mut_calls))) as pool:
+                future_to_tc = {}
+                for tc in mut_calls:
+                    if on_tool_start:
+                        on_tool_start(tc.name, tc.arguments)
+                    t0 = time.monotonic()
+                    safe_args = tc.arguments if isinstance(tc.arguments, dict) else {}
+                    fn = self.dispatch.get(tc.name)
+                    if fn:
+                        future = pool.submit(fn, safe_args)
+                    else:
+                        future = pool.submit(lambda: f"error: Unknown tool '{tc.name}'")
+                    future_to_tc[future] = (tc, t0)
 
-            # Compilation failure recovery hint
-            if tc.name == "bash":
-                cmd = tc.arguments.get("command", "") if isinstance(tc.arguments, dict) else ""
-                is_compile = any(kw in cmd for kw in ["g++", "gcc", "clang", "make", "cmake", "cargo build", "rustc"])
-                if is_compile and "exit_code" in str(res_str):
+                for future in as_completed(future_to_tc):
+                    tc, t0 = future_to_tc[future]
+                    elapsed = (time.monotonic() - t0) * 1000
                     try:
-                        result_data = json.loads(res_str.split("\n", 1)[-1] if res_str.startswith("⚠️") else res_str)
-                        if result_data.get("exit_code", 0) != 0:
-                            compile_key = cmd.strip()
-                            self.compile_fail_counts[compile_key] = self.compile_fail_counts.get(compile_key, 0) + 1
-                            if self.compile_fail_counts[compile_key] >= 3:
-                                res_str += (
-                                    "\n\n🛑 REPEATED COMPILATION FAILURE (attempt "
-                                    f"#{self.compile_fail_counts[compile_key]}). "
-                                    "STOP making blind edits. Re-read the ENTIRE source file with "
-                                    "read_file to understand its full structure, then fix ALL errors "
-                                    "comprehensively in one edit."
-                                )
-                        else:
-                            self.compile_fail_counts.pop(cmd.strip(), None)
-                    except (json.JSONDecodeError, ValueError):
-                        pass
+                        res_str = str(future.result())
+                    except Exception as e:
+                        res_str = f"error: {e}"
+                    if on_tool_end:
+                        on_tool_end(tc.name, res_str)
+                    results_map[tc.id] = ToolResult(
+                        tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
+                    )
+        else:
+            # Stage 2: Sequential mutating tools (write_file, edit_file, bash)
+            for tc in mut_calls:
+                if on_tool_start:
+                    on_tool_start(tc.name, tc.arguments)
+                t0 = time.monotonic()
+                safe_args = tc.arguments if isinstance(tc.arguments, dict) else {}
+                fn = self.dispatch.get(tc.name)
+                if fn:
+                    try:
+                        res_str = str(fn(safe_args))
+                    except Exception as e:
+                        res_str = f"error: {e}"
+                else:
+                    res_str = f"error: Unknown tool '{tc.name}'"
+                elapsed = (time.monotonic() - t0) * 1000
+
+                # Tool loop detection guard
+                call_sig = (tc.name, json.dumps(tc.arguments, sort_keys=True))
+                self.tool_call_history.append(call_sig)
+                repeat_count = sum(1 for item in self.tool_call_history[-5:] if item == call_sig)
+
+                if repeat_count >= 3:
+                    res_str += (
+                        f"\n\n🛑 REPEATED TOOL CALL LOOP DETECTED (attempt #{repeat_count}). "
+                        f"You have already executed '{tc.name}' with these exact parameters {repeat_count} times in a row. "
+                        "All checks have passed. Do NOT run this tool again. Output your final summary starting with: DONE: <summary>."
+                    )
 
-            if on_tool_end:
-                on_tool_end(tc.name, res_str)
-            results_map[tc.id] = ToolResult(
-                tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
-            )
+                # Compilation failure recovery hint
+                if tc.name == "bash":
+                    cmd = tc.arguments.get("command", "") if isinstance(tc.arguments, dict) else ""
+                    is_compile = any(kw in cmd for kw in ["g++", "gcc", "clang", "make", "cmake", "cargo build", "rustc"])
+                    if is_compile and "exit_code" in str(res_str):
+                        try:
+                            result_data = json.loads(res_str.split("\n", 1)[-1] if res_str.startswith("⚠️") else res_str)
+                            if result_data.get("exit_code", 0) != 0:
+                                compile_key = cmd.strip()
+                                self.compile_fail_counts[compile_key] = self.compile_fail_counts.get(compile_key, 0) + 1
+                                if self.compile_fail_counts[compile_key] >= 3:
+                                    res_str += (
+                                        "\n\n🛑 REPEATED COMPILATION FAILURE (attempt "
+                                        f"#{self.compile_fail_counts[compile_key]}). "
+                                        "STOP making blind edits. Re-read the ENTIRE source file with "
+                                        "read_file to understand its full structure, then fix ALL errors "
+                                        "comprehensively in one edit."
+                                    )
+                            else:
+                                self.compile_fail_counts.pop(cmd.strip(), None)
+                        except (json.JSONDecodeError, ValueError):
+                            pass
+
+                if on_tool_end:
+                    on_tool_end(tc.name, res_str)
+                results_map[tc.id] = ToolResult(
+                    tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed
+                )
 
         return [results_map[tc.id] for tc in tool_calls if tc.id in results_map]
 

alpiecode-8.0.3/src/codeagent/guardrails.py

@@ -0,0 +1,135 @@
+"""
+Pre-Commit AST & Syntax Guardrail for AlpieCode.
+
+Validates code syntax before writing to disk, ensuring that corrupt code,
+unclosed brackets, indentation errors, or syntax mistakes are caught and
+can be self-healed in-place without breaking the user workspace.
+"""
+
+import ast
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple
+
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+def validate_code_syntax(file_path: str, content: str) -> Tuple[bool, Optional[str]]:
+    """
+    Validate the syntax of code content for a given file path.
+    Returns (is_valid, error_message_if_any).
+    """
+    if not content or not content.strip():
+        return True, None
+
+    ext = Path(file_path).suffix.lower()
+
+    # 1. Python AST Validation
+    if ext == ".py":
+        try:
+            ast.parse(content, filename=file_path)
+            return True, None
+        except SyntaxError as e:
+            line = e.lineno or 0
+            col = e.offset or 0
+            text_line = e.text.strip() if e.text else ""
+            err_msg = (
+                f"SyntaxError in '{file_path}' at line {line}, col {col}: {e.msg}.\n"
+                f"Offending line: {text_line}\n"
+                "Please fix this syntax error."
+            )
+            return False, err_msg
+        except Exception as e:
+            return False, f"Syntax parsing error in '{file_path}': {e}"
+
+    # 2. JSON Validation
+    if ext == ".json":
+        try:
+            json.loads(content)
+            return True, None
+        except Exception as e:
+            return False, f"Invalid JSON in '{file_path}': {e}"
+
+    # 3. TOML Validation
+    if ext == ".toml" and tomllib:
+        try:
+            tomllib.loads(content)
+            return True, None
+        except Exception as e:
+            return False, f"Invalid TOML in '{file_path}': {e}"
+
+    # 4. JavaScript / TypeScript Validation
+    if ext in (".js", ".mjs", ".cjs"):
+        node_bin = shutil.which("node")
+        if node_bin:
+            try:
+                res = subprocess.run(
+                    [node_bin, "--check", "-"],
+                    input=content,
+                    text=True,
+                    capture_output=True,
+                    timeout=3
+                )
+                if res.returncode != 0:
+                    err = res.stderr.strip() or "Syntax error in JavaScript code"
+                    return False, f"JavaScript SyntaxError in '{file_path}': {err}"
+            except Exception:
+                pass
+
+        # Fallback lexical check for bracket balance
+        is_balanced, balance_err = check_bracket_balance(content)
+        if not is_balanced:
+            return False, f"Syntax issue in '{file_path}': {balance_err}"
+        return True, None
+
+    return True, None
+
+
+def check_bracket_balance(code: str) -> Tuple[bool, Optional[str]]:
+    """Fast lexical check for unclosed brackets or strings in code."""
+    stack = []
+    pairs = {")": "(", "}": "{", "]": "["}
+    in_string = False
+    quote_char = ""
+    escaped = False
+
+    lines = code.split("\n")
+    for line_idx, line in enumerate(lines, 1):
+        for char_idx, ch in enumerate(line, 1):
+            if in_string:
+                if escaped:
+                    escaped = False
+                elif ch == "\\":
+                    escaped = True
+                elif ch == quote_char:
+                    in_string = False
+                continue
+
+            if ch in ("'", '"', '`'):
+                in_string = True
+                quote_char = ch
+                continue
+
+            if ch in ("(", "{", "["):
+                stack.append((ch, line_idx, char_idx))
+            elif ch in (")", "}", "]"):
+                if not stack:
+                    return False, f"Unexpected closing bracket '{ch}' at line {line_idx}:{char_idx}"
+                top, t_line, t_col = stack.pop()
+                if pairs[ch] != top:
+                    return False, f"Mismatched bracket: opened '{top}' at line {t_line}:{t_col} but closed with '{ch}' at line {line_idx}:{char_idx}"
+
+    if stack:
+        top, t_line, t_col = stack[-1]
+        return False, f"Unclosed bracket '{top}' opened at line {t_line}:{t_col}"
+
+    return True, None

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/orchestrator.py

@@ -150,7 +150,7 @@ class AgentOrchestrator:
         session.is_offline = is_offline
 
         # ── Configure tools & system prompt based on complexity ──
-        active_tools = self.prompt_builder.get_tools(is_offline=is_offline, complexity=complexity)
+        active_tools = self.prompt_builder.get_tools(is_offline=is_offline, complexity=complexity, task_context=task_context)
         system_prompt = self.prompt_builder.build_system_prompt(
             session.workdir, is_offline=is_offline, complexity=complexity,
             task_context=task_context,
@@ -329,7 +329,17 @@ class AgentOrchestrator:
                         })
                         session.context.add_tool_result(res.tool_call_id, res.content)
 
-                yield AgentEvent("message", {"content": resp.content})
+                if resp.content:
+                    # Clean duplicate DONE: if repeated
+                    if resp.content.upper().count("DONE:") > 1:
+                        parts = re.split(r"(?i)\bDONE:\s*", resp.content)
+                        if len(parts) >= 3 and parts[1].strip() == parts[2].strip():
+                            resp.content = parts[0] + "DONE: " + parts[1].strip()
+
+                # Only yield 'message' if tokens were NOT already streamed chunk-by-chunk
+                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)
 
                 # Generate and write real walkthrough.md file to the project workspace
@@ -423,7 +433,17 @@ class AgentOrchestrator:
                     except Exception:
                         pass
 
-                yield AgentEvent("message", {"content": resp.content})
+                if resp.content:
+                    # Clean duplicate DONE: if repeated
+                    if resp.content.upper().count("DONE:") > 1:
+                        parts = re.split(r"(?i)\bDONE:\s*", resp.content)
+                        if len(parts) >= 3 and parts[1].strip() == parts[2].strip():
+                            resp.content = parts[0] + "DONE: " + parts[1].strip()
+
+                # Only yield 'message' if tokens were NOT already streamed chunk-by-chunk
+                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)
                 yield AgentEvent("done", {"summary": resp.content})
                 return

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/prompt.py

@@ -551,9 +551,13 @@ class PromptBuilder:
         self,
         is_offline: bool = False,
         complexity: str = "low",
+        task_context=None,
     ) -> List[dict]:
         if complexity == "qa":
             return []  # No tools for Q&A
+        if task_context is not None:
+            if getattr(task_context, "tool_set", None) == "none" or getattr(task_context, "intent", None) in ("qa", "explain"):
+                return []
         if is_offline:
             return OFFLINE_TOOLS
         if complexity in ("medium", "high"):

{alpiecode-8.0.1 → alpiecode-8.0.3}/src/codeagent/tools.py

@@ -1,3 +1,4 @@
+from .guardrails import validate_code_syntax
 _RECENTLY_WRITTEN_FILES = set()
 
 """
@@ -519,6 +520,11 @@ def _read_file(workdir: Path, path: str, start_line: int = None, end_line: int =
 
 
 def _write_file(workdir: Path, path: str, content: str) -> str:
+    # Pre-commit AST syntax check to prevent writing corrupt code
+    is_valid, err = validate_code_syntax(path, content)
+    if not is_valid:
+        return f"error: Pre-commit syntax check failed for '{path}':\n{err}\nPlease fix the syntax error before writing."
+
     p = workdir / path
     p.parent.mkdir(parents=True, exist_ok=True)
     p.write_text(content, encoding="utf-8")
@@ -532,23 +538,53 @@ def _edit_file(workdir: Path, path: str, old_str: str, new_str: str) -> str:
         return f"error: file not found: {path}"
     text = p.read_text(encoding="utf-8", errors="replace")
     count = text.count(old_str)
-    if count == 0:
-        import difflib
-        lines = text.splitlines()
-        old_lines = [ol.strip() for ol in old_str.splitlines() if ol.strip()]
-        target_line = old_lines[0] if old_lines else old_str.strip()
-        close_matches = difflib.get_close_matches(target_line, [l.strip() for l in lines], n=3, cutoff=0.3)
-        nearby = [(i + 1, l) for i, l in enumerate(lines) if l.strip() in close_matches]
-        hint = ""
-        if nearby:
-            hint = "\nClosest matching lines in file:\n" + "\n".join(f"  Line {n}: {l.strip()[:80]}" for n, l in nearby[:3])
-        return (
-            f"error: old_str not found in file '{path}'. It must match existing text EXACTLY (including whitespace/indentation).{hint}\n"
-            f"→ Action: Run read_file on '{path}' around these lines to see the exact whitespace, then retry edit_file."
-        )
-    if count > 1:
+
+    if count == 1:
+        new_text = text.replace(old_str, new_str, 1)
+    elif count > 1:
         return f"error: old_str matched {count} times in '{path}'. Must match exactly 1 occurrence. Include more surrounding lines in old_str to make it unique."
-    p.write_text(text.replace(old_str, new_str, 1), encoding="utf-8")
+    else:
+        # Whitespace-tolerant fuzzy block matching
+        import difflib
+        lines = text.splitlines(keepends=True)
+        old_lines = old_str.splitlines(keepends=True)
+        n_old = len(old_lines)
+        best_ratio = 0.0
+        best_idx = -1
+
+        norm_old = "".join(l.strip() for l in old_lines)
+
+        for i in range(len(lines) - n_old + 1):
+            window = lines[i:i + n_old]
+            norm_win = "".join(l.strip() for l in window)
+            ratio = difflib.SequenceMatcher(None, norm_win, norm_old).ratio()
+            if ratio > best_ratio:
+                best_ratio = ratio
+                best_idx = i
+
+        if best_ratio >= 0.85 and best_idx >= 0:
+            # Fuzzy match found with high confidence
+            new_lines_slice = new_str.splitlines(keepends=True)
+            new_text = "".join(lines[:best_idx] + new_lines_slice + lines[best_idx + n_old:])
+        else:
+            old_stripped = [ol.strip() for ol in old_lines if ol.strip()]
+            target_line = old_stripped[0] if old_stripped else old_str.strip()
+            close_matches = difflib.get_close_matches(target_line, [l.strip() for l in lines], n=3, cutoff=0.3)
+            nearby = [(i + 1, l) for i, l in enumerate(lines) if l.strip() in close_matches]
+            hint = ""
+            if nearby:
+                hint = "\nClosest matching lines in file:\n" + "\n".join(f"  Line {n}: {l.strip()[:80]}" for n, l in nearby[:3])
+            return (
+                f"error: old_str not found in file '{path}'.{hint}\n"
+                f"→ Action: Run read_file on '{path}' around these lines, then retry edit_file."
+            )
+
+    # Post-edit syntax validation
+    is_valid, err = validate_code_syntax(path, new_text)
+    if not is_valid:
+        return f"error: Edit would result in a syntax error in '{path}':\n{err}\nPlease revise the replacement."
+
+    p.write_text(new_text, encoding="utf-8")
     return "edit applied"
 
 
@@ -590,19 +626,29 @@ def _list_files(workdir: Path, path: str = ".", max_depth: int = 4) -> str:
 
 def _file_search(workdir: Path, pattern: str, path: str = ".", include: str = None,
                  case_insensitive: bool = False) -> str:
-    """Search for a pattern across files using grep."""
+    """Search for a pattern across files using ripgrep (rg) or grep."""
     target = workdir / path
-
-    # Build grep command
-    cmd = ["grep", "-rn", "--color=never"]
-    if case_insensitive:
-        cmd.append("-i")
-    if include:
-        cmd.extend(["--include", include])
-    # Exclude common non-code directories
-    for excl in [".git", "node_modules", "__pycache__", ".venv", "venv", ".egg-info"]:
-        cmd.extend(["--exclude-dir", excl])
-    cmd.extend([pattern, str(target)])
+    import shutil
+
+    rg_bin = shutil.which("rg")
+    if rg_bin:
+        cmd = [rg_bin, "--no-heading", "--line-number", "--color=never"]
+        if case_insensitive:
+            cmd.append("-i")
+        if include:
+            cmd.extend(["-g", include])
+        cmd.extend(["--hidden", "--glob", "!.git/*", "--glob", "!node_modules/*", "--glob", "!.venv/*"])
+        cmd.extend(["-e", pattern, str(target)])
+    else:
+        # Fallback to grep
+        cmd = ["grep", "-rn", "--color=never"]
+        if case_insensitive:
+            cmd.append("-i")
+        if include:
+            cmd.extend(["--include", include])
+        for excl in [".git", "node_modules", "__pycache__", ".venv", "venv", ".egg-info"]:
+            cmd.extend(["--exclude-dir", excl])
+        cmd.extend([pattern, str(target)])
 
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=30, cwd=workdir)