alpiecode 7.0.1__tar.gz → 7.0.3__tar.gz

{alpiecode-7.0.1 → alpiecode-7.0.3}/PKG-INFO

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

{alpiecode-7.0.1 → alpiecode-7.0.3}/pyproject.toml

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

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/alpiecode.egg-info/PKG-INFO

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

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/alpiecode.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ src/codeagent/context.py
 src/codeagent/discovery.py
 src/codeagent/doctor.py
 src/codeagent/executor.py
+src/codeagent/git_ops.py
 src/codeagent/github.py
 src/codeagent/guardian.py
 src/codeagent/ipython_ext.py
@@ -27,6 +28,7 @@ src/codeagent/memory.py
 src/codeagent/orchestrator.py
 src/codeagent/progress.py
 src/codeagent/prompt.py
+src/codeagent/rephraser.py
 src/codeagent/server.py
 src/codeagent/session.py
 src/codeagent/tools.py

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/__init__.py

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

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/agent.py

@@ -303,6 +303,19 @@ def run_agent(
         elif event.type == "adaptive_mode" and verbose and HAS_RICH:
             console.print("⚡ [dim]Adaptive mode: simple task detected, skipping deep reasoning for speed[/dim]")
 
+        elif event.type == "status":
+            phase = event.data.get("phase")
+            if debug and phase == "building" and event.data.get("rephrased") and event.data.get("rephrased") != task:
+                if HAS_RICH:
+                    console.print(Panel(
+                        f"[bold cyan]🎯 Solidified Engineering Specification[/bold cyan]\n{event.data.get('rephrased')}",
+                        title="Internal Rephraser",
+                        border_style="dim blue",
+                        padding=(0, 1)
+                    ))
+                else:
+                    print(f"[Rephraser] {event.data.get('rephrased')}")
+
         elif event.type == "turn_start":
             current_turn = event.data["turn"]
             if debug:

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/backends/openai_backend.py

@@ -111,9 +111,38 @@ class OpenAIBackend:
                 )
 
         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=msg.content,
+            content=content,
             reasoning=reasoning,
             tool_calls=tool_calls,
             raw=resp,

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/cli.py

@@ -29,7 +29,7 @@ def _show_banner():
 
 
 def _normalize_args():
-    known_commands = {"init", "serve", "run", "chat", "plan", "diff", "doctor", "explain", "-h", "--help", "--version"}
+    known_commands = {"init", "serve", "run", "chat", "plan", "diff", "undo", "doctor", "explain", "version", "-h", "--help", "-v", "--version"}
     subcommand = None
     
     # Check if a subcommand is present
@@ -83,12 +83,15 @@ def main():
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
     common.add_argument("--debug", action="store_true", help="Show autonomous discovery and debug diagnostics")
 
+    from . import __version__
     parser = argparse.ArgumentParser(
         prog="alpiecode",
         description="AlpieCode — Autonomous AI Coding Agent powered by 169Pi Alpie VLM",
         parents=[common],
     )
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
     sub = parser.add_subparsers(dest="command")
+    sub.add_parser("version", help="Show current version")
 
     # ── init ──
     sub.add_parser("init", help="Configure your VLM/OpenAI-compatible endpoint")
@@ -112,6 +115,9 @@ def main():
     # ── diff ──
     diff_p = sub.add_parser("diff", help="Show changes AlpieCode has made since last checkpoint", parents=[common])
 
+    # ── undo ──
+    undo_p = sub.add_parser("undo", help="Revert file changes made by the last AlpieCode session", parents=[common])
+
     # ── doctor ──
     sub.add_parser("doctor", help="Run system health checks (CUDA, Python, network, dev tools)")
 
@@ -125,6 +131,10 @@ def main():
         parser.print_help()
         return
 
+    if args.command == "version":
+        print(f"alpiecode {__version__}")
+        return
+
     if args.command == "init":
         interactive_init()
         return
@@ -199,6 +209,16 @@ def main():
             debug=getattr(args, "debug", False),
         )
 
+    elif args.command == "diff":
+        from .git_ops import show_diff
+        show_diff(Path(args.workdir).resolve())
+        return
+
+    elif args.command == "undo":
+        from .git_ops import undo_last_session
+        undo_last_session(Path(args.workdir).resolve())
+        return
+
     elif args.command == "doctor":
         from .doctor import run_doctor
         sys.exit(run_doctor())

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/executor.py

@@ -116,24 +116,26 @@ class ToolExecutor:
         on_tool_start: Optional[Callable[[str, dict], None]] = None,
         on_tool_end: Optional[Callable[[str, str], None]] = None,
     ) -> List[ToolResult]:
-        """Execute a list of tool calls using parallel dispatch for read-only tools."""
+        """Execute a list of tool calls with staged DAG parallelization:
+        - Stage 1: All read-only tools run concurrently in a ThreadPool
+        - Stage 2: Mutating tools run sequentially in order
+        Results are returned matching the exact original order of tool_calls.
+        """
         if not tool_calls:
             return []
 
-        all_read_only = all(tc.name in READ_ONLY_TOOLS for tc in tool_calls)
-        use_parallel = all_read_only and len(tool_calls) > 1
+        results_map: Dict[str, ToolResult] = {}
+        read_calls = [tc for tc in tool_calls if tc.name in READ_ONLY_TOOLS]
+        mut_calls = [tc for tc in tool_calls if tc.name not in READ_ONLY_TOOLS]
 
-        results: List[ToolResult] = []
-
-        if use_parallel:
-            results_map: Dict[str, Tuple[str, float]] = {}
-            with ThreadPoolExecutor(max_workers=min(8, len(tool_calls))) as pool:
+        # Stage 1: Parallel read-only execution
+        if len(read_calls) > 1:
+            with ThreadPoolExecutor(max_workers=min(8, len(read_calls))) as pool:
                 future_to_tc = {}
-                for tc in tool_calls:
+                for tc in read_calls:
                     if on_tool_start:
                         on_tool_start(tc.name, tc.arguments)
                     t0 = time.monotonic()
-                    # Defensive: ensure arguments is always a dict
                     safe_args = tc.arguments if isinstance(tc.arguments, dict) else {}
                     fn = self.dispatch.get(tc.name)
                     if fn:
@@ -149,14 +151,84 @@ class ToolExecutor:
                         res_str = str(future.result())
                     except Exception as e:
                         res_str = f"error: {e}"
-                    results_map[tc.id] = (res_str, elapsed)
+                    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
+                    )
+        elif len(read_calls) == 1:
+            tc = read_calls[0]
+            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)
+            res_str = str(fn(safe_args)) if fn else f"error: Unknown tool '{tc.name}'"
+            elapsed = (time.monotonic() - t0) * 1000
+            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
+            )
+
+        # 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>."
+                )
+
+            # 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
+            )
 
-            for tc in tool_calls:
-                res_str, elapsed = results_map[tc.id]
-                if on_tool_end:
-                    on_tool_end(tc.name, res_str)
-                results.append(ToolResult(tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed))
-            return results
+        return [results_map[tc.id] for tc in tool_calls if tc.id in results_map]
 
         # Sequential execution
         for tc in tool_calls:
@@ -215,4 +287,4 @@ class ToolExecutor:
 
             results.append(ToolResult(tool_call_id=tc.id, name=tc.name, content=res_str, duration_ms=elapsed))
 
-        return results
+        return results

alpiecode-7.0.3/src/codeagent/git_ops.py

@@ -0,0 +1,254 @@
+"""
+Git session tracking, diff inspection, and safe rollback for AlpieCode.
+
+Features:
+- Track files created / modified per session
+- `show_diff()`: Render colorized, syntax-highlighted diffs of uncommitted agent changes
+- `undo_last_session()`: Cleanly revert all changes made during the last agent session
+"""
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Set, Optional, Dict, Any
+
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.panel import Panel
+
+SESSION_FILE = ".alpiecode_session.json"
+
+
+def record_session_start(workdir: Path) -> Dict[str, Any]:
+    """Capture initial git / filesystem state before agent execution begins."""
+    state: Dict[str, Any] = {
+        "is_git": False,
+        "initial_status": {},
+        "created_files": [],
+        "modified_files": [],
+    }
+
+    if shutil.which("git") and (workdir / ".git").exists():
+        try:
+            res = subprocess.run(
+                ["git", "status", "--porcelain"],
+                cwd=workdir, capture_output=True, text=True, timeout=5
+            )
+            if res.returncode == 0:
+                state["is_git"] = True
+                status_dict = {}
+                for line in res.stdout.splitlines():
+                    if len(line) >= 4:
+                        st = line[:2].strip()
+                        f = line[3:].strip()
+                        status_dict[f] = st
+                state["initial_status"] = status_dict
+        except Exception:
+            pass
+
+    return state
+
+
+def record_session_end(workdir: Path, state: Dict[str, Any], touched_files: Set[str]):
+    """Save the session outcome to allow diffing and rolling back."""
+    session_data = {
+        "is_git": state.get("is_git", False),
+        "touched_files": list(touched_files),
+        "initial_status": state.get("initial_status", {}),
+    }
+
+    # Determine which files were newly created vs modified
+    created = []
+    modified = []
+
+    init_status = state.get("initial_status", {})
+    for f in touched_files:
+        full_p = workdir / f
+        if not full_p.exists():
+            continue
+        if f not in init_status:
+            # Was not tracked or did not exist before
+            created.append(f)
+        else:
+            modified.append(f)
+
+    session_data["created_files"] = created
+    session_data["modified_files"] = modified
+
+    try:
+        (workdir / SESSION_FILE).write_text(json.dumps(session_data, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def show_diff(workdir: Path):
+    """Render colorized Rich diff of changes made since last session."""
+    console = Console()
+    sess_path = workdir / SESSION_FILE
+
+    # If git repo, run git diff
+    if shutil.which("git") and (workdir / ".git").exists():
+        try:
+            res = subprocess.run(
+                ["git", "diff"],
+                cwd=workdir, capture_output=True, text=True, timeout=8
+            )
+            diff_text = res.stdout.strip()
+            if diff_text:
+                console.print(Panel(
+                    Syntax(diff_text, "diff", theme="monokai", line_numbers=False),
+                    title="🔍 AlpieCode Session Diff",
+                    border_style="cyan"
+                ))
+                return
+        except Exception:
+            pass
+
+    # Fallback to session record
+    if sess_path.exists():
+        try:
+            data = json.loads(sess_path.read_text(encoding="utf-8"))
+            created = data.get("created_files", [])
+            modified = data.get("modified_files", [])
+
+            if not created and not modified:
+                console.print("[green]✨ Clean workspace — no files modified by the last session.[/green]")
+                return
+
+            console.print("[bold cyan]Session File Changes:[/bold cyan]")
+            for c in created:
+                console.print(f"  [green]+ created:[/green] {c}")
+            for m in modified:
+                console.print(f"  [yellow]~ modified:[/yellow] {m}")
+            return
+        except Exception:
+            pass
+
+    console.print("[green]✨ Clean workspace — no changes found.[/green]")
+
+
+def undo_last_session(workdir: Path) -> bool:
+    """Revert changes made during the last agent session."""
+    console = Console()
+    sess_path = workdir / SESSION_FILE
+
+    if not sess_path.exists():
+        # If in a git repo, check uncommitted changes
+        if shutil.which("git") and (workdir / ".git").exists():
+            try:
+                res = subprocess.run(
+                    ["git", "status", "--porcelain"],
+                    cwd=workdir, capture_output=True, text=True, timeout=5
+                )
+                if not res.stdout.strip():
+                    console.print("[green]✨ Nothing to undo — working directory is already clean.[/green]")
+                    return True
+
+                console.print("[yellow]Found uncommitted git changes:[/yellow]")
+                for line in res.stdout.splitlines()[:10]:
+                    console.print(f"  {line}")
+
+                choice = input("\nRevert all uncommitted changes? [y/N]: ").strip().lower()
+                if choice in ("y", "yes"):
+                    subprocess.run(["git", "restore", "."], cwd=workdir, check=True)
+                    subprocess.run(["git", "clean", "-fd"], cwd=workdir, check=True)
+                    console.print("[green]✅ Successfully reverted all uncommitted changes![/green]")
+                    return True
+                else:
+                    console.print("[dim]Undo canceled.[/dim]")
+                    return False
+            except Exception as e:
+                console.print(f"[red]Error during git undo: {e}[/red]")
+                return False
+
+        console.print("[yellow]No recent AlpieCode session found to undo.[/yellow]")
+        return False
+
+    try:
+        data = json.loads(sess_path.read_text(encoding="utf-8"))
+        created = data.get("created_files", [])
+        modified = data.get("modified_files", [])
+
+        if not created and not modified:
+            console.print("[green]✨ Nothing to undo — no files were touched in the last session.[/green]")
+            return True
+
+        console.print("[bold red]Files to revert:[/bold red]")
+        for c in created:
+            console.print(f"  [red]- remove created:[/red] {c}")
+        for m in modified:
+            console.print(f"  [yellow]↺ restore modified:[/yellow] {m}")
+
+        choice = input("\nRevert these changes? [y/N]: ").strip().lower()
+        if choice not in ("y", "yes"):
+            console.print("[dim]Undo canceled.[/dim]")
+            return False
+
+        # Revert modified files via git if possible
+        if data.get("is_git") and shutil.which("git"):
+            for m in modified:
+                try:
+                    subprocess.run(["git", "checkout", "--", m], cwd=workdir, check=False)
+                except Exception:
+                    pass
+
+        # Remove created files
+        for c in created:
+            p = workdir / c
+            if p.exists() and p.is_file():
+                try:
+                    p.unlink()
+                except Exception:
+                    pass
+
+        # Clean up session file
+        sess_path.unlink(missing_ok=True)
+        console.print(f"[green]✅ Successfully reverted {len(created) + len(modified)} files![/green]")
+        return True
+
+    except Exception as e:
+        console.print(f"[red]Failed to undo session: {e}[/red]")
+        return False
+
+
+def push_to_remote(workdir: Path, username: Optional[str] = None, branch: Optional[str] = None) -> Dict[str, Any]:
+    """Stage, commit, and push changes to git remote origin."""
+    if not shutil.which("git") or not (workdir / ".git").exists():
+        return {"success": False, "error": "Not a git repository"}
+
+    try:
+        # Check remote
+        rem_res = subprocess.run(["git", "remote", "get-url", "origin"], cwd=workdir, capture_output=True, text=True, timeout=5)
+        if rem_res.returncode != 0:
+            return {"success": False, "error": "No remote 'origin' configured"}
+        remote_url = rem_res.stdout.strip()
+
+        # Determine branch
+        if not branch:
+            br_res = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=workdir, capture_output=True, text=True, timeout=5)
+            branch = br_res.stdout.strip() if br_res.returncode == 0 else "main"
+
+        # Stage and commit any uncommitted changes
+        subprocess.run(["git", "add", "-A"], cwd=workdir, capture_output=True, timeout=10)
+        commit_cmd = ["git"]
+        if username:
+            commit_cmd.extend(["-c", f"user.name={username}"])
+        commit_cmd.extend(["commit", "-m", "feat: updates by AlpieCode agent", "--allow-empty"])
+        subprocess.run(commit_cmd, cwd=workdir, capture_output=True, timeout=10)
+
+        # Push to origin
+        push_res = subprocess.run(["git", "push", "-u", "origin", branch], cwd=workdir, capture_output=True, text=True, timeout=30)
+        if push_res.returncode == 0:
+            return {
+                "success": True,
+                "remote": remote_url,
+                "branch": branch,
+                "username": username or "default",
+                "output": push_res.stdout.strip() or push_res.stderr.strip(),
+            }
+        else:
+            return {"success": False, "error": push_res.stderr.strip()}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/ipython_ext.py

@@ -11,6 +11,7 @@ and Google Colab via cell/line magic commands and rich interactive displays:
 """
 
 import html
+import time
 import re
 import sys
 import warnings
@@ -114,20 +115,28 @@ def _extract_primary_code_block(text: str) -> Optional[str]:
     return None
 
 
-def _render_colab_card(task: str, tool_actions: List[Dict[str, str]], content: str) -> str:
-    """Render a modern, sleek Colab/Jupyter responsive card."""
+# Active session cache for multi-cell conversational memory
+_ACTIVE_NOTEBOOK_SESSION = None
+
+def _render_colab_card(task: str, tool_actions: List[Dict[str, str]], status: str = "done") -> str:
+    """Render a modern, sleek Colab/Jupyter responsive card with live pulse indicator."""
     task_escaped = html.escape(task[:140])
     
+    badge_label = "Running..." if status == "running" else "Goal-Driven"
+    badge_color = "#38bdf8" if status == "running" else "#64748b"
+
     actions_html = ""
     if tool_actions:
         actions_html = '<div style="margin-top: 8px; margin-bottom: 8px; font-family: ui-monospace, monospace; font-size: 12px;">'
         for act in tool_actions:
             name = html.escape(act.get("name", ""))
             summary = html.escape(act.get("summary", ""))
-            status = act.get("status", "✓")
+            st = act.get("status", "✓")
+            dot_color = "#fbbf24" if st == "running" else "#38bdf8"
+            icon = "⏳" if st == "running" else "⏺"
             actions_html += (
                 f'<div style="display: flex; align-items: center; gap: 6px; padding: 3px 0; color: #94a3b8;">'
-                f'<span style="color: #38bdf8;">⏺</span> '
+                f'<span style="color: {dot_color}; font-size: 11px;">{icon}</span> '
                 f'<strong style="color: #f1f5f9;">{name}</strong> '
                 f'<span style="color: #64748b;">{summary}</span>'
                 f'</div>'
@@ -143,8 +152,8 @@ def _render_colab_card(task: str, tool_actions: List[Dict[str, str]], content: s
         f'<span style="font-weight: 600; font-size: 13px; color: #38bdf8; display: flex; align-items: center; gap: 6px;">'
         f'⚡ AlpieCode Agent'
         f'</span>'
-        f'<span style="font-size: 11px; color: #64748b; background: #1e293b; padding: 2px 8px; border-radius: 9999px;">'
-        f'Goal-Driven'
+        f'<span style="font-size: 11px; color: {badge_color}; background: #1e293b; padding: 2px 8px; border-radius: 9999px;">'
+        f'{badge_label}'
         f'</span>'
         f'</div>'
         f'<div style="font-size: 13px; color: #cbd5e1; margin-top: 8px; font-weight: 500;">{task_escaped}</div>'
@@ -186,17 +195,37 @@ def alpie_magic(line: str, cell: Optional[str] = None):
         run_agent(full_task, workdir, cfg, verbose=True)
         return
 
-    # In Jupyter or Google Colab: run with rich streaming & UI
+    # In Jupyter or Google Colab: run with live in-place streaming & UI
+    global _ACTIVE_NOTEBOOK_SESSION
     from IPython import get_ipython
+    from IPython.display import HTML, Markdown, display, update_display
     ip = get_ipython()
 
     backend = resolve_backend(cfg)
     orchestrator = AgentOrchestrator(backend)
     session_mgr = SessionManager()
-    session = session_mgr.create_session(workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144)
+
+    # Support --reset or --new flag for cross-cell memory reset
+    if raw_task.startswith("--reset") or raw_task.startswith("--new"):
+        _ACTIVE_NOTEBOOK_SESSION = None
+        raw_task = re.sub(r"^(--reset|--new)\s*", "", raw_task).strip()
+        full_task = f"{raw_task}\n{nb_context}" if nb_context else raw_task
+
+    if _ACTIVE_NOTEBOOK_SESSION is None:
+        _ACTIVE_NOTEBOOK_SESSION = session_mgr.create_session(
+            workdir, max_tokens=cfg.n_ctx if not backend.is_available else 262_144
+        )
+    session = _ACTIVE_NOTEBOOK_SESSION
 
     tool_actions: List[Dict[str, str]] = []
     final_content = ""
+    display_id = f"alpie_card_{int(time.time() * 1000)}"
+
+    # Initial in-place widget render
+    try:
+        display(HTML(_render_colab_card(raw_task, tool_actions, status="running")), display_id=display_id)
+    except Exception:
+        pass
 
     for event in orchestrator.run_task(session=session, task=full_task, cfg=cfg):
         if event.type == "tool_call":
@@ -212,10 +241,22 @@ def alpie_magic(line: str, cell: Optional[str] = None):
             summary = ""
             if t_name == "bash":
                 cmd = t_args.get("command", "")
-                summary = f"$ {cmd[:60]}..." if len(cmd) > 60 else f"$ {cmd}"
+                summary = f"$ {cmd[:50]}..." if len(cmd) > 50 else f"$ {cmd}"
             elif t_name in ("write_file", "edit_file", "read_file"):
                 summary = str(t_args.get("path", ""))
-            tool_actions.append({"name": t_name, "summary": summary})
+            tool_actions.append({"name": t_name, "summary": summary, "status": "running"})
+            try:
+                update_display(HTML(_render_colab_card(raw_task, tool_actions, status="running")), display_id=display_id)
+            except Exception:
+                pass
+
+        elif event.type == "tool_result":
+            if tool_actions:
+                tool_actions[-1]["status"] = "✓"
+                try:
+                    update_display(HTML(_render_colab_card(raw_task, tool_actions, status="running")), display_id=display_id)
+                except Exception:
+                    pass
 
         elif event.type == "message":
             final_content = event.data.get("content", "")
@@ -229,8 +270,12 @@ def alpie_magic(line: str, cell: Optional[str] = None):
     if cleaned_content.upper().startswith("DONE:"):
         cleaned_content = cleaned_content[5:].strip()
 
-    # Render modern card & markdown
-    _display_html(_render_colab_card(raw_task, tool_actions, cleaned_content))
+    # Final in-place update with done state
+    try:
+        update_display(HTML(_render_colab_card(raw_task, tool_actions, status="done")), display_id=display_id)
+    except Exception:
+        _display_html(_render_colab_card(raw_task, tool_actions, status="done"))
+
     if cleaned_content:
         _display_markdown(cleaned_content)
 
@@ -299,6 +344,20 @@ def alpie_explain_magic(line: str):
     alpie_magic(explain_task)
 
 
+
+def alpie_reset_magic(line: str = ""):
+    """%alpie_reset — Reset conversation memory for the notebook session."""
+    global _ACTIVE_NOTEBOOK_SESSION
+    _ACTIVE_NOTEBOOK_SESSION = None
+    if _is_notebook():
+        _display_html(
+            '<div style="background: #0f172a; border-left: 3px solid #10b981; border-radius: 6px; padding: 6px 12px; font-family: sans-serif; font-size: 12px; color: #10b981;">'
+            '🔄 AlpieCode notebook conversation memory cleared.'
+            '</div>'
+        )
+    else:
+        print("🔄 AlpieCode notebook conversation memory cleared.")
+
 def alpie_doctor_magic(line: str = ""):
     """%alpie_doctor — Run system health diagnostic checks."""
     from .doctor import run_doctor
@@ -311,6 +370,7 @@ def load_ipython_extension(ipython):
     ipython.register_magic_function(alpie_plan_magic, magic_kind="line_cell", magic_name="alpie_plan")
     ipython.register_magic_function(alpie_explain_magic, magic_kind="line", magic_name="alpie_explain")
     ipython.register_magic_function(alpie_doctor_magic, magic_kind="line", magic_name="alpie_doctor")
+    ipython.register_magic_function(alpie_reset_magic, magic_kind="line", magic_name="alpie_reset")
     if _is_notebook():
         _display_html(
             '<div style="background: #0f172a; border-left: 4px solid #38bdf8; border-radius: 6px; padding: 8px 12px; margin: 4px 0; font-family: sans-serif; font-size: 13px; color: #e2e8f0;">'

{alpiecode-7.0.1 → alpiecode-7.0.3}/src/codeagent/orchestrator.py

@@ -16,6 +16,7 @@ from .config import Config, is_server_reachable
 from .memory import extract_and_save_memories
 from .discovery import build_task_context, COMPLEXITY_CONFIG
 from .progress import ProgressMonitor
+from .rephraser import PromptRephraser
 from .prompt import PromptBuilder, classify_task
 from .session import Session, SessionManager
 
@@ -43,6 +44,7 @@ class AgentOrchestrator:
     ):
         self.backend = backend
         self.prompt_builder = prompt_builder or PromptBuilder()
+        self.rephraser = PromptRephraser()
 
     def run_task(
         self,
@@ -59,7 +61,7 @@ class AgentOrchestrator:
 
         # ── Phase 0: Discovery — pre-compute task intelligence ──
         task_context = build_task_context(task, session.workdir)
-        complexity = task_context.complexity
+        complexity = complexity or task_context.complexity
 
         yield AgentEvent("discovery", {
             "intent": task_context.intent,
@@ -116,9 +118,26 @@ class AgentOrchestrator:
             task_context=task_context,
         )
         session.context.set_system_prompt(system_prompt)
+        # ── Phase 0.5: Internal Prompt Rephraser (first step, internal only) ──
+        yield AgentEvent("status", {
+            "phase": "rephrasing",
+            "message": "Solidifying task requirements...",
+            "task": task,
+        })
+        rephrased_task = task
+        try:
+            rephrased_task = self.rephraser.rephrase(task, self.backend, task_context)
+        except Exception:
+            rephrased_task = task
+
+        yield AgentEvent("status", {
+            "phase": "building",
+            "message": "Starting build...",
+            "rephrased": rephrased_task,
+        })
 
         user_content = self.prompt_builder.build_user_content(
-            task=task,
+            task=rephrased_task,
             image_path=image_path,
             video_path=video_path,
             url=url,
@@ -134,15 +153,19 @@ class AgentOrchestrator:
             "is_offline": is_offline,
             "tool_count": len(active_tools),
             "complexity": complexity,
+            "rephrased_task": rephrased_task,
         })
 
 
 
         # ── Adaptive thinking ──
-        enable_thinking = cfg.enable_thinking or task_context.enable_thinking
-        if enable_thinking and complexity in ("qa", "low"):
-            enable_thinking = False
-            yield AgentEvent("adaptive_mode", {"message": "Simple task detected, skipping deep reasoning."})
+        if cfg.enable_thinking:
+            enable_thinking = True
+        else:
+            enable_thinking = task_context.enable_thinking
+            if enable_thinking and complexity in ("qa", "low"):
+                enable_thinking = False
+                yield AgentEvent("adaptive_mode", {"message": "Simple task detected, skipping deep reasoning."})
 
         # ── Goal-driven turn loop (no fixed limit) ──
         progress_monitor = ProgressMonitor()

alpiecode-7.0.3/src/codeagent/rephraser.py

@@ -0,0 +1,137 @@
+"""
+Prompt rephraser service for AlpieCode.
+
+Internally solidifies raw user prompts into high-grade software engineering
+specifications before agent execution begins. Operates silently behind the scenes.
+"""
+
+import logging
+import re
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+REPHRASER_SYSTEM_PROMPT = """\
+You are an expert AI prompt engineer and principal software architect.
+Your job is to transform the user's raw prompt into a clear, solid, and unambiguous software engineering specification.
+
+Guidelines:
+1. If the prompt is a simple Q&A, greeting, or direct conceptual question (e.g. "what is X?", "explain Y", "hi", "how does Z work"):
+   - Keep it clean, direct, and concise. Do NOT add unnecessary software development boilerplate.
+2. If the prompt is a coding, debugging, refactoring, testing, or feature creation task:
+   - Expand it into a solid, structured engineering prompt with:
+     * Objective: Explicit statement of what needs to be created, modified, or fixed
+     * Scope & Architecture: Target files, patterns, and module structure
+     * Technical Requirements: Key functionality, edge cases, error handling
+     * Quality & Implementation: Complete, production-ready code on Turn 1 with no stubs, placeholders, or missing imports
+     * Verification Criteria: Specific commands or tests to run to verify that the implementation works
+3. Output ONLY the refined prompt text. Do NOT include greetings, conversational remarks, thinking blocks, or preambles like "Here is the refined prompt:".
+"""
+
+
+def _clean_rephrased_text(text: str) -> str:
+    """Clean model output to extract only the actual refined specification."""
+    if not text:
+        return ""
+
+    cleaned = text.strip()
+
+    # 1. Remove <think>...</think> if present
+    cleaned = re.sub(r"<think>.*?</think>", "", cleaned, flags=re.DOTALL).strip()
+
+    # 2. Remove "Thinking Process: ... \n\n" if model output chain-of-thought
+    if "thinking process:" in cleaned.lower():
+        # Look for double newline or start of markdown header after thinking process
+        match = re.search(r"(?:thinking process:.*?\n\n|\bobjective\b|\bscope\b)", cleaned, flags=re.DOTALL | re.IGNORECASE)
+        if match:
+            # If matched starting with objective/scope, slice from there
+            obj_match = re.search(r"(\*\*objective\*\*|objective:|#\s+objective|\*\*goal\*\*)", cleaned, flags=re.IGNORECASE)
+            if obj_match:
+                cleaned = cleaned[obj_match.start():].strip()
+
+    # 3. Clean any leading conversational fluff
+    fluff_prefixes = [
+        "here is the refined prompt:",
+        "here is the solidified prompt:",
+        "refined prompt:",
+        "solidified prompt:",
+        "here is a solid prompt:",
+        "here is the specification:",
+        "refined specification:",
+    ]
+    for prefix in fluff_prefixes:
+        if cleaned.lower().startswith(prefix):
+            cleaned = cleaned[len(prefix):].strip()
+            break
+
+    # 4. Strip outer code fences if accidentally wrapped
+    if cleaned.startswith("```") and cleaned.endswith("```"):
+        lines = cleaned.splitlines()
+        if len(lines) >= 3:
+            cleaned = "\n".join(lines[1:-1]).strip()
+
+    return cleaned.strip()
+
+
+class PromptRephraser:
+    """Refines and solidifies tasks into rigorous engineering specifications."""
+
+    def __init__(self, system_prompt: str = REPHRASER_SYSTEM_PROMPT):
+        self.system_prompt = system_prompt
+
+    def rephrase(
+        self,
+        task: str,
+        backend: Any,
+        task_context: Optional[Any] = None,
+        timeout: float = 6.0,
+    ) -> str:
+        """Solidify user task into a high-grade prompt internally.
+
+        Fails open: returns original task if rephrasing fails, times out,
+        or if backend is unavailable.
+        """
+        if not task or not task.strip():
+            return task
+
+        # If pure trivial greeting, skip model call for instant response
+        clean_task = task.strip().lower()
+        if clean_task in ("hi", "hello", "hey", "help", "ping", "exit", "quit"):
+            return task
+
+        # Check if backend is available
+        if backend is None or not getattr(backend, "is_available", True):
+            return task
+
+        try:
+            messages = [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": f"User Task:\n{task.strip()}"},
+            ]
+
+            # Invoke backend with enable_thinking=False for ultra-fast, deterministic response
+            kwargs = {
+                "messages": messages,
+                "temperature": 0.0,
+                "max_tokens": 1024,
+            }
+            try:
+                response = backend.chat_completion(**kwargs, enable_thinking=False)
+            except TypeError:
+                response = backend.chat_completion(**kwargs)
+
+            refined = ""
+            if hasattr(response, "content") and response.content:
+                refined = response.content.strip()
+            elif isinstance(response, dict):
+                refined = response.get("content", "").strip()
+
+            if not refined:
+                return task
+
+            cleaned = _clean_rephrased_text(refined)
+            return cleaned if cleaned else task
+
+        except Exception as e:
+            logger.debug(f"Prompt rephrasing skipped due to exception: {e}")
+            return task