alpiecode 3.0.0__tar.gz → 4.0.0__tar.gz

{alpiecode-3.0.0 → alpiecode-4.0.0}/PKG-INFO

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

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

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 3.0.0
+Version: 4.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-3.0.0 → alpiecode-4.0.0}/src/codeagent/__init__.py

@@ -1,3 +1,8 @@
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", module="jupyter_client.*")
+
 """
 AlpieCode — Autonomous AI Coding Agent powered by local 169Pi GGUF VLM & Online API.
 

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/agent.py

@@ -1,3 +1,8 @@
+import warnings
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", module="jupyter_client.*")
+
 """
 CLI agent wrapper and presentation adapter for AlpieCode.
 
@@ -150,6 +155,7 @@ def run_agent(
     url: str = None,
     github_repo: str = None,
     server_url: str = None,
+    complexity: str = None,
 ) -> list:
     """Run non-interactive agent task with Rich presentation."""
     workdir = workdir.resolve()
@@ -173,6 +179,7 @@ def run_agent(
             video_path=video_path,
             url=url,
             github_repo=github_repo,
+            complexity=complexity,
         )
     else:
         backend = resolve_backend(cfg)
@@ -187,6 +194,7 @@ def run_agent(
             video_path=video_path,
             url=url,
             github_repo=github_repo,
+            complexity=complexity,
         )
 
     _checkpoint(workdir, "checkpoint: start")
@@ -209,10 +217,12 @@ def run_agent(
                 console.print(f"📂 Workdir: {workdir}", style="dim")
                 if not data["is_offline"]:
                     console.print(f"🌐 Mode: [bold green]ONLINE[/bold green]", style="dim")
-                    console.print(f"🤖 Model: [bold cyan]alpie_9b[/bold cyan]", style="dim")
                 else:
                     console.print(f"🧠 Mode: [bold yellow]OFFLINE[/bold yellow]", style="dim")
-                    console.print(f"🤖 Model: [bold cyan]alpie_9b (Local GGUF)[/bold cyan]", style="dim")
+                comp = data.get("complexity", "low")
+                comp_label = {"qa": "Q&A (instant)", "low": "Low (fast)", "medium": "Medium (balanced)", "high": "High (thorough)"}.get(comp, comp)
+                comp_color = {"qa": "cyan", "low": "green", "medium": "yellow", "high": "red"}.get(comp, "white")
+                console.print(f"⚡ Complexity: [bold {comp_color}]{comp_label}[/bold {comp_color}]", style="dim")
                 if cfg.enable_thinking:
                     console.print(f"🧠 Reasoning: [bold green]ON[/bold green]", style="dim")
             else:
@@ -234,6 +244,10 @@ def run_agent(
         elif event.type == "compaction" and verbose:
             console.print("🗜️  Compacting context (approaching token limit)...", style="yellow")
 
+        elif event.type == "wrap_up" and verbose:
+            if HAS_RICH:
+                console.print(f"⏳ [bold yellow]Wrap-up: {event.data['remaining']} turns remaining[/bold yellow]", style="yellow")
+
         elif event.type == "thinking" and verbose:
             _print_reasoning(event.data["content"])
 

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/cli.py

@@ -76,6 +76,7 @@ def main():
     common.add_argument("--max-turns", type=int, default=None, help="Override max turns")
     common.add_argument("--thinking", "--reasoning", dest="thinking", action="store_true", help="Enable VLM reasoning mode")
     common.add_argument("--no-thinking", "--non-thinking", dest="no_thinking", action="store_true", help="Disable VLM reasoning mode")
+    common.add_argument("--complexity", choices=["low", "medium", "high"], default=None, help="Task complexity: low (fast, 10 turns), medium (balanced, 20 turns), high (thorough, 40 turns)")
     common.add_argument("--no-update", action="store_true", help="Skip automatic update check")
     common.add_argument("--quiet", action="store_true", help="Suppress per-turn logging")
 
@@ -166,6 +167,7 @@ def main():
             image_path=args.image,
             video_path=getattr(args, "video", None),
             url=getattr(args, "url", None),
+            complexity=getattr(args, "complexity", None),
             github_repo=getattr(args, "github", None),
         )
 

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/client.py

@@ -73,6 +73,7 @@ class AlpieCodeClient:
         video_path: Optional[str] = None,
         url: Optional[str] = None,
         github_repo: Optional[str] = None,
+        complexity: Optional[str] = None,
     ) -> Iterator[AgentEvent]:
         """
         Stream agent events from POST /chat using Server-Sent Events (SSE).

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/config.py

@@ -18,7 +18,7 @@ CONFIG_DIR = Path.home() / ".alpiecode"
 CONFIG_PATH = CONFIG_DIR / "config.json"
 
 # Config version — bump this when defaults change to trigger auto-migration
-CONFIG_VERSION = 5  # v5: model alpie_9b, reasoning OFF by default, clean display
+CONFIG_VERSION = 6  # v6: smart flow, max_turns 20, complexity-aware
 
 DEFAULTS = {
     "base_url": "http://20.245.200.125:8000/v1",  # Primary endpoint
@@ -26,7 +26,7 @@ DEFAULTS = {
     "model_repo": "169Pi/Alpie_learn_prototype_GGUF_NEW",
     "api_key": "not-needed",
     "hf_token": None,
-    "max_turns": 50,
+    "max_turns": 20,
     "temperature": 0.1,
     "max_tokens": 8192,
     "enable_thinking": False,  # Reasoning OFF by default
@@ -88,7 +88,7 @@ class Config:
     model_repo: str = "169Pi/Alpie_learn_prototype_GGUF_NEW"  # HuggingFace repo for offline GGUF
     api_key: str = "not-needed"
     hf_token: Optional[str] = None
-    max_turns: int = 50
+    max_turns: int = 20
     temperature: float = 0.1
     max_tokens: int = 8192
     enable_thinking: bool = False
@@ -111,12 +111,13 @@ def load_config() -> Config:
                 # v1 → v2: n_ctx was 16384, upgrade to 32768
                 if saved_data.get("n_ctx") == 16384:
                     data["n_ctx"] = 32768
-                # v4 → v5: model alpie_9b, reasoning OFF default
+                # v5 → v6: smart flow, max_turns 20
                 data["base_url"] = "http://20.245.200.125:8000/v1"
                 data["model"] = "alpie_9b"
                 data["enable_thinking"] = False
                 data["temperature"] = 0.1
                 data["max_tokens"] = 8192
+                data["max_turns"] = 20
                 data["config_version"] = CONFIG_VERSION
                 needs_save = True
         except Exception:

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/ipython_ext.py

@@ -11,9 +11,16 @@ and Google Colab via cell/line magic commands and rich interactive displays:
 """
 
 import sys
+import warnings
 from pathlib import Path
 from typing import Optional
 
+# Suppress noisy Jupyter / Python 3.12+ deprecation warnings (e.g. datetime.utcnow in jupyter_client)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", module="jupyter_client.*")
+warnings.filterwarnings("ignore", module="ipykernel.*")
+
 from .config import load_config
 from .agent import run_agent
 
@@ -42,6 +49,15 @@ def _display_html(html_str: str):
         print(html_str)
 
 
+def _display_markdown(md_str: str):
+    """Render rich Markdown in Jupyter or Google Colab."""
+    try:
+        from IPython.display import Markdown, display
+        display(Markdown(md_str))
+    except Exception:
+        print(md_str)
+
+
 def alpie_magic(line: str, cell: Optional[str] = None):
     """
     %alpie <task>        (line magic)

{alpiecode-3.0.0 → alpiecode-4.0.0}/src/codeagent/orchestrator.py

@@ -1,40 +1,31 @@
 """
 Agent orchestrator for AlpieCode.
 
-Coordinates inference backends, context management, prompt construction, and tool execution.
-Yields a stream of transport-agnostic AgentEvent objects.
+Owns the turn loop, backend resolution, caching, and event stream.
 """
 
-import json
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Dict, Iterator, Optional
+import copy
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterator, List, Optional
 
-from .backends.base import ChatResponse, InferenceBackend, ToolCall
+from .backends.base import InferenceBackend, ChatResponse
 from .backends.local_backend import LocalBackend
 from .backends.openai_backend import OpenAIBackend
 from .cache import get_cache
 from .config import Config, is_server_reachable
-from .context import ContextManager
-from .executor import ToolExecutor, ToolResult
 from .memory import extract_and_save_memories
-from .prompt import PromptBuilder, is_simple_task
+from .prompt import PromptBuilder, classify_task, COMPLEXITY_CONFIG
 from .session import Session, SessionManager
 
 
 @dataclass
 class AgentEvent:
-    """Structured event yielded by the orchestrator."""
     type: str
     data: Dict[str, Any]
 
 
 def resolve_backend(cfg: Config, timeout: float = 2.0) -> InferenceBackend:
-    """Resolve online vs offline backend based on server reachability.
-
-    Uses a generous timeout at startup (2s default) to avoid false negatives
-    when the remote API is slow to respond (e.g. Azure VM cold start).
-    """
+    """Resolve online vs offline backend based on server reachability."""
     if is_server_reachable(cfg.base_url, timeout=timeout):
         return OpenAIBackend(cfg)
     return LocalBackend(cfg)
@@ -60,12 +51,25 @@ class AgentOrchestrator:
         video_path: Optional[str] = None,
         url: Optional[str] = None,
         github_repo: Optional[str] = None,
+        complexity: Optional[str] = None,
     ) -> Iterator[AgentEvent]:
-        """
-        Run full agent task loop for a session. Yields AgentEvents.
-        """
-        # ── Response cache check (instant return for repeated prompts) ──
-        # Only cache pure text prompts (no images, videos, URLs, or GitHub repos)
+        """Run full agent task loop. Yields AgentEvents."""
+
+        # ── Auto-classify complexity if not provided ──
+        if complexity is None:
+            complexity = classify_task(task)
+
+        comp_cfg = COMPLEXITY_CONFIG.get(complexity, COMPLEXITY_CONFIG["low"])
+
+        # ── Determine effective max_turns and max_tokens ──
+        effective_max_turns = min(cfg.max_turns, comp_cfg["max_turns"])
+        effective_max_tokens = comp_cfg["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
+            effective_max_turns = cfg.max_turns
+
+        # ── Response cache check ──
         is_cacheable = not any([image_path, video_path, url, github_repo])
         if is_cacheable:
             cache = get_cache()
@@ -77,6 +81,7 @@ class AgentOrchestrator:
                     "backend": "cache",
                     "is_offline": False,
                     "tool_count": 0,
+                    "complexity": complexity,
                 })
                 yield AgentEvent("cache_hit", {
                     "message": "Returning cached response (instant)",
@@ -87,19 +92,18 @@ class AgentOrchestrator:
                 yield AgentEvent("done", {"summary": cached["response"]})
                 return
 
-        # Dynamic backend re-check: if currently on LocalBackend but remote
-        # API is now reachable, switch to OnlineBackend automatically.
-        # This handles the case where the server started offline but the
-        # remote API came online later (e.g. VM cold start, network hiccup).
+        # ── Dynamic backend re-check ──
         if isinstance(self.backend, LocalBackend) and is_server_reachable(cfg.base_url, timeout=1.5):
             self.backend = OpenAIBackend(cfg)
 
         is_offline = not self.backend.is_available or isinstance(self.backend, LocalBackend)
         session.is_offline = is_offline
 
-        # Configure tools & system prompt
-        active_tools = self.prompt_builder.get_tools(is_offline=is_offline)
-        system_prompt = self.prompt_builder.build_system_prompt(session.workdir, is_offline=is_offline)
+        # ── Configure tools & system prompt based on complexity ──
+        active_tools = self.prompt_builder.get_tools(is_offline=is_offline, complexity=complexity)
+        system_prompt = self.prompt_builder.build_system_prompt(
+            session.workdir, is_offline=is_offline, complexity=complexity
+        )
         session.context.set_system_prompt(system_prompt)
 
         user_content = self.prompt_builder.build_user_content(
@@ -118,50 +122,65 @@ class AgentOrchestrator:
             "backend": self.backend.name,
             "is_offline": is_offline,
             "tool_count": len(active_tools),
+            "complexity": complexity,
         })
 
-        # Adaptive thinking check
+        # ── Adaptive thinking ──
         enable_thinking = cfg.enable_thinking
-        if enable_thinking and is_simple_task(task):
+        if enable_thinking and complexity in ("qa", "low"):
             enable_thinking = False
             yield AgentEvent("adaptive_mode", {"message": "Simple task detected, skipping deep reasoning."})
 
-        for turn in range(cfg.max_turns):
+        # ── Turn loop ──
+        wrap_up_injected = False
+
+        for turn in range(effective_max_turns):
             if session.cancelled:
                 yield AgentEvent("cancelled", {"turn": turn + 1})
                 break
 
-            # Context compaction check
+            # Context compaction
             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):
+                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."
+                )
+                yield AgentEvent("wrap_up", {"turn": turn + 1, "remaining": remaining})
+
             yield AgentEvent("turn_start", {"turn": turn + 1})
 
             try:
                 if enable_thinking:
-                    max_tokens = 4096 if is_offline else max(cfg.max_tokens, 16384)
+                    max_tokens = 4096 if is_offline else max(effective_max_tokens, 16384)
                 else:
-                    max_tokens = 2048 if is_offline else cfg.max_tokens
+                    max_tokens = 2048 if is_offline else effective_max_tokens
 
                 resp = self.backend.chat_completion(
                     messages=session.context.messages,
-                    tools=active_tools,
+                    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 auto-fallback attempt
+                # Online error -> fallback to local
                 if not is_offline and isinstance(self.backend, OpenAIBackend):
                     yield AgentEvent("fallback", {"error": str(e), "message": "Falling back to local engine"})
                     self.backend = LocalBackend(cfg)
                     session.is_offline = True
                     is_offline = True
-                    active_tools = self.prompt_builder.get_tools(is_offline=True)
+                    active_tools = self.prompt_builder.get_tools(is_offline=True, complexity=complexity)
                     try:
                         resp = self.backend.chat_completion(
                             messages=session.context.messages,
-                            tools=active_tools,
+                            tools=active_tools if active_tools else None,
                             temperature=cfg.temperature,
                             max_tokens=2048,
                             enable_thinking=enable_thinking,
@@ -178,7 +197,38 @@ class AgentOrchestrator:
 
             session.context.add_assistant_response(resp)
 
-            # Extract tool calls
+            # ── DONE detection in assistant content ──
+            if resp.content and "DONE:" in resp.content.upper():
+                # Model said DONE — finish even if there are tool calls
+                tool_calls = session.executor.extract_tool_calls(resp)
+                if tool_calls:
+                    # Execute final tool calls before finishing
+                    results = session.executor.execute_tool_calls(tool_calls)
+                    for res in results:
+                        yield AgentEvent("tool_result", {
+                            "turn": turn + 1,
+                            "id": res.tool_call_id,
+                            "name": res.name,
+                            "content": res.content,
+                            "duration_ms": res.duration_ms,
+                        })
+                        session.context.add_tool_result(res.tool_call_id, res.content)
+
+                yield AgentEvent("message", {"content": resp.content})
+                extract_and_save_memories(session.workdir, session.context.messages)
+
+                # Cache if single-turn
+                if is_cacheable and turn == 0:
+                    try:
+                        cache = get_cache()
+                        cache.put(task, resp.content, reasoning=resp.reasoning)
+                    except Exception:
+                        pass
+
+                yield AgentEvent("done", {"summary": resp.content})
+                return
+
+            # Extract and execute tool calls
             tool_calls = session.executor.extract_tool_calls(resp)
 
             if tool_calls:
@@ -204,9 +254,8 @@ class AgentOrchestrator:
 
                 continue
 
-            # Assistant text response (no tool calls = cacheable)
+            # Text-only response = done
             if resp.content:
-                # Cache this response — it completed in a single turn without tools
                 if is_cacheable and turn == 0:
                     try:
                         cache = get_cache()
@@ -219,10 +268,10 @@ class AgentOrchestrator:
                 yield AgentEvent("done", {"summary": resp.content})
                 return
 
-            # Exhausted tokens or empty response
+            # Empty response
             extract_and_save_memories(session.workdir, session.context.messages)
             yield AgentEvent("done", {"summary": "Task completed."})
             return
 
-        yield AgentEvent("max_turns_reached", {"max_turns": cfg.max_turns})
+        yield AgentEvent("max_turns_reached", {"max_turns": effective_max_turns})
         extract_and_save_memories(session.workdir, session.context.messages)