alpiecode 7.0.7__tar.gz → 8.0.1__tar.gz

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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 7.0.7
+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.1/src/codeagent/backends/openai_backend.py

@@ -0,0 +1,319 @@
+"""
+OpenAI-compatible API inference backend with smart model resolution.
+"""
+
+from typing import Any, List, Optional
+from openai import OpenAI, NotFoundError
+
+from ..config import Config, get_shared_http_client, is_server_reachable
+from .base import ChatResponse, ToolCall
+
+
+class OpenAIBackend:
+    """Backend for remote OpenAI-compatible servers (vLLM, Ollama, etc.)."""
+
+    def __init__(self, cfg: Config):
+        self._cfg = cfg
+        self._client: Optional[OpenAI] = None
+        self._resolved_model: Optional[str] = None
+
+    @property
+    def name(self) -> str:
+        return f"Online API ({self._cfg.base_url})"
+
+    @property
+    def is_available(self) -> bool:
+        return is_server_reachable(self._cfg.base_url)
+
+    @property
+    def context_window(self) -> int:
+        return 262_144
+
+    def _ensure_client(self) -> OpenAI:
+        if self._client is None:
+            self._client = OpenAI(
+                base_url=self._cfg.base_url,
+                api_key=self._cfg.api_key or "not-needed",
+                http_client=get_shared_http_client(),
+            )
+        return self._client
+
+    def _get_available_model(self, client: OpenAI) -> str:
+        """Auto-discover the served model name from /v1/models."""
+        if self._resolved_model:
+            return self._resolved_model
+        try:
+            models_list = client.models.list()
+            if models_list.data:
+                for m in models_list.data:
+                    if m.id == self._cfg.model or getattr(m, "root", None) == self._cfg.model:
+                        self._resolved_model = m.id
+                        return self._resolved_model
+                self._resolved_model = models_list.data[0].id
+                return self._resolved_model
+        except Exception:
+            pass
+        return self._cfg.model
+
+    def chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        """
+        True real-time SSE streaming completion yielding progressive thinking deltas,
+        duration, content tokens, and final ChatResponse.
+        """
+        import time
+        import json
+        start_time = time.time()
+        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.1)
+        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 8192)
+
+        client = self._ensure_client()
+        model_name = self._get_available_model(client)
+
+        params = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temp,
+            "max_tokens": m_tokens,
+            "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
+            "stream": True,
+        }
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = "auto"
+
+        try:
+            response = client.chat.completions.create(**params)
+        except NotFoundError:
+            self._resolved_model = None
+            model_name = self._get_available_model(client)
+            params["model"] = model_name
+            response = client.chat.completions.create(**params)
+
+        in_think = enable_thinking
+        think_started = False
+        full_content = []
+        full_reasoning = []
+        tool_calls_dict = {}
+
+        for chunk in response:
+            if not chunk.choices:
+                continue
+            delta = chunk.choices[0].delta
+            if not delta:
+                continue
+
+            # Tool call deltas
+            if delta.tool_calls:
+                for tc in delta.tool_calls:
+                    idx = tc.index
+                    if idx not in tool_calls_dict:
+                        tool_calls_dict[idx] = {
+                            "id": tc.id or f"call_{idx}",
+                            "name": tc.function.name if tc.function and tc.function.name else "",
+                            "arguments": ""
+                        }
+                    else:
+                        if tc.id:
+                            tool_calls_dict[idx]["id"] = tc.id
+                        if tc.function and tc.function.name:
+                            tool_calls_dict[idx]["name"] += tc.function.name
+                    if tc.function and tc.function.arguments:
+                        tool_calls_dict[idx]["arguments"] += tc.function.arguments
+
+            # Explicit reasoning field from some models
+            explicit_reasoning = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
+            if explicit_reasoning:
+                if not think_started:
+                    think_started = True
+                    yield ("thinking_start", {"time": start_time})
+                full_reasoning.append(explicit_reasoning)
+                yield ("thinking_delta", {"delta": explicit_reasoning})
+
+            # Content deltas (contains <think>...</think> on vLLM/Qwen models)
+            if delta.content:
+                text = delta.content
+                if in_think:
+                    if not think_started:
+                        think_started = True
+                        yield ("thinking_start", {"time": start_time})
+
+                    if "</think>" in text:
+                        before, after = text.split("</think>", 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()})
+                        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)
+                        yield ("thinking_delta", {"delta": clean_text})
+                else:
+                    full_content.append(text)
+                    yield ("token", {"delta": text})
+
+        # Close thinking if stream ended while still in think block
+        if in_think and think_started:
+            elapsed = time.time() - start_time
+            yield ("thinking_end", {"duration": round(elapsed, 1), "content": "".join(full_reasoning).strip()})
+
+        tool_calls = None
+        if tool_calls_dict:
+            tool_calls = []
+            for idx in sorted(tool_calls_dict.keys()):
+                item = tool_calls_dict[idx]
+                try:
+                    args = json.loads(item["arguments"])
+                except Exception:
+                    args = {}
+                tool_calls.append(ToolCall(id=item["id"], name=item["name"], arguments=args))
+
+        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,
+            reasoning=final_reasoning,
+            tool_calls=tool_calls,
+            raw=None
+        ))
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.1)
+        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 8192)
+
+        client = self._ensure_client()
+        model_name = self._get_available_model(client)
+
+        params = {
+            "model": model_name,
+            "messages": messages,
+            "temperature": temp,
+            "max_tokens": m_tokens,
+            "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
+        }
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = "auto"
+
+        try:
+            resp = client.chat.completions.create(**params)
+        except NotFoundError:
+            # Model name mismatch -> re-discover model
+            self._resolved_model = None
+            model_name = self._get_available_model(client)
+            params["model"] = model_name
+            resp = client.chat.completions.create(**params)
+
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if msg.tool_calls:
+            import json
+            tool_calls = []
+            for tc in msg.tool_calls:
+                try:
+                    args = json.loads(tc.function.arguments or "{}")
+                except (json.JSONDecodeError, TypeError):
+                    args = {}
+                if not isinstance(args, dict):
+                    args = {}
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        arguments=args,
+                    )
+                )
+
+        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
+        content = msg.content or ""
+
+        # Extract embedded thinking/reasoning if not provided in separate fields
+        if not reasoning and content:
+            import re
+            if "</think>" in content:
+                # Handled when model starts thinking implicitly or with <think>
+                parts = content.split("</think>", 1)
+                reasoning = parts[0].replace("<think>", "").strip()
+                content = parts[1].strip()
+            elif "<think>" in content:
+                think_match = re.search(r"<think>(.*?)</think>", content, flags=re.DOTALL)
+                if think_match:
+                    reasoning = think_match.group(1).strip()
+                    content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
+            elif content.strip().lower().startswith("thinking process:") or "\nthinking process:" in content.lower():
+                if tool_calls:
+                    reasoning = re.sub(r"(?i)^thinking process:\s*", "", content).strip()
+                    content = ""
+                else:
+                    code_match = re.search(r"\n(?=```|Here is|Below is|I will|The following|DONE:|#!/usr|/\*|package\s|import\s[a-z]|from\s[a-z])", content, flags=re.IGNORECASE)
+                    if code_match:
+                        think_part = content[:code_match.start()]
+                        content_part = content[code_match.start():]
+                        reasoning = re.sub(r"(?i)^thinking process:\s*", "", think_part).strip()
+                        content = content_part.strip()
+                    else:
+                        reasoning = re.sub(r"(?i)^thinking process:\s*", "", content).strip()
+                        content = ""
+
+        return ChatResponse(
+            content=content,
+            reasoning=reasoning,
+            tool_calls=tool_calls,
+            raw=resp,
+        )
+
+    def shutdown(self) -> None:
+        self._client = None

{alpiecode-7.0.7 → 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:
@@ -211,13 +249,27 @@ class AgentOrchestrator:
                 else:
                     max_tokens = 2048 if is_offline else effective_max_tokens
 
-                resp = self.backend.chat_completion(
-                    messages=session.context.messages,
-                    tools=active_tools if active_tools else None,
-                    temperature=cfg.temperature,
-                    max_tokens=max_tokens,
-                    enable_thinking=enable_thinking,
-                )
+                if hasattr(self.backend, "chat_completion_stream") and not is_offline:
+                    resp = None
+                    for event_type, data in self.backend.chat_completion_stream(
+                        messages=session.context.messages,
+                        tools=active_tools if active_tools else None,
+                        temperature=cfg.temperature,
+                        max_tokens=max_tokens,
+                        enable_thinking=enable_thinking,
+                    ):
+                        if event_type == "done":
+                            resp = data
+                        else:
+                            yield AgentEvent(event_type, data)
+                else:
+                    resp = self.backend.chat_completion(
+                        messages=session.context.messages,
+                        tools=active_tools if active_tools else None,
+                        temperature=cfg.temperature,
+                        max_tokens=max_tokens,
+                        enable_thinking=enable_thinking,
+                    )
             except Exception as e:
                 # Online error -> fallback to local
                 if not is_offline and isinstance(self.backend, OpenAIBackend):
@@ -241,11 +293,25 @@ class AgentOrchestrator:
                     yield AgentEvent("error", {"error": str(e)})
                     return
 
-            if resp.reasoning:
+            if resp.reasoning and not (hasattr(self.backend, "chat_completion_stream") and not is_offline):
                 yield AgentEvent("thinking", {"content": resp.reasoning})
 
             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
@@ -266,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:
@@ -301,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-7.0.7/src/codeagent/backends/openai_backend.py

@@ -1,152 +0,0 @@
-"""
-OpenAI-compatible API inference backend with smart model resolution.
-"""
-
-from typing import Any, List, Optional
-from openai import OpenAI, NotFoundError
-
-from ..config import Config, get_shared_http_client, is_server_reachable
-from .base import ChatResponse, ToolCall
-
-
-class OpenAIBackend:
-    """Backend for remote OpenAI-compatible servers (vLLM, Ollama, etc.)."""
-
-    def __init__(self, cfg: Config):
-        self._cfg = cfg
-        self._client: Optional[OpenAI] = None
-        self._resolved_model: Optional[str] = None
-
-    @property
-    def name(self) -> str:
-        return f"Online API ({self._cfg.base_url})"
-
-    @property
-    def is_available(self) -> bool:
-        return is_server_reachable(self._cfg.base_url)
-
-    @property
-    def context_window(self) -> int:
-        return 262_144
-
-    def _ensure_client(self) -> OpenAI:
-        if self._client is None:
-            self._client = OpenAI(
-                base_url=self._cfg.base_url,
-                api_key=self._cfg.api_key or "not-needed",
-                http_client=get_shared_http_client(),
-            )
-        return self._client
-
-    def _get_available_model(self, client: OpenAI) -> str:
-        """Auto-discover the served model name from /v1/models."""
-        if self._resolved_model:
-            return self._resolved_model
-        try:
-            models_list = client.models.list()
-            if models_list.data:
-                for m in models_list.data:
-                    if m.id == self._cfg.model or getattr(m, "root", None) == self._cfg.model:
-                        self._resolved_model = m.id
-                        return self._resolved_model
-                self._resolved_model = models_list.data[0].id
-                return self._resolved_model
-        except Exception:
-            pass
-        return self._cfg.model
-
-    def chat_completion(
-        self,
-        messages: List[dict],
-        tools: Optional[List[dict]] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        enable_thinking: bool = True,
-    ) -> ChatResponse:
-        temp = temperature if temperature is not None else getattr(self._cfg, "temperature", 0.1)
-        m_tokens = max_tokens if max_tokens is not None else getattr(self._cfg, "max_tokens", 8192)
-
-        client = self._ensure_client()
-        model_name = self._get_available_model(client)
-
-        params = {
-            "model": model_name,
-            "messages": messages,
-            "temperature": temp,
-            "max_tokens": m_tokens,
-            "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
-        }
-        if tools:
-            params["tools"] = tools
-            params["tool_choice"] = "auto"
-
-        try:
-            resp = client.chat.completions.create(**params)
-        except NotFoundError:
-            # Model name mismatch -> re-discover model
-            self._resolved_model = None
-            model_name = self._get_available_model(client)
-            params["model"] = model_name
-            resp = client.chat.completions.create(**params)
-
-        msg = resp.choices[0].message
-
-        tool_calls = None
-        if msg.tool_calls:
-            import json
-            tool_calls = []
-            for tc in msg.tool_calls:
-                try:
-                    args = json.loads(tc.function.arguments or "{}")
-                except (json.JSONDecodeError, TypeError):
-                    args = {}
-                if not isinstance(args, dict):
-                    args = {}
-                tool_calls.append(
-                    ToolCall(
-                        id=tc.id,
-                        name=tc.function.name,
-                        arguments=args,
-                    )
-                )
-
-        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
-        content = msg.content or ""
-
-        # Extract embedded thinking/reasoning if not provided in separate fields
-        if not reasoning and content:
-            import re
-            if "</think>" in content:
-                # Handled when model starts thinking implicitly or with <think>
-                parts = content.split("</think>", 1)
-                reasoning = parts[0].replace("<think>", "").strip()
-                content = parts[1].strip()
-            elif "<think>" in content:
-                think_match = re.search(r"<think>(.*?)</think>", content, flags=re.DOTALL)
-                if think_match:
-                    reasoning = think_match.group(1).strip()
-                    content = re.sub(r"<think>.*?</think>", "", content, flags=re.DOTALL).strip()
-            elif content.strip().lower().startswith("thinking process:") or "\nthinking process:" in content.lower():
-                if tool_calls:
-                    reasoning = re.sub(r"(?i)^thinking process:\s*", "", content).strip()
-                    content = ""
-                else:
-                    code_match = re.search(r"\n(?=```|Here is|Below is|I will|The following|DONE:|#!/usr|/\*|package\s|import\s[a-z]|from\s[a-z])", content, flags=re.IGNORECASE)
-                    if code_match:
-                        think_part = content[:code_match.start()]
-                        content_part = content[code_match.start():]
-                        reasoning = re.sub(r"(?i)^thinking process:\s*", "", think_part).strip()
-                        content = content_part.strip()
-                    else:
-                        reasoning = re.sub(r"(?i)^thinking process:\s*", "", content).strip()
-                        content = ""
-
-        return ChatResponse(
-            content=content,
-            reasoning=reasoning,
-            tool_calls=tool_calls,
-            raw=resp,
-        )
-
-    def shutdown(self) -> None:
-        self._client = None