alpiecode 0.6.0__py3-none-any.whl

codeagent/cli.py

@@ -0,0 +1,215 @@
+"""
+CLI entry point for AlpieCode.
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from .config import CONFIG_PATH, interactive_init, load_config
+
+
+BANNER = r"""
+    _    _     _      ____            _      
+   / \  | |_ _| | ___ / ___|___   __| | ___ 
+  / _ \ | | '_ \ |/ _ \ |   / _ \ / _` |/ _ \
+ / ___ \| | |_) | |  __/ |__| (_) | (_| |  __/
+/_/   \_\_|_.__/|_|\___|\____\___/ \__,_|\___|
+"""
+
+
+def _show_banner():
+    try:
+        from rich.console import Console
+        console = Console()
+        console.print(BANNER, style="bold cyan", highlight=False)
+    except ImportError:
+        print(BANNER)
+
+
+def _normalize_args():
+    known_commands = {"init", "run", "chat", "plan", "diff", "-h", "--help", "--version"}
+    subcommand = None
+    
+    # Check if a subcommand is present
+    for arg in sys.argv[1:]:
+        if arg in known_commands:
+            subcommand = arg
+            break
+            
+    if not subcommand and len(sys.argv) > 1:
+        subcommand = "run"
+        sys.argv.insert(1, "run")
+
+    if subcommand in ("run", "plan") and len(sys.argv) > 2:
+        cmd_idx = sys.argv.index(subcommand)
+        sub_args = sys.argv[cmd_idx + 1:]
+        
+        flags = []
+        positionals = []
+        
+        i = 0
+        while i < len(sub_args):
+            arg = sub_args[i]
+            if arg.startswith("-"):
+                flags.append(arg)
+                if arg in ("--workdir", "--image", "--video", "--url", "--github", "--max-turns") and i + 1 < len(sub_args):
+                    flags.append(sub_args[i + 1])
+                    i += 1
+            else:
+                positionals.append(arg)
+            i += 1
+            
+        sys.argv = sys.argv[:cmd_idx + 1] + flags + positionals
+
+
+def main():
+    _normalize_args()
+
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--workdir", default=".", help="Repo directory (default: current dir)")
+    common.add_argument("--image", default=None, help="Path to an image file for vision analysis")
+    common.add_argument("--video", default=None, help="Path to a video file for multimodal analysis")
+    common.add_argument("--url", default=None, help="YouTube URL for video analysis")
+    common.add_argument("--github", default=None, help="GitHub repository (e.g. owner/repo or URL) for open-source analysis")
+    common.add_argument("--max-turns", type=int, default=None, help="Override max turns")
+    common.add_argument("--no-thinking", "--non-thinking", dest="no_thinking", action="store_true", help="Disable VLM reasoning/thinking mode")
+    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")
+
+    parser = argparse.ArgumentParser(
+        prog="alpiecode",
+        description="AlpieCode — Autonomous AI Coding Agent powered by 169Pi Alpie VLM",
+        parents=[common],
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    # ── init ──
+    sub.add_parser("init", help="Configure your VLM/OpenAI-compatible endpoint")
+
+    # ── run ──
+    run_p = sub.add_parser("run", help="Run a coding task against a repository", parents=[common])
+    run_p.add_argument("task", help="Natural-language task description")
+
+    # ── chat ──
+    chat_p = sub.add_parser("chat", help="Interactive chat mode with AlpieCode", parents=[common])
+
+    # ── plan ──
+    plan_p = sub.add_parser("plan", help="Generate a plan without making changes (read-only)", parents=[common])
+    plan_p.add_argument("task", help="Natural-language task to plan for")
+
+    # ── diff ──
+    diff_p = sub.add_parser("diff", help="Show changes AlpieCode has made since last checkpoint", parents=[common])
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return
+
+    if args.command == "init":
+        interactive_init()
+        return
+
+    # Check for auto-updates from GitHub in background
+    if not getattr(args, "no_update", False):
+        try:
+            from .updater import auto_update
+            auto_update(quiet=getattr(args, "quiet", False))
+        except Exception:
+            pass
+
+    cfg = load_config()
+
+    if getattr(args, "no_thinking", False):
+        cfg.enable_thinking = False
+
+    if args.command == "run":
+        if args.max_turns:
+            cfg.max_turns = args.max_turns
+        _show_banner()
+        from .agent import run_agent
+        run_agent(
+            args.task, Path(args.workdir), cfg,
+            verbose=not args.quiet,
+            image_path=args.image,
+            video_path=getattr(args, "video", None),
+            url=getattr(args, "url", None),
+            github_repo=getattr(args, "github", None),
+        )
+
+    elif args.command == "chat":
+        if args.max_turns:
+            cfg.max_turns = args.max_turns
+        _show_banner()
+        from .agent import run_chat
+        run_chat(Path(args.workdir), cfg, verbose=not args.quiet)
+
+    elif args.command == "plan":
+        _show_banner()
+        plan_task = (
+            f"PLANNING ONLY — Do NOT make any file edits. "
+            f"Analyze the codebase and create a detailed implementation plan for the following task. "
+            f"Use list_files, read_file, and file_search to understand the project. "
+            f"Then use update_plan to write a structured plan with deliverables and checks. "
+            f"Finish with DONE: when the plan is complete.\n\n"
+            f"Task: {args.task}"
+        )
+        from .agent import run_agent
+        run_agent(
+            plan_task, Path(args.workdir), cfg, verbose=True,
+            image_path=args.image,
+            video_path=getattr(args, "video", None),
+            url=getattr(args, "url", None),
+            github_repo=getattr(args, "github", None),
+        )
+
+    elif args.command == "diff":
+        workdir = Path(args.workdir).resolve()
+        # Show git diff since the first checkpoint
+        result = subprocess.run(
+            ["git", "log", "--oneline", "--all"],
+            cwd=workdir, capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            print("Not a git repository or no commits found.")
+            return
+
+        # Find the start checkpoint
+        log_lines = result.stdout.strip().splitlines()
+        start_sha = None
+        for line in reversed(log_lines):
+            if "checkpoint: start" in line:
+                start_sha = line.split()[0]
+                break
+
+        if not start_sha:
+            print("No AlpieCode checkpoint found. Run a task first.")
+            return
+
+        diff_result = subprocess.run(
+            ["git", "diff", start_sha, "HEAD", "--stat"],
+            cwd=workdir, capture_output=True, text=True
+        )
+        print(f"Changes since AlpieCode started (from {start_sha}):\n")
+        print(diff_result.stdout)
+
+        # Also show the full diff
+        full_diff = subprocess.run(
+            ["git", "diff", start_sha, "HEAD"],
+            cwd=workdir, capture_output=True, text=True
+        )
+        if full_diff.stdout:
+            try:
+                from rich.console import Console
+                from rich.syntax import Syntax
+                console = Console()
+                syntax = Syntax(full_diff.stdout, "diff", theme="monokai")
+                console.print(syntax)
+            except ImportError:
+                print(full_diff.stdout)
+
+
+if __name__ == "__main__":
+    main()

codeagent/compaction.py

@@ -0,0 +1,163 @@
+"""
+Context compaction for AlpieCode.
+
+When the conversation history approaches the model's context window limit,
+this module summarizes older turns to free up space while preserving
+the essential information needed for the agent to continue working.
+
+Strategy:
+  - Keep system prompt and last N turns intact
+  - Summarize older tool calls and results into compact descriptions
+  - Preserve all user messages verbatim
+  - Track approximate token count using a simple heuristic (4 chars ≈ 1 token)
+"""
+
+import json
+from typing import List
+
+# Our model's context window
+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 = 10
+# Approximate chars per token (rough heuristic)
+CHARS_PER_TOKEN = 4
+
+
+def estimate_tokens(messages: List[dict]) -> int:
+    """Estimate token count from a list of messages."""
+    total_chars = 0
+    for msg in messages:
+        if isinstance(msg, dict):
+            content = msg.get("content") or ""
+            if isinstance(content, str):
+                total_chars += len(content)
+            # Account for tool call arguments
+            tool_calls = msg.get("tool_calls", [])
+            if tool_calls:
+                for tc in tool_calls:
+                    if isinstance(tc, dict):
+                        fn = tc.get("function", {})
+                        total_chars += len(fn.get("arguments", ""))
+                        total_chars += len(fn.get("name", ""))
+    return total_chars // CHARS_PER_TOKEN
+
+
+def needs_compaction(messages: List[dict], max_tokens: int = MAX_CONTEXT_TOKENS) -> bool:
+    """Check if the conversation needs compaction."""
+    tokens = estimate_tokens(messages)
+    return tokens > (max_tokens * COMPACT_THRESHOLD)
+
+
+def _summarize_tool_result(tool_name: str, content: str) -> str:
+    """Create a compact summary of a tool result."""
+    if len(content) <= 300:
+        return content
+
+    if tool_name == "bash":
+        try:
+            data = json.loads(content)
+            stdout = data.get("stdout", "")
+            stderr = data.get("stderr", "")
+            exit_code = data.get("exit_code", -1)
+            summary = f"exit_code={exit_code}"
+            if stdout:
+                summary += f", stdout({len(stdout)} chars): {stdout[:150]}..."
+            if stderr:
+                summary += f", stderr: {stderr[:100]}..."
+            return summary
+        except json.JSONDecodeError:
+            pass
+
+    if tool_name in ("read_file", "list_files"):
+        lines = content.splitlines()
+        if len(lines) > 20:
+            return "\n".join(lines[:10]) + f"\n... ({len(lines) - 20} lines omitted) ...\n" + "\n".join(lines[-10:])
+
+    # Generic truncation
+    return content[:250] + f"... ({len(content)} chars total)"
+
+
+def compact_messages(messages: List[dict]) -> List[dict]:
+    """
+    Compact a message list by summarizing older turns.
+
+    Preserves:
+      - System prompt (index 0)
+      - All user messages (verbatim)
+      - Last KEEP_RECENT_TURNS messages (verbatim)
+
+    Summarizes:
+      - Older tool results (truncated)
+      - Older assistant reasoning (removed)
+    """
+    if len(messages) <= KEEP_RECENT_TURNS + 2:
+        return messages
+
+    # Always keep system prompt
+    system = messages[0] if messages and messages[0].get("role") == "system" else None
+
+    # Split into old and recent
+    cutoff = len(messages) - KEEP_RECENT_TURNS
+    old_messages = messages[1:cutoff] if system else messages[:cutoff]
+    recent_messages = messages[cutoff:]
+
+    # Build a compacted summary of old messages
+    compacted_old = []
+    summary_parts = []
+
+    for msg in old_messages:
+        role = msg.get("role", "")
+
+        if role == "user":
+            # Keep user messages verbatim
+            compacted_old.append(msg)
+
+        elif role == "assistant":
+            # Compact assistant messages: keep tool calls but remove reasoning
+            compact_msg = {"role": "assistant"}
+            if msg.get("content"):
+                # Truncate long assistant content
+                content = msg["content"]
+                if len(content) > 200:
+                    compact_msg["content"] = content[:200] + "..."
+                else:
+                    compact_msg["content"] = content
+            else:
+                compact_msg["content"] = None
+
+            if msg.get("tool_calls"):
+                compact_msg["tool_calls"] = msg["tool_calls"]
+            compacted_old.append(compact_msg)
+
+        elif role == "tool":
+            # Summarize tool results
+            tool_call_id = msg.get("tool_call_id", "")
+            content = msg.get("content", "")
+
+            # Try to find the tool name from the preceding assistant message
+            tool_name = "unknown"
+            for prev in reversed(compacted_old):
+                if prev.get("tool_calls"):
+                    for tc in prev["tool_calls"]:
+                        tc_dict = tc if isinstance(tc, dict) else {}
+                        if tc_dict.get("id") == tool_call_id:
+                            tool_name = tc_dict.get("function", {}).get("name", "unknown")
+                            break
+                    break
+
+            compacted_old.append({
+                "role": "tool",
+                "tool_call_id": tool_call_id,
+                "content": _summarize_tool_result(tool_name, content),
+            })
+
+    # Rebuild message list
+    result = []
+    if system:
+        result.append(system)
+    result.extend(compacted_old)
+    result.extend(recent_messages)
+
+    return result

codeagent/config.py

@@ -0,0 +1,195 @@
+"""
+Per-user config for AlpieCode.
+
+Resolution order (highest priority first):
+  1. Environment variables: HF_TOKEN, ALPIECODE_MODEL_REPO, etc.
+  2. ~/.alpiecode/config.json (written by `alpiecode init`)
+  3. Built-in defaults (Local GGUF model: 169Pi/Alpie_learn_prototype_GGUF_NEW)
+"""
+
+import json
+import os
+import socket
+from dataclasses import dataclass, asdict, fields
+from pathlib import Path
+from typing import Optional
+
+CONFIG_DIR = Path.home() / ".alpiecode"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+# Config version — bump this when defaults change to trigger auto-migration
+CONFIG_VERSION = 2  # v2: n_ctx upgraded 16384 → 32768
+
+DEFAULTS = {
+    "base_url": "http://20.245.200.125:8000/v1",  # Remote VLM server endpoint
+    "model": "169Pi/grpo_phase_2_merged",
+    "model_repo": "169Pi/Alpie_learn_prototype_GGUF_NEW",
+    "api_key": "not-needed",
+    "hf_token": None,
+    "max_turns": 30,
+    "temperature": 0.2,
+    "max_tokens": 16384,
+    "enable_thinking": True,
+    "n_ctx": 32768,  # 32k context window (model supports up to 131k)
+    "n_gpu_layers": None,  # None = auto-detect GPU
+    "config_version": CONFIG_VERSION,
+}
+
+
+def is_server_reachable(base_url: Optional[str], timeout: float = 0.4) -> bool:
+    """Fast network ping check (0.4s max) to see if server endpoint is online."""
+    if not base_url:
+        return False
+    try:
+        from urllib.parse import urlparse
+        parsed = urlparse(base_url)
+        host = parsed.hostname
+        port = parsed.port or (443 if parsed.scheme == "https" else 80)
+        if not host:
+            return False
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except Exception:
+        return False
+
+
+def is_internet_available(timeout: float = 1.0) -> bool:
+    """Quick check if general internet is available (ping Google DNS)."""
+    try:
+        with socket.create_connection(("8.8.8.8", 53), timeout=timeout):
+            return True
+    except Exception:
+        return False
+
+
+@dataclass
+class Config:
+    base_url: Optional[str] = None
+    model: str = "169Pi/grpo_phase_2_merged"          # Server API model name (vLLM)
+    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 = 30
+    temperature: float = 0.2
+    max_tokens: int = 16384
+    enable_thinking: bool = True
+    n_ctx: int = 32768
+    n_gpu_layers: Optional[int] = None
+
+
+def load_config() -> Config:
+    data = dict(DEFAULTS)
+    needs_save = False
+    if CONFIG_PATH.exists():
+        try:
+            saved_data = json.loads(CONFIG_PATH.read_text())
+            # Skip null values so they don't override smart defaults (e.g. base_url)
+            data.update({k: v for k, v in saved_data.items() if v is not None})
+
+            # ── Auto-migrate stale configs ────────────────────────────
+            saved_version = saved_data.get("config_version", 1)
+            if saved_version < CONFIG_VERSION:
+                # v1 → v2: n_ctx was 16384, upgrade to 32768
+                if saved_data.get("n_ctx") == 16384:
+                    data["n_ctx"] = 32768
+                data["config_version"] = CONFIG_VERSION
+                needs_save = True
+        except Exception:
+            pass
+
+    # env vars override saved file
+    for prefix in ("ALPIECODE_", "CODEAGENT_"):
+        if os.environ.get(f"{prefix}BASE_URL"):
+            data["base_url"] = os.environ[f"{prefix}BASE_URL"]
+        if os.environ.get(f"{prefix}MODEL"):
+            data["model"] = os.environ[f"{prefix}MODEL"]
+        if os.environ.get(f"{prefix}MODEL_REPO"):
+            data["model_repo"] = os.environ[f"{prefix}MODEL_REPO"]
+        if os.environ.get(f"{prefix}API_KEY"):
+            data["api_key"] = os.environ[f"{prefix}API_KEY"]
+    if os.environ.get("HF_TOKEN"):
+        data["hf_token"] = os.environ["HF_TOKEN"]
+    if os.environ.get("ALPIECODE_CPU") == "1":
+        data["n_gpu_layers"] = 0
+    elif os.environ.get("ALPIECODE_GPU_LAYERS"):
+        try:
+            data["n_gpu_layers"] = int(os.environ["ALPIECODE_GPU_LAYERS"])
+        except ValueError:
+            pass
+
+    # Filter data to only keys present in Config fields
+    valid_keys = {f.name for f in fields(Config)}
+    filtered_data = {k: v for k, v in data.items() if k in valid_keys}
+    cfg = Config(**filtered_data)
+
+    # Auto-save migrated config
+    if needs_save:
+        try:
+            save_config(cfg)
+        except Exception:
+            pass
+
+    return cfg
+
+
+def save_config(cfg: Config) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(json.dumps(asdict(cfg), indent=2))
+
+
+def interactive_init() -> Config:
+    current = load_config()
+    print("AlpieCode Setup — Local GGUF Model Configuration\n")
+
+    print("AlpieCode uses the 169Pi/Alpie_learn_prototype_GGUF_NEW model from HuggingFace.")
+    print("Please enter your HuggingFace user access token (required to download model).\n")
+
+    # Mask token for display (show first 3 + last 3 chars only)
+    if current.hf_token:
+        t = current.hf_token
+        masked = f"{t[:3]}***{t[-3:]}" if len(t) > 6 else "***"
+    else:
+        masked = "none"
+    token_prompt = f"HuggingFace Token [{masked}]: "
+    hf_token = input(token_prompt).strip() or current.hf_token
+
+    repo_prompt = f"Model Repo [{current.model_repo}]: "
+    model_repo = input(repo_prompt).strip() or current.model_repo
+
+    cfg = Config(
+        base_url=current.base_url,
+        model=current.model,
+        model_repo=model_repo,
+        api_key=current.api_key,
+        hf_token=hf_token,
+        max_turns=current.max_turns,
+        temperature=current.temperature,
+        max_tokens=current.max_tokens,
+        enable_thinking=current.enable_thinking,
+        n_ctx=current.n_ctx,
+        n_gpu_layers=current.n_gpu_layers,
+    )
+    save_config(cfg)
+    print(f"\n✅ Config saved to {CONFIG_PATH}")
+
+    # Trigger model download test if token provided
+    try:
+        from .local_model import download_model
+        print("\n📥 Testing HuggingFace model download...")
+        local_path = download_model(repo_id=cfg.model_repo, token=cfg.hf_token)
+        print(f"✅ Model downloaded & cached at: {local_path}")
+    except Exception as e:
+        print(f"⚠️ Could not download model right now: {e}")
+        print("   Model will be downloaded automatically on first task execution.")
+
+    # Pre-install llama-cpp-python binary wheel (so offline mode works immediately)
+    try:
+        from .local_model import _ensure_llama_cpp
+        print("\n⚙️  Setting up offline GGUF engine...")
+        _ensure_llama_cpp()
+        print("✅ Offline mode ready — works without internet from now on!")
+    except Exception as e:
+        print(f"⚠️ Could not setup offline engine: {e}")
+        print("   It will be installed automatically when needed.")
+
+    return cfg