alpiecode 10.5.2__tar.gz → 10.5.3__tar.gz

{alpiecode-10.5.2 → alpiecode-10.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.2
+Version: 10.5.3
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.5.2 → alpiecode-10.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.5.2"
+version = "10.5.3"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.5.2
+Version: 10.5.3
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/alpiecode.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/codeagent/session.py
 src/codeagent/system1.py
 src/codeagent/tools.py
 src/codeagent/updater.py
+src/codeagent/verifier.py
 src/codeagent/vscode_installer.py
 src/codeagent/backends/__init__.py
 src/codeagent/backends/base.py
@@ -46,4 +47,5 @@ src/codeagent/backends/openai_backend.py
 src/codeagent/extension/alpiecode.vsix
 test/test_context_and_trajectory.py
 test/test_dream_rsi.py
-test/test_task_assessment.py
+test/test_task_assessment.py
+test/test_verifier.py

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/codeagent/__init__.py

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

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/codeagent/orchestrator.py

@@ -334,7 +334,11 @@ class AgentOrchestrator:
             base_enable_thinking = task_context.enable_thinking
 
         task_metrics.record_context_prep((time.time() - ctx_prep_start) * 1000.0)
-        # ── Goal-driven turn loop (no fixed limit) ──
+        # Extract explicitly named deliverable files from task prompt (e.g. auth.py, test_auth.py)
+        named_deliverables = list(dict.fromkeys(
+            re.findall(r"\b([a-zA-Z0-9_\-]+\.(?:py|js|ts|html|css|json|toml|sh))\b", task)
+        ))
+
         progress_monitor = ProgressMonitor()
         turn = 0
         prior_turn_had_error = False
@@ -368,6 +372,9 @@ class AgentOrchestrator:
             # ── Stall Detection & Corrective Intervention ──
             if progress_monitor.is_stalled(threshold=3):
                 advice = progress_monitor.get_stall_advice()
+                uncreated = [f for f in named_deliverables if f not in session_touched_files]
+                if uncreated:
+                    advice += f"\nNote: The following files requested in the task have not been created yet: {', '.join(uncreated)}. Create them now using write_file."
                 session.context.add_user_message(advice)
                 yield AgentEvent("stall_intervention", {
                     "turn": turn,
@@ -675,97 +682,58 @@ class AgentOrchestrator:
                 verify_attempts = getattr(session, "_auto_verify_attempts", 0)
 
                 if has_code_files and not auto_verify_passed and verify_attempts < 2:
-                    # 1. In-process Python syntax verification for all modified Python files
-                    syntax_errs = []
-                    for tf in session_touched_files:
-                        if tf.endswith(".py"):
-                            full_tf = session.workdir / tf
-                            if full_tf.exists():
-                                try:
-                                    import ast as _ast
-                                    _ast.parse(full_tf.read_text(encoding="utf-8", errors="replace"))
-                                except SyntaxError as se:
-                                    syntax_errs.append(f"- '{tf}' line {se.lineno}: {se.msg}")
-
-                    if syntax_errs:
+                    from .verifier import IntelligentVerificationEngine, format_replan_directive
+                    v_engine = IntelligentVerificationEngine(session.workdir)
+
+                    events_queue = []
+                    v_res = v_engine.run_full_verification(
+                        task=task,
+                        session_touched_files=session_touched_files,
+                        task_context=task_context,
+                        run_bash_fn=session.executor.dispatch.get("bash", lambda a: ""),
+                        is_offline=is_offline,
+                        successful_commands=getattr(session.executor, "successful_bash_commands", None),
+                        events_queue=events_queue,
+                    )
+
+                    for ev_name, ev_data in events_queue:
+                        yield AgentEvent(ev_name, ev_data)
+
+                    if not v_res.passed:
                         session._auto_verify_attempts = verify_attempts + 1
-                        err_msg = "\n".join(syntax_errs)
-                        session.context.add_user_message(
-                            f"[VERIFICATION FAILED -> RE-PLAN & REASON]\nSyntax error(s) detected in your code:\n{err_msg}\n\n"
-                            "Reasoning Path Directive:\n"
-                            "1. Analyze why these syntax errors occurred.\n"
-                            "2. Re-plan the fix.\n"
-                            "3. Use edit_file to apply the corrected code.\n"
-                            "4. Verify before marking DONE."
-                        )
-                        yield AgentEvent("verification_failed", {
-                            "type": "syntax",
-                            "errors": syntax_errs,
-                        })
-                        yield AgentEvent("replan", {
+                        replan_prompt = format_replan_directive(v_res, is_offline=is_offline)
+                        session.context.add_user_message(replan_prompt)
+
+                        v_type = "syntax" if v_res.tier == "syntax" else ("tests" if "test" in v_res.tier else v_res.tier)
+                        v_event_data = {
+                            "type": v_type,
+                            "tier": v_res.tier,
+                            "error_type": v_res.error_type,
+                            "message": v_res.message,
+                            "failing_file": v_res.failing_file,
+                        }
+                        if v_res.errors:
+                            v_event_data["errors"] = v_res.errors
+                        if v_res.command:
+                            v_event_data["command"] = v_res.command
+                            v_event_data["exit_code"] = v_res.exit_code
+                        yield AgentEvent("verification_failed", v_event_data)
+
+                        replan_trigger = "syntax_errors" if v_res.tier == "syntax" else ("test_failure" if "test" in v_res.tier else f"{v_res.tier}_failure")
+                        replan_data = {
                             "turn": turn,
                             "strategy": strategy,
-                            "trigger": "syntax_errors",
-                            "details": syntax_errs,
-                        })
+                            "trigger": replan_trigger,
+                            "details": v_res.errors or v_res.message,
+                        }
+                        if v_res.command:
+                            replan_data["command"] = v_res.command
+                            replan_data["exit_code"] = v_res.exit_code
+                        yield AgentEvent("replan", replan_data)
+
                         prior_turn_had_error = True
                         continue
 
-                    # 2. Automated test verification if project has tests
-                    if task_context.has_tests and not getattr(session, "_has_run_tests_in_session", False):
-                        session._auto_verify_attempts = verify_attempts + 1
-                        session._has_run_tests_in_session = True
-                        test_cmd = "python3 -m pytest -q --tb=short" if task_context.project_type == "python" else "npm test" if task_context.project_type == "node" else None
-                        if test_cmd:
-                            yield AgentEvent("status", {
-                                "phase": "verifying",
-                                "message": f"Auto-running verification test suite ({test_cmd})...",
-                            })
-                            t_res = session.executor.dispatch.get("bash", lambda a: "")({"command": test_cmd})
-                            t_exit = 0
-                            try:
-                                import json as _json
-                                json_str = t_res
-                                if "{" in json_str:
-                                    json_str = json_str[json_str.find("{"):]
-                                t_data = _json.loads(json_str)
-                                t_exit = t_data.get("exit_code", 0)
-                                t_out = t_data.get("stdout", "")
-                                if t_data.get("stderr"):
-                                    t_out += "\n" + t_data.get("stderr")
-                            except Exception:
-                                t_out = str(t_res)
-                                if "exit_code=" in t_res:
-                                    import re as _re
-                                    m = _re.search(r"exit_code=(\d+)", t_res)
-                                    if m:
-                                        t_exit = int(m.group(1))
-
-                            if t_exit != 0:
-                                session.context.add_user_message(
-                                    f"[VERIFICATION FAILED -> RE-PLAN & REASON]\nTest suite failed (exit_code={t_exit}) after your changes:\n"
-                                    f"{t_out[:1200]}\n\n"
-                                    "Reasoning Path Directive:\n"
-                                    "1. Diagnose the root cause of the test failure.\n"
-                                    "2. Re-plan your implementation or fix the broken assertion/logic.\n"
-                                    "3. Apply targeted fixes with edit_file.\n"
-                                    "4. Verify the test suite passes before marking completion."
-                                )
-                                yield AgentEvent("verification_failed", {
-                                    "type": "tests",
-                                    "command": test_cmd,
-                                    "exit_code": t_exit,
-                                })
-                                yield AgentEvent("replan", {
-                                    "turn": turn,
-                                    "strategy": strategy,
-                                    "trigger": "test_failure",
-                                    "command": test_cmd,
-                                    "exit_code": t_exit,
-                                })
-                                prior_turn_had_error = True
-                                continue
-
                     session._auto_verify_passed = True
 
                 # Cache if single-turn
@@ -863,7 +831,7 @@ class AgentOrchestrator:
                         turn=turn,
                         tool_calls=[{'name': tc.name, 'arguments': tc.arguments} for tc in tool_calls],
                         tool_results=[{'name': res.name, 'content': res.content[:200], 'duration_ms': res.duration_ms} for res in results],
-                        error_types=[system1.triage_error(res.content)[0].value for res in results if system1.triage_error(res.content)[0].value != 'none'],
+                        error_types=[system1.triage_error(res.content, tool_name=res.name)[0].value for res in results if system1.triage_error(res.content, tool_name=res.name)[0].value != 'none'],
                         had_error=prior_turn_had_error,
                         duration_ms=(time.time() - llm_call_start) * 1000.0,
                         tokens_estimated=max_tokens,

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/codeagent/progress.py

@@ -126,10 +126,25 @@ class ProgressMonitor:
                 snap.errors.append(content[:100])
 
         # Determine progress
+        # Read-only bash inspection commands (cat, head, ls, wc, etc.) do NOT count as progress on their own
+        import re
+        read_only_verbs = {"cat", "head", "tail", "ls", "file", "wc", "stat", "echo", "pwd", "which", "type"}
+        has_productive_bash = False
+        for tc in tool_calls:
+            name = tc.get("name", "") if isinstance(tc, dict) else getattr(tc, "name", "")
+            if name == "bash":
+                cmd = (tc.get("arguments", {}) if isinstance(tc, dict) else getattr(tc, "arguments", {})).get("command", "")
+                # Strip shell redirections like 2>&1, >/dev/null, etc. before tokenizing
+                cleaned_cmd = re.sub(r"\d*>\s*&?\d*|\d*<\s*&?\d*", "", cmd)
+                parts = [p.strip() for p in re.split(r"\s*(?:&&|\|\||[;|])\s*", cleaned_cmd) if p.strip()]
+                is_pure_read = bool(parts) and all(p.split()[0].lower() in read_only_verbs for p in parts if p.split())
+                if not is_pure_read:
+                    has_productive_bash = True
+
         snap.had_progress = bool(
             snap.files_created
             or snap.files_modified
-            or (snap.bash_exit_codes and 0 in snap.bash_exit_codes)
+            or (snap.bash_exit_codes and 0 in snap.bash_exit_codes and has_productive_bash)
         )
 
         # No tools called at all = not progress (empty turn)
@@ -190,12 +205,22 @@ class ProgressMonitor:
                 f"Take a step back: what is the simplest path to a working solution?"
             )
 
+        if all(
+            not s.files_created and not s.files_modified and any(t in ("read_file", "list_files", "bash") for t in s.tools_called)
+            for s in recent
+        ):
+            return (
+                "[SYSTEM - PROGRESS MONITOR] Stalled in read-only inspection for 3 consecutive turns. "
+                "You are repeatedly viewing or inspecting files without creating or editing deliverables. "
+                "Stop inspecting. Proceed immediately to implementing the next deliverable: use write_file or edit_file to create remaining code/test files, or run verification tests."
+            )
+
         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. "
                 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"
+                "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."

{alpiecode-10.5.2 → alpiecode-10.5.3}/src/codeagent/system1.py

@@ -75,6 +75,8 @@ class System1Controller:
         self._action_history: List[str] = []
         self._loop_count: Dict[str, int] = {}
         self._file_write_counts: Dict[str, int] = {}
+        self._file_read_counts: Dict[str, int] = {}
+        self._ls_count: int = 0
         self.total_interventions: int = 0
         self.total_llm_skips: int = 0
 
@@ -89,6 +91,8 @@ class System1Controller:
         self._action_history.clear()
         self._loop_count.clear()
         self._file_write_counts.clear()
+        self._file_read_counts.clear()
+        self._ls_count = 0
 
     # ── 1. Test Result Checking ─────────────────────────────────────────
 
@@ -141,13 +145,35 @@ class System1Controller:
 
     # ── 2. Error Triage ─────────────────────────────────────────────────
 
-    def triage_error(self, err_text: str) -> Tuple[ErrorType, Optional[str], Optional[int]]:
+    def triage_error(self, err_text: str, tool_name: Optional[str] = None) -> Tuple[ErrorType, Optional[str], Optional[int]]:
         """Classify error into ErrorType and extract file & line."""
         if not err_text or not err_text.strip():
             return ErrorType.NONE, None, None
 
-        # Truncation error or syntax cutoff due to unexpected EOF
+        # 1. Read-only tools (read_file, list_files, file_search, read_symbol)
+        if tool_name in ("read_file", "list_files", "file_search", "read_symbol"):
+            stripped = err_text.strip()
+            # Only an error if the tool explicitly reported failure
+            if stripped.lower().startswith("error:") or stripped.startswith("FileNotFoundError") or "file not found" in stripped.lower():
+                return ErrorType.UNKNOWN, None, None
+            # Otherwise, read_file output is source code, NOT an execution error!
+            return ErrorType.NONE, None, None
+
+        # Numbered lines from _read_file: "   1 | ..."
+        if re.match(r"^\s*\d+\s*\|", err_text.lstrip()):
+            return ErrorType.NONE, None, None
+
+        # Successful write_file: "wrote N bytes to ..."
+        if err_text.startswith("wrote ") and " bytes to " in err_text:
+            return ErrorType.NONE, None, None
+
+        # Successful bash command: exit_code is 0 and no failure banner
+        if ('"exit_code": 0' in err_text or '"exit_code":0' in err_text) and "⚠️ COMMAND FAILED" not in err_text:
+            return ErrorType.NONE, None, None
+
         lower_err = err_text.lower()
+
+        # Truncation error or syntax cutoff due to unexpected EOF
         if "truncated" in lower_err or "unexpected end of input" in lower_err or "unexpected eof" in lower_err:
             file_match = re.search(r"for\s+['\"]?([a-zA-Z0-9_\.\-\/]+)['\"]?", err_text) or re.search(r"in\s+['\"]?([a-zA-Z0-9_\.\-\/]+)['\"]?", err_text)
             target = file_match.group(1) if file_match else None
@@ -166,22 +192,26 @@ class System1Controller:
             return ErrorType.DEPENDENCY, None, None
 
         # Assertion failure
-        if "assertionerror" in lower_err or "fail:" in lower_err:
+        if "assertionerror" in lower_err or "fail:" in lower_err or "assertion error" in lower_err:
             return ErrorType.ASSERTION, None, None
 
         # Timeout
         if "timed out" in lower_err or "timeout" in lower_err:
             return ErrorType.TIMEOUT, None, None
 
-        # Runtime / general error (only if output actually contains error signals)
-        error_signals = [
-            "error:", "exception:", "traceback", "failed", "errno",
-            "permission denied", "not found", "cannot", "invalid",
-            "nameerror", "typeerror", "valueerror", "keyerror",
-            "indexerror", "runtimeerror", "oserror", "ioerror",
-            "filenotfounderror", "importerror", "attributeerror",
+        # Runtime / general error (detect actual execution crashes and tracebacks, not code words)
+        real_error_patterns = [
+            r"traceback \(most recent call last\):",
+            r"\b(nameerror|typeerror|valueerror|keyerror|indexerror|runtimeerror|oserror|ioerror|filenotfounderror|importerror|attributeerror|permissionerror|zerodivisionerror|recursionerror):\s",
+            r"⚠️\s*command failed",
+            r"^error:\s",
+            r"^fatal:\s",
+            r"command failed:",
+            r"\berrno\s+\d+",
+            r"permission denied",
+            r"no such file or directory",
         ]
-        if any(sig in lower_err for sig in error_signals):
+        if any(re.search(pat, lower_err, re.MULTILINE) for pat in real_error_patterns):
             return ErrorType.UNKNOWN, None, None
 
         # Normal output (no error detected) → do NOT treat as error
@@ -269,7 +299,66 @@ class System1Controller:
                         confidence=0.95,
                     )
 
-        err_type, target_file, target_line = self.triage_error(tool_result)
+        # Inspection loop detection: repeatedly reading/inspecting the same file
+        if tool_name == "read_file":
+            path = str(tool_args.get("path") or tool_args.get("file") or tool_args.get("filepath") or "").strip()
+            if path:
+                count = self._file_read_counts.get(path, 0) + 1
+                self._file_read_counts[path] = count
+                if count >= 2:
+                    self.total_interventions += 1
+                    directive = (
+                        f"[SYSTEM 1 DIRECTIVE] Inspection loop detected: You have already read and inspected '{path}'. "
+                        f"Stop re-reading '{path}'. Proceed immediately to implementing the next deliverable: "
+                        "create any remaining files (e.g. test files) using write_file, or run test verification."
+                    )
+                    return JevDecision(
+                        action=ActionCategory.RETRY_WITH_DIRECTIVE,
+                        error_type=ErrorType.NONE,
+                        directive=directive,
+                        confidence=0.95,
+                    )
+
+        # Inspection loop detection for bash (cat, head, tail, ls)
+        if tool_name == "bash":
+            cmd = str(tool_args.get("command", "")).strip().lower()
+            if any(cmd.startswith(v) or f" {v}" in cmd for v in ("cat ", "head ", "tail ", "less ")):
+                parts = cmd.split()
+                for p in parts[1:]:
+                    clean_p = p.strip("'\"")
+                    if clean_p.endswith((".py", ".js", ".ts", ".html", ".css", ".json", ".toml")):
+                        count = self._file_read_counts.get(clean_p, 0) + 1
+                        self._file_read_counts[clean_p] = count
+                        if count >= 2:
+                            self.total_interventions += 1
+                            directive = (
+                                f"[SYSTEM 1 DIRECTIVE] Inspection loop detected: You are inspecting '{clean_p}' via bash. "
+                                f"'{clean_p}' already exists and has been reviewed. Stop re-reading it. "
+                                "Proceed immediately to implement the NEXT required file or run test verification."
+                            )
+                            return JevDecision(
+                                action=ActionCategory.RETRY_WITH_DIRECTIVE,
+                                error_type=ErrorType.NONE,
+                                directive=directive,
+                                confidence=0.95,
+                            )
+            if cmd.startswith("ls") or " ls " in cmd or "ls -la" in cmd:
+                self._ls_count += 1
+                if self._ls_count >= 2:
+                    self.total_interventions += 1
+                    directive = (
+                        "[SYSTEM 1 DIRECTIVE] Repeated directory listing detected. "
+                        "Stop inspecting directory contents. Proceed immediately to creating the next required file "
+                        "using write_file, or run test verification."
+                    )
+                    return JevDecision(
+                        action=ActionCategory.RETRY_WITH_DIRECTIVE,
+                        error_type=ErrorType.NONE,
+                        directive=directive,
+                        confidence=0.95,
+                    )
+
+        err_type, target_file, target_line = self.triage_error(tool_result, tool_name=tool_name)
 
         # 1. Loop detection (using Dream-RSI adaptive thresholds)
         if err_type != ErrorType.NONE and self.detect_loop(tool_name, tool_args, tool_result, err_type=err_type):
@@ -288,10 +377,22 @@ class System1Controller:
                     target_line=target_line,
                     directive=directive,
                 )
+            elif tool_name == "bash":
+                cmd = str(tool_args.get("command", ""))
+                directive = (
+                    f"[SYSTEM 1 DIRECTIVE] Repeated command failure loop detected for: '{cmd[:80]}'.\n"
+                    "Do NOT re-run the same failing command. Fix the root cause in the source code using edit_file or adjust the command arguments."
+                )
+                return JevDecision(
+                    action=ActionCategory.RETRY_WITH_DIRECTIVE,
+                    confidence=0.95,
+                    error_type=err_type,
+                    directive=directive,
+                )
             else:
                 directive = (
-                    f"[SYSTEM 1 INTERVENTION] Repeated failure loop detected for {tool_name}.\n"
-                    "Change strategy: inspect workspace state or error details before retrying."
+                    f"[SYSTEM 1 DIRECTIVE] Repeated failure loop detected for {tool_name}.\n"
+                    "Do NOT repeat the same failing call. Proceed with an alternative action or next deliverable."
                 )
                 return JevDecision(
                     action=ActionCategory.RETRY_WITH_DIRECTIVE,