alpiecode 8.0.0__tar.gz → 8.0.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.0
+Version: 8.0.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-8.0.0 → alpiecode-8.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "8.0.0"
+version = "8.0.1"
 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.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 8.0.0
+Version: 8.0.1
 Summary: AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-8.0.0 → alpiecode-8.0.1}/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.1}/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:
@@ -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]