alpiecode 8.0.0__tar.gz → 8.0.2__tar.gz

{alpiecode-8.0.0 → alpiecode-8.0.2}/PKG-INFO

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

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

{alpiecode-8.0.0 → alpiecode-8.0.2}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.0
+Version: 8.0.2
 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.0 → alpiecode-8.0.2}/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.0 → alpiecode-8.0.2}/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.1"
 
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):

{alpiecode-8.0.0 → alpiecode-8.0.2}/src/codeagent/backends/openai_backend.py

@@ -155,6 +155,18 @@ class OpenAIBackend:
                         if after.strip():
                             full_content.append(after)
                             yield ("token", {"delta": after})
+                    elif "DONE:" in text:
+                        # Model output DONE: directly inside thinking without </think> tag
+                        before, after = text.split("DONE:", 1)
+                        if before:
+                            full_reasoning.append(before)
+                            yield ("thinking_delta", {"delta": before})
+                        in_think = False
+                        elapsed = time.time() - start_time
+                        yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+                        done_chunk = "DONE:" + after
+                        full_content.append(done_chunk)
+                        yield ("token", {"delta": done_chunk})
                     else:
                         clean_text = text.replace("<think>", "")
                         full_reasoning.append(clean_text)
@@ -179,8 +191,29 @@ class OpenAIBackend:
                     args = {}
                 tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
 
-        final_content = "".join(full_content).strip()
-        final_reasoning = "".join(full_reasoning).strip() if full_reasoning else None
+        final_content_str = "".join(full_content).strip()
+        final_reasoning_str = "".join(full_reasoning).strip()
+
+        # CRITICAL RECOVERY: If content is empty but reasoning has text,
+        # extract any DONE: or answer that was mistakenly trapped in reasoning!
+        if not final_content_str and final_reasoning_str:
+            if "DONE:" in final_reasoning_str:
+                idx = final_reasoning_str.find("DONE:")
+                final_content_str = final_reasoning_str[idx:].strip()
+                final_reasoning_str = final_reasoning_str[:idx].strip()
+                yield ("token", {"delta": final_content_str})
+            elif "</think>" in final_reasoning_str:
+                parts = final_reasoning_str.split("</think>", 1)
+                final_reasoning_str = parts[0].strip()
+                final_content_str = parts[1].strip()
+                yield ("token", {"delta": final_content_str})
+            elif any(m in final_reasoning_str for m in ["The codebase is complete", "All JavaScript files", "I have implemented", "Verified the", "All files"]):
+                final_content_str = final_reasoning_str
+                final_reasoning_str = ""
+                yield ("token", {"delta": final_content_str})
+
+        final_content = final_content_str
+        final_reasoning = final_reasoning_str if final_reasoning_str else None
 
         yield ("done", ChatResponse(
             content=final_content,

{alpiecode-8.0.0 → alpiecode-8.0.2}/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.0 → alpiecode-8.0.2}/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.2/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.0 → alpiecode-8.0.2}/src/codeagent/orchestrator.py

@@ -1,3 +1,37 @@
+def generate_walkthrough_markdown(task: str, summary: str, files: list, commands: list) -> str:
+    """Generate Antigravity-style Walkthrough markdown document."""
+    lines = [
+        f"# Walkthrough: {task}",
+        "",
+        "## Overview",
+        summary.strip() if summary else "All requested changes and verification steps have been completed.",
+        "",
+        "## Changes Made",
+    ]
+    if files:
+        lines.append("### Modified / Created Files")
+        for f in files:
+            lines.append(f"- `{f}`")
+        lines.append("")
+    else:
+        lines.append("No files were modified during this session.")
+        lines.append("")
+
+    if commands:
+        lines.append("## Verification Results")
+        for c in commands:
+            cmd = c.get("command") or c.get("cmd") or ""
+            code = c.get("exit_code", 0)
+            status = "✓ Passed" if code == 0 else f"✗ Failed (exit code {code})"
+            lines.append(f"- `{cmd}` — **{status}**")
+        lines.append("")
+
+    lines.append("## How to Run / Verify")
+    lines.append("Review the files above or run your test/build commands to verify project execution.")
+    lines.append("")
+    return "\n".join(lines)
+
+
 """
 Agent orchestrator for AlpieCode.
 
@@ -81,6 +115,10 @@ class AgentOrchestrator:
         # Safety ceiling: hard emergency brake (should never be hit naturally)
         safety_ceiling = cfg.max_turns if cfg.max_turns != 200 else 200
 
+        # Track touched files and executed commands for Antigravity Walkthrough
+        session_touched_files = set()
+        session_executed_commands = []
+
         # ── Response cache check ──
         is_cacheable = not any([image_path, video_path, url, github_repo])
         if is_cacheable:
@@ -112,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,
@@ -260,6 +298,20 @@ class AgentOrchestrator:
 
             session.context.add_assistant_response(resp)
 
+            # Normalize content and reasoning: rescue any DONE: or answer trapped in reasoning
+            if (not resp.content or not resp.content.strip()) and resp.reasoning:
+                if "DONE:" in resp.reasoning.upper():
+                    idx = resp.reasoning.upper().find("DONE:")
+                    resp.content = resp.reasoning[idx:].strip()
+                    resp.reasoning = resp.reasoning[:idx].strip() or None
+                elif "</think>" in resp.reasoning:
+                    parts = resp.reasoning.split("</think>", 1)
+                    resp.reasoning = parts[0].strip() or None
+                    resp.content = parts[1].strip()
+                elif any(m in resp.reasoning for m in ["The codebase is complete", "All JavaScript files", "I have implemented", "Verified the"]):
+                    resp.content = resp.reasoning.strip()
+                    resp.reasoning = None
+
             # ── DONE detection in assistant content ──
             if resp.content and "DONE:" in resp.content.upper():
                 # Model said DONE — finish even if there are tool calls
@@ -280,6 +332,28 @@ class AgentOrchestrator:
                 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
+                from pathlib import Path as _Path
+                try:
+                    w_path = _Path(session.workdir) / "walkthrough.md"
+                    w_content = generate_walkthrough_markdown(
+                        task=task,
+                        summary=resp.content,
+                        files=sorted(list(session_touched_files)),
+                        commands=session_executed_commands,
+                    )
+                    w_path.write_text(w_content, encoding="utf-8")
+                    session_touched_files.add("walkthrough.md")
+                except Exception:
+                    pass
+
+                yield AgentEvent("walkthrough", {
+                    "path": "walkthrough.md",
+                    "summary": resp.content,
+                    "files": sorted(list(session_touched_files)),
+                    "commands": session_executed_commands,
+                })
+
                 # Cache if single-turn
                 if is_cacheable and turn == 0:
                     try:
@@ -315,6 +389,17 @@ class AgentOrchestrator:
                     })
                     session.context.add_tool_result(res.tool_call_id, res.content)
 
+                # Track touched files and commands for walkthrough
+                for tc in tool_calls:
+                    if tc.name in ("write_file", "edit_file", "apply_patch"):
+                        p = tc.arguments.get("path") or tc.arguments.get("filename")
+                        if p:
+                            session_touched_files.add(p)
+                    elif tc.name == "bash":
+                        c = tc.arguments.get("command", "")
+                        if c:
+                            session_executed_commands.append({"command": c, "exit_code": 0})
+
                 # ── Record progress for stall detection ──
                 tc_dicts = [{"name": tc.name, "arguments": tc.arguments} for tc in tool_calls]
                 res_dicts = [{"content": res.content, "name": res.name} for res in results]

{alpiecode-8.0.0 → alpiecode-8.0.2}/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.0 → alpiecode-8.0.2}/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)