alpiecode 0.6.0__tar.gz → 0.7.1__tar.gz

{alpiecode-0.6.0 → alpiecode-0.7.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.6.0
+Version: 0.7.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
 Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
 Requires-Dist: openai>=1.0.0
-Requires-Dist: httpx>=0.24.0
+Requires-Dist: httpx[http2]>=0.24.0
 Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0

{alpiecode-0.6.0 → alpiecode-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "0.6.0"
+version = "0.7.1"
 description = "AlpieCode — Autonomous AI Coding Agent CLI powered by local 169Pi GGUF VLM"
 requires-python = ">=3.9"
 dependencies = [
@@ -12,7 +12,7 @@ dependencies = [
     "rich>=13.0",
     "click>=8.0",
     "openai>=1.0.0",
-    "httpx>=0.24.0",
+    "httpx[http2]>=0.24.0",
     "duckduckgo-search>=7.0.0",
     "beautifulsoup4>=4.12.0",
     "yt-dlp>=2024.0.0",

{alpiecode-0.6.0 → alpiecode-0.7.1}/src/alpiecode.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 0.6.0
+Version: 0.7.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
 Requires-Dist: rich>=13.0
 Requires-Dist: click>=8.0
 Requires-Dist: openai>=1.0.0
-Requires-Dist: httpx>=0.24.0
+Requires-Dist: httpx[http2]>=0.24.0
 Requires-Dist: duckduckgo-search>=7.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
 Requires-Dist: yt-dlp>=2024.0.0

{alpiecode-0.6.0 → alpiecode-0.7.1}/src/alpiecode.egg-info/requires.txt

@@ -2,7 +2,7 @@ huggingface_hub>=0.20.0
 rich>=13.0
 click>=8.0
 openai>=1.0.0
-httpx>=0.24.0
+httpx[http2]>=0.24.0
 duckduckgo-search>=7.0.0
 beautifulsoup4>=4.12.0
 yt-dlp>=2024.0.0

{alpiecode-0.6.0 → alpiecode-0.7.1}/src/codeagent/agent.py

@@ -13,6 +13,7 @@ import json
 import re
 import subprocess
 import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import httpx
@@ -23,6 +24,26 @@ from .tools import TOOLS, make_dispatch
 from .compaction import needs_compaction, compact_messages
 from .memory import format_memories_for_prompt, extract_and_save_memories
 
+# ── Tool classification for parallel dispatch ─────────────────────────
+# READ_ONLY tools can execute concurrently; MUTATING tools must be sequential
+READ_ONLY_TOOLS = frozenset({"read_file", "list_files", "file_search", "fetch_url", "web_search"})
+
+
+def _is_simple_task(task: str) -> bool:
+    """Detect simple tasks that don't benefit from deep reasoning traces."""
+    task_lower = task.lower().strip()
+    # Short prompts (< 80 chars) are almost always simple
+    if len(task_lower) < 80:
+        return True
+    # Keyword patterns indicating simple edits
+    simple_patterns = [
+        "fix typo", "add comment", "rename", "format", "add docstring",
+        "remove unused", "add import", "update version", "change color",
+        "fix indent", "add logging", "hello world", "fibonacci",
+        "print ", "add a test", "calculator",
+    ]
+    return any(pat in task_lower for pat in simple_patterns)
+
 SYSTEM_PROMPT = """\
 You are AlpieCode, an autonomous software-engineering agent built by 169Pi. You operate \
 autonomously to solve the user's requirements end to end, bringing the judgement \
@@ -482,10 +503,11 @@ def run_agent(task: str, workdir: Path, cfg: Config, verbose: bool = True,
 
     if server_online:
         # ── ONLINE MODE: Server reachable ─────────────────────────────
+        from .config import get_shared_http_client
         client = OpenAI(
             base_url=cfg.base_url,
             api_key=cfg.api_key or "not-needed",
-            timeout=httpx.Timeout(30.0, connect=3.0),
+            http_client=get_shared_http_client(),
         )
         local_model = None
     else:
@@ -559,6 +581,14 @@ def run_agent(task: str, workdir: Path, cfg: Config, verbose: bool = True,
     compile_fail_counts = {}  # Track compilation failures per file
     tool_call_history = []    # Track repeated tool calls to prevent infinite loops
 
+    # ── Adaptive Thinking Router ──────────────────────────────────────
+    # Auto-disable thinking for simple tasks to save 10-20s of reasoning
+    if cfg.enable_thinking and _is_simple_task(task):
+        cfg = Config(**{f.name: getattr(cfg, f.name) for f in cfg.__dataclass_fields__.values()})
+        cfg.enable_thinking = False
+        if verbose and HAS_RICH:
+            console.print("⚡ [dim]Adaptive mode: simple task detected, skipping deep reasoning for speed[/dim]")
+
     for turn in range(cfg.max_turns):
         # Context compaction check — use actual n_ctx for offline (32k), full for online (262k)
         ctx_limit = cfg.n_ctx if not server_online else 262_144
@@ -665,6 +695,46 @@ def run_agent(task: str, workdir: Path, cfg: Config, verbose: bool = True,
                 })
 
         if raw_tool_calls:
+            # ── Parallel Multi-Tool Dispatch Engine ───────────────────
+            # Classify calls: execute contiguous READ_ONLY tools concurrently
+            # Mutating tools (write_file, edit_file, bash) remain sequential
+            all_read_only = all(tc["name"] in READ_ONLY_TOOLS for tc in raw_tool_calls)
+            use_parallel = all_read_only and len(raw_tool_calls) > 1
+
+            if use_parallel:
+                # Execute all read-only tools concurrently
+                if verbose and HAS_RICH:
+                    console.print(f"   ⚡ [dim]Parallel dispatch: {len(raw_tool_calls)} read-only tools[/dim]")
+                results_map = {}
+                with ThreadPoolExecutor(max_workers=min(8, len(raw_tool_calls))) as pool:
+                    future_to_tc = {}
+                    for tc in raw_tool_calls:
+                        fn_name = tc["name"]
+                        args = tc["arguments"]
+                        if verbose:
+                            _print_tool_call(turn, fn_name, args)
+                        future = pool.submit(dispatch[fn_name], args)
+                        future_to_tc[future] = tc
+                    for future in as_completed(future_to_tc):
+                        tc = future_to_tc[future]
+                        try:
+                            results_map[tc["id"]] = future.result()
+                        except Exception as e:
+                            results_map[tc["id"]] = f"error: {e}"
+                # Append results in original order
+                for tc in raw_tool_calls:
+                    result = str(results_map[tc["id"]])
+                    if verbose:
+                        _print_tool_result(result)
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tc["id"],
+                        "content": result,
+                    })
+                _checkpoint(workdir, f"checkpoint: turn {turn + 1}")
+                continue
+
+            # Sequential execution for mutating tools (or single tool calls)
             for tc in raw_tool_calls:
                 fn_name = tc["name"]
                 args = tc["arguments"]
@@ -775,10 +845,11 @@ def run_chat(workdir: Path, cfg: Config, verbose: bool = True) -> None:
     server_online = is_server_reachable(cfg.base_url)
 
     if server_online:
+        from .config import get_shared_http_client
         client = OpenAI(
             base_url=cfg.base_url,
             api_key=cfg.api_key or "not-needed",
-            timeout=httpx.Timeout(30.0, connect=3.0),
+            http_client=get_shared_http_client(),
         )
         local_model = None
     else:

{alpiecode-0.6.0 → alpiecode-0.7.1}/src/codeagent/config.py

@@ -62,6 +62,25 @@ def is_internet_available(timeout: float = 1.0) -> bool:
         return False
 
 
+# ── Shared HTTP/2 connection pool ─────────────────────────────────────
+_SHARED_HTTP_CLIENT = None
+
+def get_shared_http_client():
+    """
+    Get or create a shared HTTP/2 client with TCP keep-alive and connection pooling.
+    Eliminates 150-300ms connection overhead per API call by reusing sockets.
+    """
+    global _SHARED_HTTP_CLIENT
+    if _SHARED_HTTP_CLIENT is None:
+        import httpx
+        _SHARED_HTTP_CLIENT = httpx.Client(
+            http2=True,
+            timeout=httpx.Timeout(120.0, connect=5.0),
+            limits=httpx.Limits(max_keepalive_connections=20, max_connections=50),
+        )
+    return _SHARED_HTTP_CLIENT
+
+
 @dataclass
 class Config:
     base_url: Optional[str] = None

{alpiecode-0.6.0 → alpiecode-0.7.1}/src/codeagent/local_model.py

@@ -242,30 +242,37 @@ def _ensure_llama_cpp():
     else:
         wheel_url = "https://github.com/abetlen/llama-cpp-python/releases/download/v0.3.34-vulkan/llama_cpp_python-0.3.34-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl"
 
+    install_targets = [wheel_url, "llama-cpp-python"]
     installed = False
     last_error = ""
-    for cmd_base in [["uv", "pip", "install", wheel_url], [sys.executable, "-m", "pip", "install", wheel_url]]:
-        try:
-            res = subprocess.run(cmd_base, capture_output=True, text=True, timeout=120)
-            if res.returncode == 0:
-                installed = True
-                break
-            else:
-                last_error = res.stderr.strip() or res.stdout.strip()
-        except Exception as e:
-            last_error = str(e)
-            continue
+    for target in install_targets:
+        for cmd_base in [
+            ["uv", "pip", "install", target],
+            [sys.executable, "-m", "pip", "install", target],
+        ]:
+            try:
+                res = subprocess.run(cmd_base, capture_output=True, text=True, timeout=180)
+                if res.returncode == 0:
+                    installed = True
+                    break
+                else:
+                    last_error = res.stderr.strip() or res.stdout.strip()
+            except Exception as e:
+                last_error = str(e)
+                continue
+        if installed:
+            break
 
     try:
         from llama_cpp import Llama
         print("✅ Pre-compiled local GGUF engine installed successfully!")
         return Llama
     except ImportError:
-        err_detail = f"\n   Last error: {last_error[:200]}" if last_error else ""
+        err_detail = f"\n   Last error: {last_error[:300]}" if last_error else ""
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
             "│  Failed to auto-install local GGUF engine.               │\n"
-            "│  Internet connection required for first-time setup.      │\n"
+            "│  Please check your internet connection for first setup.  │\n"
             "╰────────────────────────────────────────────────────────────╯"
             f"{err_detail}"
         )
@@ -296,14 +303,32 @@ class LocalModel:
         Llama = _ensure_llama_cpp()
 
         accel = "GPU" if self.n_gpu_layers != 0 else "CPU"
+
+        # ── Smart P-Core Topology Auto-Tuning ─────────────────────────
+        # On hybrid CPUs (Intel 12th+), over-subscribing E-cores causes
+        # cache thrashing. Use physical core count to avoid this.
+        n_threads = max(1, (os.cpu_count() or 4) - 1)
+        try:
+            import subprocess
+            # Linux: count physical cores only (excludes hyperthreads)
+            res = subprocess.run(
+                ["nproc", "--all"],
+                capture_output=True, text=True, timeout=2
+            )
+            if res.returncode == 0:
+                logical = int(res.stdout.strip())
+                # Heuristic: physical cores ≈ logical / 2 on HT systems
+                # Use 75% of logical cores as a safe threading target
+                n_threads = max(1, int(logical * 0.75))
+        except Exception:
+            pass
+
         print(f"🧠 Loading local GGUF model: {model_path.name}")
-        print(f"   Context: {self.n_ctx} tokens | Mode: {accel} | Threads: {max(1, (os.cpu_count() or 4) - 1)}")
+        print(f"   Context: {self.n_ctx} tokens | Mode: {accel} | Threads: {n_threads}")
         if accel == "CPU":
             print(f"   ⏳ CPU loading ~4GB model — this takes 30-90 seconds on first run...")
         else:
-            print(f"   ⚡ GPU-accelerated loading...")
-
-        n_threads = max(1, (os.cpu_count() or 4) - 1)
+            print(f"   ⚡ GPU-accelerated loading (Q8 KV cache enabled)...")
 
         # Suppress noisy ggml_vulkan/ggml_cuda stderr messages from C library
         # These confuse users ("ggml_vulkan: Found 1 Vulkan devices: Intel UHD...")
@@ -318,17 +343,30 @@ class LocalModel:
         except Exception:
             _stderr_fd = None  # Fallback: don't suppress if dup2 fails
 
+        # ── Build Llama kwargs with Q8_0 KV Cache for GPU ─────────────
+        llama_kwargs = dict(
+            model_path=str(model_path),
+            n_ctx=self.n_ctx,
+            n_batch=2048 if self.n_gpu_layers == 0 else 4096,
+            n_threads=n_threads,
+            n_gpu_layers=self.n_gpu_layers,
+            use_mmap=True,
+            flash_attn=(self.n_gpu_layers != 0),  # Flash Attention only for GPU
+            verbose=False,
+        )
+
+        # Quantized KV Cache (Q8_0) — halves VRAM usage, ~0% quality loss
+        # Only enable for GPU mode where VRAM savings matter
+        if self.n_gpu_layers != 0:
+            try:
+                llama_kwargs["type_k"] = 8   # GGML_TYPE_Q8_0
+                llama_kwargs["type_v"] = 8   # GGML_TYPE_Q8_0
+                llama_kwargs["offload_kqv"] = True  # Keep K/V tensors in VRAM
+            except Exception:
+                pass  # Older llama-cpp-python versions may not support these
+
         try:
-            self._llm = Llama(
-                model_path=str(model_path),
-                n_ctx=self.n_ctx,
-                n_batch=2048 if self.n_gpu_layers == 0 else 4096,
-                n_threads=n_threads,
-                n_gpu_layers=self.n_gpu_layers,
-                use_mmap=True,
-                flash_attn=(self.n_gpu_layers != 0),  # Flash Attention only for GPU
-                verbose=False,
-            )
+            self._llm = Llama(**llama_kwargs)
         finally:
             # Restore stderr
             if _stderr_fd is not None: