alpiecode 0.7.2__tar.gz → 0.8.1__tar.gz

{alpiecode-0.7.2 → alpiecode-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.7.2
+Version: 0.8.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
@@ -12,3 +12,7 @@ Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
 Requires-Dist: imageio-ffmpeg>=0.4.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100.0; extra == "server"
+Requires-Dist: uvicorn>=0.20.0; extra == "server"
+Requires-Dist: sse-starlette>=2.0.0; extra == "server"

{alpiecode-0.7.2 → alpiecode-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "0.7.2"
+version = "0.8.1"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [
@@ -19,6 +19,13 @@ dependencies = [
     "imageio-ffmpeg>=0.4.0",
 ]
 
+[project.optional-dependencies]
+server = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.20.0",
+    "sse-starlette>=2.0.0",
+]
+
 [project.scripts]
 alpiecode = "codeagent.cli:main"
 codeagent = "codeagent.cli:main"

{alpiecode-0.7.2 → alpiecode-0.8.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.7.2
+Version: 0.8.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
@@ -12,3 +12,7 @@ Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0
 Requires-Dist: imageio-ffmpeg>=0.4.0
+Provides-Extra: server
+Requires-Dist: fastapi>=0.100.0; extra == "server"
+Requires-Dist: uvicorn>=0.20.0; extra == "server"
+Requires-Dist: sse-starlette>=2.0.0; extra == "server"

{alpiecode-0.7.2 → alpiecode-0.8.1}/src/alpiecode.egg-info/SOURCES.txt

@@ -11,10 +11,20 @@ src/codeagent/agent.py
 src/codeagent/cli.py
 src/codeagent/compaction.py
 src/codeagent/config.py
+src/codeagent/context.py
+src/codeagent/executor.py
 src/codeagent/github.py
 src/codeagent/guardian.py
 src/codeagent/local_model.py
 src/codeagent/media.py
 src/codeagent/memory.py
+src/codeagent/orchestrator.py
+src/codeagent/prompt.py
+src/codeagent/server.py
+src/codeagent/session.py
 src/codeagent/tools.py
-src/codeagent/updater.py
+src/codeagent/updater.py
+src/codeagent/backends/__init__.py
+src/codeagent/backends/base.py
+src/codeagent/backends/local_backend.py
+src/codeagent/backends/openai_backend.py

{alpiecode-0.7.2 → alpiecode-0.8.1}/src/alpiecode.egg-info/requires.txt

@@ -7,3 +7,8 @@ duckduckgo-search>=7.0.0
 beautifulsoup4>=4.12.0
 yt-dlp>=2024.0.0
 imageio-ffmpeg>=0.4.0
+
+[server]
+fastapi>=0.100.0
+uvicorn>=0.20.0
+sse-starlette>=2.0.0

alpiecode-0.8.1/src/codeagent/agent.py

@@ -0,0 +1,331 @@
+"""
+CLI agent wrapper and presentation adapter for AlpieCode.
+
+Delegates agent orchestration to AgentOrchestrator and handles Rich terminal UI output.
+"""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .config import Config, is_server_reachable
+from .context import ContextManager, _serialize_assistant_message
+from .executor import READ_ONLY_TOOLS, ToolExecutor, parse_text_tool_calls as _parse_text_tool_calls
+from .orchestrator import AgentEvent, AgentOrchestrator, resolve_backend
+from .prompt import (
+    OFFLINE_SYSTEM_PROMPT,
+    OFFLINE_TOOLS,
+    SYSTEM_PROMPT,
+    PromptBuilder,
+    is_simple_task as _is_simple_task,
+)
+from .session import SessionManager
+
+# Re-export for backward compatibility
+_build_system_prompt = lambda workdir, is_offline=False: PromptBuilder().build_system_prompt(workdir, is_offline)
+
+
+# ── Rich console setup ────────────────────────────────────────────────
+
+try:
+    from rich.console import Console
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.rule import Rule
+    from rich.text import Text
+
+    console = Console()
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+
+    class _FallbackConsole:
+        def print(self, *args, **kwargs):
+            kwargs.pop("style", None)
+            kwargs.pop("highlight", None)
+            print(*args, **kwargs)
+
+        def rule(self, title="", **kwargs):
+            print(f"\n{'─' * 20} {title} {'─' * 20}")
+
+    console = _FallbackConsole()
+
+
+def _print_reasoning(reasoning: str):
+    if not reasoning or not reasoning.strip():
+        return
+    if HAS_RICH:
+        text = Text(reasoning.strip(), style="dim italic")
+        console.print(Panel(text, title="💭 Thinking", border_style="dim blue", padding=(0, 1)))
+    else:
+        console.print(f"\n💭 Thinking: {reasoning.strip()}")
+
+
+def _print_tool_call(turn: int, name: str, args: dict):
+    display_args = {}
+    for k, v in args.items():
+        if isinstance(v, str) and len(v) > 200:
+            display_args[k] = v[:200] + "..."
+        else:
+            display_args[k] = v
+    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)
+    else:
+        console.print(f"\n🔧 Tool: {name}({display_args})")
+
+
+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)
+    else:
+        console.print(f"   → {truncated}")
+
+
+def _print_assistant_message(content: str):
+    if HAS_RICH:
+        try:
+            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)))
+    else:
+        console.print(f"\n🤖 Assistant: {content}")
+
+
+# ── Git helpers ───────────────────────────────────────────────────────
+
+def _is_safe_git_dir(workdir: Path) -> bool:
+    try:
+        home = Path.home().resolve()
+        wd = workdir.resolve()
+        if wd == home or wd == Path("/") or wd == Path("C:\\"):
+            return False
+        try:
+            items = list(wd.iterdir())
+            if len(items) > 500:
+                return False
+        except PermissionError:
+            return False
+    except Exception:
+        return False
+    return True
+
+
+def _ensure_git(workdir: Path) -> None:
+    if not _is_safe_git_dir(workdir):
+        return
+    if not (workdir / ".git").exists():
+        try:
+            subprocess.run(["git", "init"], cwd=workdir, capture_output=True, timeout=10)
+            subprocess.run(["git", "add", "-A"], cwd=workdir, capture_output=True, timeout=30)
+            subprocess.run(["git", "commit", "-m", "initial commit", "--allow-empty"], cwd=workdir, capture_output=True, timeout=10)
+        except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+            pass
+
+
+def _checkpoint(workdir: Path, message: str) -> None:
+    if not (workdir / ".git").exists():
+        return
+    try:
+        subprocess.run(["git", "add", "-A"], cwd=workdir, capture_output=True, timeout=30)
+        subprocess.run(["git", "commit", "-m", message, "--allow-empty"], cwd=workdir, capture_output=True, timeout=10)
+    except (subprocess.TimeoutExpired, FileNotFoundError, Exception):
+        pass
+
+
+# ── Main CLI Agent Functions ──────────────────────────────────────────
+
+def run_agent(
+    task: str,
+    workdir: Path,
+    cfg: Config,
+    verbose: bool = True,
+    image_path: str = None,
+    video_path: str = None,
+    url: str = None,
+    github_repo: str = None,
+) -> list:
+    """Run non-interactive agent task with Rich presentation."""
+    workdir = workdir.resolve()
+    _ensure_git(workdir)
+
+    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)
+
+    _checkpoint(workdir, "checkpoint: start")
+
+    current_turn = 0
+    for event in orchestrator.run_task(
+        session=session,
+        task=task,
+        cfg=cfg,
+        image_path=image_path,
+        video_path=video_path,
+        url=url,
+        github_repo=github_repo,
+    ):
+        if event.type == "start" and verbose:
+            data = event.data
+            if HAS_RICH:
+                console.rule("[bold blue]Agent Started[/bold blue]")
+                console.print(f"📋 Task: {task.splitlines()[0]}", style="bold")
+                if github_repo:
+                    console.print(f"🐙 GitHub Repo: {github_repo}", style="cyan")
+                if image_path:
+                    console.print(f"🖼️  Image: {image_path}", style="cyan")
+                if video_path:
+                    console.print(f"🎬 Video: {video_path}", style="cyan")
+                if url:
+                    console.print(f"📺 URL: {url}", style="cyan")
+                console.print(f"📂 Workdir: {workdir}", style="dim")
+                if not data["is_offline"]:
+                    console.print(f"🌐 Mode: [bold green]ONLINE[/bold green] (Server: {cfg.base_url})", style="dim")
+                    console.print(f"🤖 Model: {cfg.model}", style="dim")
+                else:
+                    console.print(f"🧠 Mode: [bold yellow]OFFLINE[/bold yellow] (Local GGUF GPU Engine)", style="dim")
+                    console.print(f"🧠 Local Model: {cfg.model_repo}", style="dim")
+                    console.print(f"⚡ Context Window: {cfg.n_ctx} tokens", style="dim")
+                console.print(f"🧠 Reasoning: {'ON' if cfg.enable_thinking else 'OFF'}", style="dim")
+                console.print(f"🔧 Tools: {data['tool_count']} available", style="dim")
+            else:
+                console.rule("Agent Started")
+                console.print(f"📋 Task: {task.splitlines()[0]}")
+                console.print(f"📂 Workdir: {workdir}")
+
+        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 == "turn_start":
+            current_turn = event.data["turn"]
+            if verbose:
+                if HAS_RICH:
+                    console.rule(f"[bold]Turn {current_turn}[/bold]", style="blue")
+                else:
+                    console.rule(f"Turn {current_turn}")
+
+        elif event.type == "compaction" and verbose:
+            console.print("🗜️  Compacting context (approaching token limit)...", style="yellow")
+
+        elif event.type == "thinking" and verbose:
+            _print_reasoning(event.data["content"])
+
+        elif event.type == "tool_call" and verbose:
+            _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+
+        elif event.type == "tool_result":
+            if verbose:
+                _print_tool_result(event.data["content"])
+            _checkpoint(workdir, f"checkpoint: turn {event.data['turn']}")
+
+        elif event.type == "message" and verbose:
+            _print_assistant_message(event.data["content"])
+            _checkpoint(workdir, "checkpoint: response")
+
+        elif event.type == "fallback" and verbose:
+            if HAS_RICH:
+                console.print(f"\n⚠️  [bold yellow]Online Server Error / Timeout[/bold yellow] ({event.data['error']})", 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']}")
+                print("🔄 Auto-falling back to local GGUF engine...")
+
+        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")
+            else:
+                print(f"\n❌ Model Error: {event.data['error']}")
+
+        elif event.type == "done":
+            summary = event.data["summary"]
+            _checkpoint(workdir, "checkpoint: done")
+            if verbose and HAS_RICH:
+                if "DONE" in summary.upper():
+                    console.rule("[bold green]✅ Task Complete[/bold green]")
+                else:
+                    console.rule("[bold yellow]💬 Agent Replied[/bold yellow]")
+
+        elif event.type == "max_turns_reached" and verbose:
+            console.print(f"\n⚠️  Max turns ({event.data['max_turns']}) reached without completion.", style="bold yellow")
+
+    return session.context.messages
+
+
+def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
+    """Run interactive chat session with Rich presentation."""
+    workdir = workdir.resolve()
+    _ensure_git(workdir)
+
+    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)
+
+    is_offline = isinstance(backend, LocalBackend) or not backend.is_available
+    active_tools = PromptBuilder().get_tools(is_offline=is_offline)
+
+    if HAS_RICH:
+        console.print()
+        console.print(
+            Panel(
+                "[bold cyan]AlpieCode[/bold cyan] interactive mode\n"
+                f"📂 Working in: [cyan]{workdir}[/cyan]\n"
+                + (f"🌐 Mode: [bold green]ONLINE[/bold green] (Server: {cfg.base_url})\n" if not is_offline else "🧠 Mode: [bold yellow]OFFLINE[/bold yellow] (Local GGUF Engine)\n")
+                + f"🔧 Tools: [cyan]{len(active_tools)} available[/cyan]\n\n"
+                "Type your request, or [bold red]exit[/bold red] / [bold red]quit[/bold red] to stop.",
+                title="💬 Chat Mode",
+                border_style="blue",
+            )
+        )
+    else:
+        console.print("\n💬 Chat Mode — type your request, or 'exit' to stop.")
+        console.print(f"📂 Working in: {workdir}")
+
+    while True:
+        try:
+            if HAS_RICH:
+                user_input = console.input("\n[bold green]You ❯[/bold green] ").strip()
+            else:
+                user_input = input("\nYou ❯ ").strip()
+        except (EOFError, KeyboardInterrupt):
+            console.print("\nGoodbye! 👋")
+            break
+
+        if not user_input:
+            continue
+        if user_input.lower() in ("exit", "quit", "q"):
+            console.print("Goodbye! 👋")
+            break
+
+        for event in orchestrator.run_task(session, user_input, cfg):
+            if event.type == "turn_start" and verbose:
+                if HAS_RICH:
+                    console.rule(f"[bold]Turn {event.data['turn']}[/bold]", style="blue")
+                else:
+                    console.rule(f"Turn {event.data['turn']}")
+
+            elif event.type == "thinking" and verbose:
+                _print_reasoning(event.data["content"])
+
+            elif event.type == "tool_call" and verbose:
+                _print_tool_call(event.data["turn"], event.data["name"], event.data["arguments"])
+
+            elif event.type == "tool_result":
+                if verbose:
+                    _print_tool_result(event.data["content"])
+                _checkpoint(workdir, f"checkpoint: chat turn {event.data['turn']}")
+
+            elif event.type == "message":
+                _print_assistant_message(event.data["content"])
+                _checkpoint(workdir, "checkpoint: done")
+
+            elif event.type == "error":
+                console.print(f"❌ Model error: {event.data['error']}", style="bold red" if HAS_RICH else None)
+
+            elif event.type == "done":
+                break

alpiecode-0.8.1/src/codeagent/backends/__init__.py

@@ -0,0 +1 @@
+"""Inference backends package for AlpieCode."""

alpiecode-0.8.1/src/codeagent/backends/base.py

@@ -0,0 +1,61 @@
+"""
+Inference backend interface for AlpieCode.
+
+Defines the contract (Protocol) and dataclasses for all inference providers
+(OpenAI-compatible server, local GGUF model, etc.).
+"""
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Protocol, runtime_checkable
+
+
+@dataclass
+class ToolCall:
+    """Normalized tool call representation."""
+    id: str
+    name: str
+    arguments: dict
+
+
+@dataclass
+class ChatResponse:
+    """Normalized inference response structure."""
+    content: Optional[str]
+    reasoning: Optional[str]
+    tool_calls: Optional[List[ToolCall]]
+    raw: Any = None
+
+
+@runtime_checkable
+class InferenceBackend(Protocol):
+    """Contract that all inference backends must implement."""
+
+    @property
+    def name(self) -> str:
+        """Human-readable backend name."""
+        ...
+
+    @property
+    def is_available(self) -> bool:
+        """Whether the backend is available/reachable."""
+        ...
+
+    @property
+    def context_window(self) -> int:
+        """Maximum context window in tokens."""
+        ...
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 4096,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        """Execute chat completion and return a normalized ChatResponse."""
+        ...
+
+    def shutdown(self) -> None:
+        """Clean up resources."""
+        ...

alpiecode-0.8.1/src/codeagent/backends/local_backend.py

@@ -0,0 +1,96 @@
+"""
+Local GGUF model inference backend.
+"""
+
+from typing import Any, List, Optional
+
+from ..config import Config
+from ..local_model import LocalModel
+from .base import ChatResponse, ToolCall
+
+
+class LocalBackend:
+    """Backend for local GGUF model inference via llama-cpp-python."""
+
+    def __init__(self, cfg: Config):
+        self._cfg = cfg
+        self._model: Optional[LocalModel] = None
+
+    @property
+    def name(self) -> str:
+        return f"Local GGUF ({self._cfg.model_repo})"
+
+    @property
+    def is_available(self) -> bool:
+        return True  # Local model is always available (downloads if missing)
+
+    @property
+    def context_window(self) -> int:
+        return self._cfg.n_ctx
+
+    def _ensure_model(self) -> LocalModel:
+        if self._model is None:
+            self._model = LocalModel(
+                repo_id=self._cfg.model_repo,
+                n_ctx=self._cfg.n_ctx,
+                n_gpu_layers=self._cfg.n_gpu_layers,
+                token=self._cfg.hf_token,
+            )
+        return self._model
+
+    def load_model(self) -> None:
+        """Explicitly load model into VRAM/RAM (warmup)."""
+        model = self._ensure_model()
+        model.load()
+
+    def chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        model = self._ensure_model()
+        resp = model.create_chat_completion(
+            messages=messages,
+            tools=tools,
+            tool_choice="auto",
+            temperature=temperature,
+            max_tokens=max_tokens,
+            enable_thinking=enable_thinking,
+        )
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if msg.tool_calls:
+            import json
+            tool_calls = []
+            for tc in msg.tool_calls:
+                args = tc.function.arguments
+                if isinstance(args, str):
+                    try:
+                        args = json.loads(args or "{}")
+                    except Exception:
+                        args = {}
+                tool_calls.append(
+                    ToolCall(
+                        id=tc.id,
+                        name=tc.function.name,
+                        arguments=args if isinstance(args, dict) else {},
+                    )
+                )
+
+        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
+
+        return ChatResponse(
+            content=msg.content,
+            reasoning=reasoning,
+            tool_calls=tool_calls,
+            raw=resp,
+        )
+
+    def shutdown(self) -> None:
+        if self._model:
+            self._model._llm = None
+            self._model = None

alpiecode-0.8.1/src/codeagent/backends/openai_backend.py

@@ -0,0 +1,85 @@
+"""
+OpenAI-compatible API inference backend.
+"""
+
+from typing import Any, List, Optional
+from openai import OpenAI
+
+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
+
+    @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 chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 4096,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        client = self._ensure_client()
+        params = {
+            "model": self._cfg.model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "extra_body": {"chat_template_kwargs": {"enable_thinking": enable_thinking}},
+        }
+        if tools:
+            params["tools"] = tools
+            params["tool_choice"] = "auto"
+
+        resp = client.chat.completions.create(**params)
+        msg = resp.choices[0].message
+
+        tool_calls = None
+        if msg.tool_calls:
+            import json
+            tool_calls = [
+                ToolCall(
+                    id=tc.id,
+                    name=tc.function.name,
+                    arguments=json.loads(tc.function.arguments or "{}"),
+                )
+                for tc in msg.tool_calls
+            ]
+
+        reasoning = getattr(msg, "reasoning", None) or getattr(msg, "reasoning_content", None)
+
+        return ChatResponse(
+            content=msg.content,
+            reasoning=reasoning,
+            tool_calls=tool_calls,
+            raw=resp,
+        )
+
+    def shutdown(self) -> None:
+        self._client = None