alpiecode 0.8.2__tar.gz → 0.9.1__tar.gz

{alpiecode-0.8.2 → alpiecode-0.9.1}/PKG-INFO

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

{alpiecode-0.8.2 → alpiecode-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "0.8.2"
+version = "0.9.1"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [
@@ -32,3 +32,7 @@ codeagent = "codeagent.cli:main"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.setuptools.package-data]
+codeagent = ["extension/*.vsix"]
+

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/alpiecode.egg-info/PKG-INFO

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

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/alpiecode.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/alpiecode.egg-info/top_level.txt
 src/codeagent/__init__.py
 src/codeagent/agent.py
 src/codeagent/cli.py
+src/codeagent/client.py
 src/codeagent/compaction.py
 src/codeagent/config.py
 src/codeagent/context.py
@@ -24,7 +25,9 @@ src/codeagent/server.py
 src/codeagent/session.py
 src/codeagent/tools.py
 src/codeagent/updater.py
+src/codeagent/vscode_installer.py
 src/codeagent/backends/__init__.py
 src/codeagent/backends/base.py
 src/codeagent/backends/local_backend.py
-src/codeagent/backends/openai_backend.py
+src/codeagent/backends/openai_backend.py
+src/codeagent/extension/alpiecode.vsix

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/codeagent/agent.py

@@ -149,28 +149,50 @@ def run_agent(
     video_path: str = None,
     url: str = None,
     github_repo: str = None,
+    server_url: 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)
+    # CLI-as-Client check: auto-detect if local/remote server is running
+    from .client import AlpieCodeClient
+    target_server = server_url or getattr(cfg, "server_url", None)
+    if not target_server:
+        # Check default local server
+        local_client = AlpieCodeClient("http://127.0.0.1:7169")
+        if local_client.health().get("status") == "online":
+            target_server = "http://127.0.0.1:7169"
+
+    if target_server:
+        client = AlpieCodeClient(target_server)
+        event_stream = client.stream_chat(
+            task=task,
+            workdir=str(workdir),
+            image_path=image_path,
+            video_path=video_path,
+            url=url,
+            github_repo=github_repo,
+        )
+    else:
+        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)
+        event_stream = orchestrator.run_task(
+            session=session,
+            task=task,
+            cfg=cfg,
+            image_path=image_path,
+            video_path=video_path,
+            url=url,
+            github_repo=github_repo,
+        )
 
     _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,
-    ):
+    for event in event_stream:
         if event.type == "start" and verbose:
             data = event.data
             if HAS_RICH:
@@ -254,7 +276,7 @@ def run_agent(
         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
+    return session.context.messages if "session" in locals() else []
 
 
 def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/codeagent/cli.py

@@ -119,6 +119,11 @@ def main():
 
     if args.command == "serve":
         _show_banner()
+        try:
+            from .vscode_installer import ensure_vscode_extension
+            ensure_vscode_extension()
+        except Exception as e:
+            pass
         from .server import run_server
         run_server(host=args.host, port=args.port)
         return

alpiecode-0.9.1/src/codeagent/client.py

@@ -0,0 +1,131 @@
+"""
+Client SDK for AlpieCode API server.
+
+Provides a clean, typed interface for connecting to an AlpieCode server (`alpiecode serve`),
+streaming SSE events, managing sessions, and canceling tasks.
+Used by the CLI client mode and future IDE/remote Python integrations.
+"""
+
+import json
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterator, Optional
+
+from .orchestrator import AgentEvent
+
+
+class AlpieCodeClient:
+    """Client for interacting with a running AlpieCode API server."""
+
+    def __init__(self, base_url: str = "http://127.0.0.1:7169", timeout: float = 120.0):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def health(self) -> Dict[str, Any]:
+        """Check server health and backend status."""
+        req = urllib.request.Request(f"{self.base_url}/health")
+        try:
+            with urllib.request.urlopen(req, timeout=3.0) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except Exception as e:
+            return {"status": "offline", "error": str(e)}
+
+    def metrics(self) -> Dict[str, Any]:
+        """Get server observability metrics."""
+        req = urllib.request.Request(f"{self.base_url}/metrics")
+        try:
+            with urllib.request.urlopen(req, timeout=3.0) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except Exception as e:
+            return {"error": str(e)}
+
+    def list_sessions(self) -> list:
+        """List active server sessions."""
+        req = urllib.request.Request(f"{self.base_url}/sessions")
+        try:
+            with urllib.request.urlopen(req, timeout=5.0) as resp:
+                data = json.loads(resp.read().decode("utf-8"))
+                return data.get("sessions", [])
+        except Exception:
+            return []
+
+    def cancel_task(self, session_id: str) -> bool:
+        """Request cancellation of an in-progress task session."""
+        req = urllib.request.Request(
+            f"{self.base_url}/cancel/{session_id}",
+            method="POST",
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=5.0) as resp:
+                return resp.status == 200
+        except Exception:
+            return False
+
+    def stream_chat(
+        self,
+        task: str,
+        workdir: str = ".",
+        session_id: Optional[str] = None,
+        image_path: Optional[str] = None,
+        video_path: Optional[str] = None,
+        url: Optional[str] = None,
+        github_repo: Optional[str] = None,
+    ) -> Iterator[AgentEvent]:
+        """
+        Stream agent events from POST /chat using Server-Sent Events (SSE).
+        Yields AgentEvent instances.
+        """
+        endpoint = f"{self.base_url}/chat"
+        payload = json.dumps({
+            "task": task,
+            "workdir": str(workdir),
+            "session_id": session_id,
+            "image": image_path,
+            "video": video_path,
+            "url": url,
+            "github": github_repo,
+        }).encode("utf-8")
+
+        req = urllib.request.Request(
+            endpoint,
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Accept": "text/event-stream",
+            },
+        )
+
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                current_event_type = "message"
+                current_data_str = ""
+
+                for raw_line in resp:
+                    line = raw_line.decode("utf-8").strip()
+                    if not line:
+                        if current_data_str:
+                            try:
+                                event_data = json.loads(current_data_str)
+                            except Exception:
+                                event_data = {"content": current_data_str}
+                            yield AgentEvent(type=current_event_type, data=event_data)
+                            current_event_type = "message"
+                            current_data_str = ""
+                        continue
+
+                    if line.startswith("event:"):
+                        current_event_type = line[6:].strip()
+                    elif line.startswith("data:"):
+                        current_data_str = line[5:].strip()
+
+                if current_data_str:
+                    try:
+                        event_data = json.loads(current_data_str)
+                    except Exception:
+                        event_data = {"content": current_data_str}
+                    yield AgentEvent(type=current_event_type, data=event_data)
+        except Exception as e:
+            yield AgentEvent(type="error", data={"error": f"Server connection failed: {e}"})

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/codeagent/orchestrator.py

@@ -28,9 +28,13 @@ class AgentEvent:
     data: Dict[str, Any]
 
 
-def resolve_backend(cfg: Config) -> InferenceBackend:
-    """Resolve online vs offline backend based on server reachability."""
-    if is_server_reachable(cfg.base_url):
+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).
+    """
+    if is_server_reachable(cfg.base_url, timeout=timeout):
         return OpenAIBackend(cfg)
     return LocalBackend(cfg)
 
@@ -59,6 +63,13 @@ class AgentOrchestrator:
         """
         Run full agent task loop for a session. Yields AgentEvents.
         """
+        # 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).
+        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
 

{alpiecode-0.8.2 → alpiecode-0.9.1}/src/codeagent/server.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, Optional
 
 try:
     from fastapi import FastAPI, HTTPException, Request, Response
+    from fastapi.middleware.cors import CORSMiddleware
     from fastapi.responses import JSONResponse, StreamingResponse
     HAS_FASTAPI = True
 except ImportError:
@@ -53,6 +54,15 @@ if HAS_FASTAPI:
         lifespan=lifespan,
     )
 
+    # CORS — allow VS Code extensions, web UIs, and external clients
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
     @app.get("/health")
     async def health_check():
         """Health check and engine status."""

alpiecode-0.9.1/src/codeagent/vscode_installer.py

@@ -0,0 +1,122 @@
+"""
+VS Code Extension Auto-Installer for AlpieCode.
+
+Detects if VS Code is available, checks if the AlpieCode extension is installed,
+and prompts/auto-installs the bundled .vsix if missing.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+def get_bundled_vsix_path() -> Path:
+    """Return path to bundled .vsix inside the codeagent package."""
+    pkg_dir = Path(__file__).parent
+    return pkg_dir / "extension" / "alpiecode.vsix"
+
+
+def find_code_cli() -> Optional[str]:
+    """Find the VS Code CLI executable across Windows, WSL, Linux, and macOS."""
+    for cmd in ("code", "code.cmd", "code.exe"):
+        found = shutil.which(cmd)
+        if found:
+            return found
+            
+    # Check common WSL / Windows paths if not found directly in PATH
+    wsl_code_paths = [
+        "/mnt/c/Users/*/AppData/Local/Programs/Microsoft VS Code/bin/code",
+        "/usr/local/bin/code",
+        "/usr/bin/code",
+    ]
+    import glob
+    for pattern in wsl_code_paths:
+        matches = glob.glob(pattern)
+        if matches:
+            return matches[0]
+            
+    return None
+
+
+def is_extension_installed() -> bool:
+    """Check if 'alpiecode' extension is already installed in VS Code."""
+    code_bin = find_code_cli()
+    if not code_bin:
+        return False
+
+    try:
+        res = subprocess.run(
+            [code_bin, "--list-extensions"],
+            capture_output=True,
+            text=True,
+            timeout=8,
+        )
+        if res.returncode == 0:
+            installed = res.stdout.lower()
+            return "alpiecode" in installed
+    except Exception:
+        pass
+
+    return False
+
+
+def ensure_vscode_extension(auto_confirm: bool = False, quiet: bool = False) -> bool:
+    """
+    Check if VS Code extension is installed. If missing:
+    - Asks user: 'Would you like to install the AlpieCode VS Code extension? [Y/n]'
+    - If Yes (or auto_confirm=True): installs bundled .vsix via `code --install-extension`
+    - Returns True if installed or successfully installed, False otherwise.
+    """
+    if is_extension_installed():
+        if not quiet:
+            print("✅ AlpieCode VS Code extension is installed.")
+        return True
+
+    code_bin = find_code_cli()
+    if not code_bin:
+        if not quiet:
+            print("ℹ️ VS Code CLI ('code') not detected on PATH. Skipping extension check.")
+        return False
+
+    vsix_path = get_bundled_vsix_path()
+    if not vsix_path.exists():
+        if not quiet:
+            print(f"ℹ️ Bundled extension VSIX not found at {vsix_path}")
+        return False
+
+    if not quiet:
+        print("\n💡 VS Code detected, but the AlpieCode extension is not installed.")
+
+    if not auto_confirm:
+        try:
+            prompt_text = "   Would you like to install the AlpieCode VS Code extension now? [Y/n]: "
+            choice = input(prompt_text).strip().lower()
+            if choice and choice not in ("y", "yes"):
+                if not quiet:
+                    print("   Skipped VS Code extension installation.\n")
+                return False
+        except (KeyboardInterrupt, EOFError):
+            print()
+            return False
+
+    print(f"📦 Installing AlpieCode VS Code extension ({vsix_path.name})...")
+    try:
+        res = subprocess.run(
+            [code_bin, "--install-extension", str(vsix_path), "--force"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+        if res.returncode == 0:
+            print("✅ AlpieCode VS Code extension installed successfully!")
+            print("   👉 Reload VS Code (`Ctrl+Shift+P` → `Developer: Reload Window`) to start chatting!\n")
+            return True
+        else:
+            print(f"⚠️ Could not install VS Code extension: {res.stderr.strip()}\n")
+    except Exception as e:
+        print(f"⚠️ Extension installation error: {e}\n")
+
+    return False