alpiecode 5.1.1__tar.gz → 6.0.0__tar.gz

{alpiecode-5.1.1 → alpiecode-6.0.0}/PKG-INFO

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

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

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 5.1.1
+Version: 6.0.0
 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-5.1.1 → alpiecode-6.0.0}/src/codeagent/agent.py

@@ -37,6 +37,7 @@ _build_system_prompt = lambda workdir, is_offline=False: PromptBuilder().build_s
 try:
     from rich.console import Console
     from rich.markdown import Markdown
+    from rich.markup import escape
     from rich.panel import Panel
     from rich.rule import Rule
     from rich.text import Text
@@ -46,6 +47,9 @@ try:
 except ImportError:
     HAS_RICH = False
 
+    def escape(text: str) -> str:
+        return text
+
     class _FallbackConsole:
         def print(self, *args, **kwargs):
             kwargs.pop("style", None)
@@ -78,7 +82,7 @@ def _print_tool_call(turn: int, name: str, args: dict):
     if HAS_RICH:
         args_str = json.dumps(display_args, indent=2)
         console.print(f"\n🔧 [bold cyan]Tool:[/bold cyan] [bold]{name}[/bold]", highlight=False)
-        console.print(f"   {args_str}", style="cyan", highlight=False)
+        console.print(Text(f"   {args_str}", style="cyan"))
     else:
         console.print(f"\n🔧 Tool: {name}({display_args})")
 
@@ -86,7 +90,7 @@ def _print_tool_call(turn: int, name: str, args: dict):
 def _print_tool_result(result: str):
     truncated = result[:1500] + ("..." if len(result) > 1500 else "")
     if HAS_RICH:
-        console.print(f"   → {truncated}", style="green", highlight=False)
+        console.print(Text(f"   → {truncated}", style="green"))
     else:
         console.print(f"   → {truncated}")
 
@@ -97,7 +101,7 @@ def _print_assistant_message(content: str):
             md = Markdown(content)
             console.print(Panel(md, title="🤖 Assistant", border_style="green", padding=(0, 1)))
         except Exception:
-            console.print(Panel(content, title="🤖 Assistant", border_style="green", padding=(0, 1)))
+            console.print(Panel(Text(content), title="🤖 Assistant", border_style="green", padding=(0, 1)))
     else:
         console.print(f"\n🤖 Assistant: {content}")
 
@@ -225,7 +229,7 @@ def run_agent(
             data = event.data
             if HAS_RICH:
                 console.rule("[bold blue]Agent Started[/bold blue]")
-                console.print(f"📋 Task: {task.splitlines()[0]}", style="bold")
+                console.print(Text(f"📋 Task: {task.splitlines()[0]}", style="bold"))
                 if github_repo:
                     console.print(f"🐙 GitHub Repo: {github_repo}", style="cyan")
                 if image_path:
@@ -288,8 +292,9 @@ def run_agent(
             _checkpoint(workdir, "checkpoint: response")
 
         elif event.type == "fallback" and verbose:
+            err_str = escape(str(event.data.get('error', '')))
             if HAS_RICH:
-                console.print(f"\n⚠️  [bold yellow]Online Server Error / Timeout[/bold yellow] ({event.data['error']})", style="yellow")
+                console.print(f"\n⚠️  [bold yellow]Online Server Error / Timeout[/bold yellow] ({err_str})", style="yellow")
                 console.print("🔄 [bold cyan]Auto-falling back to local GGUF engine...[/bold cyan]", style="cyan")
             else:
                 print(f"\n⚠️ Online Server Error: {event.data['error']}")
@@ -297,7 +302,7 @@ def run_agent(
 
         elif event.type == "error" and verbose:
             if HAS_RICH:
-                console.print(f"\n❌ [bold red]Model Error[/bold red]\n   Error: {event.data['error']}\n")
+                console.print(Text(f"\n❌ Model Error\n   Error: {event.data['error']}\n", style="bold red"))
             else:
                 print(f"\n❌ Model Error: {event.data['error']}")
 
@@ -385,7 +390,10 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
                 _checkpoint(workdir, "checkpoint: done")
 
             elif event.type == "error":
-                console.print(f"❌ Model error: {event.data['error']}", style="bold red" if HAS_RICH else None)
+                if HAS_RICH:
+                    console.print(Text(f"❌ Model error: {event.data['error']}", style="bold red"))
+                else:
+                    print(f"❌ Model error: {event.data['error']}")
 
             elif event.type == "done":
                 break

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/cli.py

@@ -162,6 +162,7 @@ def main():
     if args.command == "run":
         if args.max_turns:
             cfg.max_turns = args.max_turns
+            cfg._explicit_max_turns = True
         _show_banner()
         from .agent import run_agent
         run_agent(
@@ -177,6 +178,7 @@ def main():
     elif args.command == "chat":
         if args.max_turns:
             cfg.max_turns = args.max_turns
+            cfg._explicit_max_turns = True
         _show_banner()
         from .agent import run_chat
         run_chat(Path(args.workdir), cfg, verbose=not args.quiet)

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/compaction.py

@@ -20,7 +20,7 @@ MAX_CONTEXT_TOKENS = 262_144
 # Start compacting when we hit this percentage of the context window
 COMPACT_THRESHOLD = 0.70
 # Number of recent turns to always keep intact
-KEEP_RECENT_TURNS = 20
+KEEP_RECENT_TURNS = 12
 # Approximate chars per token (rough heuristic)
 CHARS_PER_TOKEN = 4
 

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/discovery.py

@@ -178,16 +178,18 @@ def detect_environment() -> dict:
 
 
 def _detect_shell(os_name: str) -> str:
-    """Detect available shell, preferring WSL on Windows like Claude/Codex agents."""
+    """Detect available shell, aligned with tools.py execution path."""
 
     if os_name == "windows":
-        # On Windows: prefer WSL (like Claude, Codex, Gemini agents do)
+        # Check if bash binary exists (Git Bash / MSYS)
+        if shutil.which("bash"):
+            return "bash"
         if _is_wsl_available():
             return "wsl"
         # Fallback to PowerShell
         if shutil.which("powershell") or shutil.which("pwsh"):
             return "powershell"
-        return "cmd"
+        return "cmd" 
 
     if os_name in ("linux", "wsl"):
         return "bash"  # Standard on Linux/WSL
@@ -466,13 +468,14 @@ def compute_complexity(intent: str, repo_info: dict, task: str) -> str:
 
     # -- MEDIUM: multi-step tasks --
     medium_keywords = [
-        "api", "rest api", "graphql", "server",
-        "game", "snake", "tetris", "chess", "pong", "sudoku",
-        "website", "web page", "web app", "webapp",
-        "test suite", "unit tests", "integration test",
-        "dashboard", "portfolio",
-        "react", "vue", "angular", "next.js",
-        "django", "flask app", "fastapi app",
+        "api", "rest api", "graphql", "server", "backend", "frontend",
+        "game", "snake", "tetris", "chess", "pong", "sudoku", "flappy", "arcade",
+        "website", "web page", "web app", "webapp", "html", "css", "javascript",
+        "test suite", "unit tests", "integration test", "e2e test",
+        "dashboard", "portfolio", "application", "app with", "notes app", "todo app",
+        "react", "vue", "angular", "next.js", "tailwind",
+        "django", "flask app", "fastapi app", "express",
+        "refactor", "migrate", "redesign", "restructure", "investigate",
     ]
     if any(kw in task_lower for kw in medium_keywords):
         return "medium"
@@ -503,19 +506,19 @@ COMPLEXITY_CONFIG = {
         "enable_thinking": False,
     },
     "low": {
-        "max_turns": 10,
+        "max_turns": 15,
         "max_tokens": 8192,
         "tool_set": "core",
         "enable_thinking": False,
     },
     "medium": {
-        "max_turns": 20,
-        "max_tokens": 8192,
+        "max_turns": 40,
+        "max_tokens": 16384,
         "tool_set": "full",
-        "enable_thinking": False,
+        "enable_thinking": True,
     },
     "high": {
-        "max_turns": 40,
+        "max_turns": 60,
         "max_tokens": 16384,
         "tool_set": "full",
         "enable_thinking": True,

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/guardian.py

@@ -16,12 +16,17 @@ from typing import Tuple
 try:
     from rich.console import Console
     from rich.panel import Panel
+    from rich.text import Text
+    from rich.markup import escape
     console = Console()
     HAS_RICH = True
 except ImportError:
     HAS_RICH = False
     console = None
 
+    def escape(text: str) -> str:
+        return text
+
 
 class RiskLevel(Enum):
     SAFE = "safe"
@@ -134,19 +139,19 @@ def gate_command(command: str, auto_approve: bool = False) -> bool:
     if risk == RiskLevel.WARNING:
         if auto_approve:
             if HAS_RICH:
-                console.print(f"   ⚠️  [yellow]{reason}[/yellow]", highlight=False)
+                console.print(Text(f"   ⚠️  {reason}", style="yellow"))
             return True
         # In interactive mode, show warning but proceed
         if HAS_RICH:
-            console.print(f"   ⚠️  [yellow]{reason}[/yellow]", highlight=False)
+            console.print(Text(f"   ⚠️  {reason}", style="yellow"))
         return True
 
     if risk == RiskLevel.DANGEROUS:
         if HAS_RICH:
             console.print(Panel(
                 f"[bold red]🛑 BLOCKED — Dangerous Command[/bold red]\n\n"
-                f"Command: [cyan]{command}[/cyan]\n"
-                f"Reason: {reason}\n\n"
+                f"Command: [cyan]{escape(command)}[/cyan]\n"
+                f"Reason: {escape(reason)}\n\n"
                 f"This command has been blocked for safety.\n"
                 f"If you need to run it, do so manually in your terminal.",
                 border_style="red",

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/orchestrator.py

@@ -77,7 +77,7 @@ class AgentOrchestrator:
         effective_max_tokens = task_context.max_tokens
 
         # User override: if they set --max-turns explicitly, respect it
-        if cfg.max_turns != 20:  # 20 is new default, so non-default = explicit
+        if getattr(cfg, "_explicit_max_turns", False):
             effective_max_turns = cfg.max_turns
 
         # ── Response cache check ──
@@ -137,6 +137,13 @@ class AgentOrchestrator:
             "complexity": complexity,
         })
 
+        if complexity in ("medium", "high"):
+            session.context.add_user_message(
+                f"[BUDGET & GOAL] Available turn budget: {effective_max_turns} turns. "
+                "Plan the needed components, create the complete files, verify with bash, "
+                "and finish with DONE: <summary> as soon as verification succeeds."
+            )
+
         # ── Adaptive thinking ──
         enable_thinking = cfg.enable_thinking or task_context.enable_thinking
         if enable_thinking and complexity in ("qa", "low"):
@@ -155,17 +162,27 @@ class AgentOrchestrator:
             if session.context.check_and_compact():
                 yield AgentEvent("compaction", {"turn": turn + 1})
 
-            # ── Wrap-up injection at 80% of turns ──
-            if not wrap_up_injected and turn >= int(effective_max_turns * 0.8):
+            # ── Progressive wrap-up injection ──
+            # Step 1: Gentle verification reminder at 70%
+            if not wrap_up_injected and turn >= int(effective_max_turns * 0.70):
                 wrap_up_injected = True
                 remaining = effective_max_turns - turn
                 session.context.add_user_message(
-                    f"[SYSTEM] You have {remaining} turns remaining. "
-                    "Finish your current work now. If code is written and tested, "
-                    "output DONE: <summary>. If code has errors, make one final fix attempt."
+                    f"[SYSTEM] Turn budget update: {remaining} turns remaining. "
+                    "Ensure all necessary files are created and run verification tests now. "
+                    "As soon as verification succeeds, output DONE: <summary>."
                 )
                 yield AgentEvent("wrap_up", {"turn": turn + 1, "remaining": remaining})
 
+            # Step 2: Final wrap-up call at 90%
+            if not getattr(self, "_final_wrap_up_injected", False) and turn >= int(effective_max_turns * 0.90):
+                self._final_wrap_up_injected = True
+                remaining = effective_max_turns - turn
+                session.context.add_user_message(
+                    f"[SYSTEM] FINAL TURNS: Only {remaining} turns remaining. "
+                    "Do not start new exploration. Fix any remaining errors and output DONE: <summary>."
+                )
+
             yield AgentEvent("turn_start", {"turn": turn + 1})
 
             try:

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/prompt.py

@@ -339,19 +339,19 @@ COMPLEXITY_CONFIG = {
         "prompt": "default",
     },
     "low": {
-        "max_turns": 10,
+        "max_turns": 15,
         "max_tokens": 8192,
         "tools": "core",  # 5 core tools
         "prompt": "default",
     },
     "medium": {
-        "max_turns": 20,
-        "max_tokens": 8192,
+        "max_turns": 40,
+        "max_tokens": 16384,
         "tools": "full",  # All 15 tools
         "prompt": "default",
     },
     "high": {
-        "max_turns": 40,
+        "max_turns": 60,
         "max_tokens": 16384,
         "tools": "full",  # All 15 tools
         "prompt": "high",  # Detailed system prompt
@@ -408,7 +408,7 @@ REPO_CONTEXT_TEMPLATE = """\
 {extra}"""
 
 INTENT_CREATE = """\
-## Task Intent: Create New Code
+## Task Intent: Create New Code (Single-file / Simple Tasks)
 - Write the COMPLETE, WORKING code on Turn 1 using write_file
 - Do NOT explore the filesystem first -- start coding immediately
 - Include ALL imports, ALL functions, ALL logic -- no stubs, no TODOs
@@ -417,6 +417,23 @@ INTENT_CREATE = """\
 - When everything works: DONE: <summary>
 """
 
+INTENT_CREATE_COMPLEX = """\
+## Task Intent: Create Multi-Component Code (Medium/High Complexity)
+- Turn 1: Think through and plan the architecture. Identify ALL files needed (e.g. HTML, CSS, JS, tests).
+- Sequential Creation: Write each file completely using write_file in logical dependency order.
+- No Thrashing: Do NOT delete files you just created with `rm`. If adjustments are needed, use edit_file or overwrite directly.
+- Verification: After writing the files, run or verify them using bash (e.g. run test suite, build check, or verify syntax).
+- Early Stopping: Once verified and working, output: DONE: <summary> immediately. Do not run redundant checks.
+"""
+
+GOAL_DRIVEN_RULES = """\
+## Execution & Goal Convergence Rules
+- Efficiency First: Plan your actions to minimize wasted turns. You can execute multiple tool calls in a single turn.
+- No Thrashing: NEVER delete a file (e.g. `rm <file>`) immediately after creating it to start over. Use `edit_file` to modify what needs fixing.
+- Immediate Completion: As soon as your code is written and verified, output `DONE: <summary>`. Do NOT linger or rerun commands that already passed.
+- Targeted Editing: If `edit_file` fails, use `read_file` to inspect the exact lines and whitespace before attempting another edit.
+"""
+
 INTENT_MODIFY = """\
 ## Task Intent: Modify Existing Code
 - Turn 1: Use read_file to read the relevant file(s)
@@ -492,13 +509,19 @@ class PromptBuilder:
             # Inject intent-specific workflow
             intent = getattr(task_context, "intent", "create")
             if intent == "create":
-                prompt += "\n\n" + INTENT_CREATE
+                if complexity in ("medium", "high"):
+                    prompt += "\n\n" + INTENT_CREATE_COMPLEX
+                else:
+                    prompt += "\n\n" + INTENT_CREATE
             elif intent == "modify":
                 prompt += "\n\n" + INTENT_MODIFY
             elif intent == "debug":
                 prompt += "\n\n" + INTENT_DEBUG
             elif intent == "explain":
                 prompt += "\n\n" + INTENT_EXPLAIN
+
+            if complexity in ("medium", "high"):
+                prompt += "\n\n" + GOAL_DRIVEN_RULES
             # qa intent: no extra prompt needed (model answers directly)
 
         memories = format_memories_for_prompt(workdir)

{alpiecode-5.1.1 → alpiecode-6.0.0}/src/codeagent/tools.py

@@ -1,3 +1,5 @@
+_RECENTLY_WRITTEN_FILES = set()
+
 """
 Tool definitions and implementations for AlpieCode.
 
@@ -437,11 +439,11 @@ def _bash(workdir: Path, command: str) -> str:
             shell_cmd,
             cwd=workdir, capture_output=True, text=True,
             stdin=subprocess.DEVNULL,
-            timeout=30, env=env,
+            timeout=120, env=env,
         )
 
-        stdout = _smart_truncate(result.stdout, 6000)
-        stderr = _smart_truncate(result.stderr, 4000)
+        stdout = _smart_truncate(result.stdout, 3000)
+        stderr = _smart_truncate(result.stderr, 2000)
 
         output = json.dumps({
             "stdout": stdout,
@@ -463,6 +465,20 @@ def _bash(workdir: Path, command: str) -> str:
                 )
             output = hint + output
 
+        # ── Anti-thrashing guard: warned if deleting file created in this session ──
+        cmd_parts = command.strip().split()
+        if cmd_parts and cmd_parts[0] in ("rm", "del", "Remove-Item"):
+            for part in cmd_parts[1:]:
+                base_part = Path(part.strip('"\'')).name.lower()
+                if base_part in _RECENTLY_WRITTEN_FILES:
+                    _RECENTLY_WRITTEN_FILES.discard(base_part)
+                    output += (
+                        f"\n\n💡 ADVICE: You deleted '{base_part}' which was created in a recent turn. "
+                        "Avoid deleting and rewriting entire files from scratch. "
+                        "For iterative improvements, use edit_file or overwrite directly with write_file."
+                    )
+                    break
+
         # ── Smart Guardrail 2: Silent success — script ran but no output ──
         elif result.returncode == 0 and not stdout.strip() and not stderr.strip():
             script_file = _extract_script_path(command)
@@ -505,7 +521,8 @@ def _read_file(workdir: Path, path: str, start_line: int = None, end_line: int =
 def _write_file(workdir: Path, path: str, content: str) -> str:
     p = workdir / path
     p.parent.mkdir(parents=True, exist_ok=True)
-    p.write_text(content)
+    p.write_text(content, encoding="utf-8")
+    _RECENTLY_WRITTEN_FILES.add(Path(path).name.lower())
     return f"wrote {len(content)} bytes to {path}"
 
 
@@ -513,13 +530,25 @@ def _edit_file(workdir: Path, path: str, old_str: str, new_str: str) -> str:
     p = workdir / path
     if not p.exists():
         return f"error: file not found: {path}"
-    text = p.read_text()
+    text = p.read_text(encoding="utf-8", errors="replace")
     count = text.count(old_str)
     if count == 0:
-        return "error: old_str not found in file. Make sure it matches exactly (including whitespace)."
+        import difflib
+        lines = text.splitlines()
+        old_lines = [ol.strip() for ol in old_str.splitlines() if ol.strip()]
+        target_line = old_lines[0] if old_lines else old_str.strip()
+        close_matches = difflib.get_close_matches(target_line, [l.strip() for l in lines], n=3, cutoff=0.3)
+        nearby = [(i + 1, l) for i, l in enumerate(lines) if l.strip() in close_matches]
+        hint = ""
+        if nearby:
+            hint = "\nClosest matching lines in file:\n" + "\n".join(f"  Line {n}: {l.strip()[:80]}" for n, l in nearby[:3])
+        return (
+            f"error: old_str not found in file '{path}'. It must match existing text EXACTLY (including whitespace/indentation).{hint}\n"
+            f"→ Action: Run read_file on '{path}' around these lines to see the exact whitespace, then retry edit_file."
+        )
     if count > 1:
-        return f"error: old_str matched {count} times, need exactly 1 match. Use a more specific old_str."
-    p.write_text(text.replace(old_str, new_str, 1))
+        return f"error: old_str matched {count} times in '{path}'. Must match exactly 1 occurrence. Include more surrounding lines in old_str to make it unique."
+    p.write_text(text.replace(old_str, new_str, 1), encoding="utf-8")
     return "edit applied"
 
 
@@ -689,9 +718,10 @@ def _request_user_input(question: str) -> str:
     try:
         from rich.console import Console
         from rich.panel import Panel
+        from rich.text import Text
         console = Console()
         console.print(Panel(
-            f"[bold]{question}[/bold]",
+            Text(question, style="bold"),
             title="❓ Agent needs your input",
             border_style="yellow",
         ))