alpiecode 10.7.0__tar.gz → 10.7.2__tar.gz

{alpiecode-10.7.0 → alpiecode-10.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.7.0
+Version: 10.7.2
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.7.0 → alpiecode-10.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alpiecode"
-version = "10.7.0"
+version = "10.7.2"
 description = "AlpieCode"
 requires-python = ">=3.9"
 dependencies = [

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/alpiecode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alpiecode
-Version: 10.7.0
+Version: 10.7.2
 Summary: AlpieCode
 Requires-Python: >=3.9
 Requires-Dist: huggingface_hub>=0.20.0

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/__init__.py

@@ -17,7 +17,7 @@ Supports:
 from pathlib import Path
 from typing import Optional, Any, Dict
 
-__version__ = "10.6.9"
+__version__ = "10.7.2"
 
 def run(task: str, workdir: str = ".", reasoning_level: str = "thinking", **kwargs):
     """Run an autonomous coding task programmatically."""

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/backends/local_backend.py

@@ -439,7 +439,7 @@ class LocalBackend:
             "max_tokens": max_tokens,
             "stream": False,
         }
-        if tools:
+        if tools and getattr(self._cfg, "enable_native_tools", False):
             payload["tools"] = tools
             payload["tool_choice"] = "auto"
         client = httpx.Client(http2=False, timeout=120.0)
@@ -496,7 +496,7 @@ class LocalBackend:
             "max_tokens": max_tokens or 2048,
             "stream": True,
         }
-        if tools:
+        if tools and getattr(self._cfg, "enable_native_tools", False):
             payload["tools"] = tools
             payload["tool_choice"] = "auto"
         client = httpx.Client(http2=False, timeout=120.0)
@@ -874,10 +874,10 @@ class iOSBackend(BasePlatformBackend):
             "max_tokens": max_tokens,
             "stream": False,
         }
-        if tools:
+        if tools and getattr(self._cfg, "enable_native_tools", False):
             payload["tools"] = tools
             payload["tool_choice"] = "auto"
-        resp = httpx.post(f"{bridge_url}/v1/chat/completions", json=payload, timeout=90.0)
+        resp = httpx.post(f"{bridge_url}/v1/chat/completions", json=payload, timeout=300.0)
         if resp.status_code != 200:
             raise RuntimeError(f"iOS bridge HTTP {resp.status_code}: {resp.text}")
         data = json.loads(resp.text)
@@ -953,10 +953,10 @@ class iOSBackend(BasePlatformBackend):
             "max_tokens": max_tokens or 2048,
             "stream": True,
         }
-        if tools:
+        if tools and getattr(self._cfg, "enable_native_tools", False):
             payload["tools"] = tools
             payload["tool_choice"] = "auto"
-        client = httpx.Client(timeout=90.0)
+        client = httpx.Client(timeout=httpx.Timeout(300.0, connect=10.0, read=300.0, write=30.0))
         req = client.build_request("POST", f"{bridge_url}/v1/chat/completions", json=payload)
         resp = client.send(req, stream=True)
         if resp.status_code != 200:
@@ -1056,11 +1056,14 @@ class AndroidBackend(BasePlatformBackend):
         if not model_path:
             self._last_server_error = "No GGUF model found in ~/.alpiecode/models or ~/models."
             return False
-        mmprojs = list(model_path.parent.glob("*mmproj*.gguf"))
-        cmd = [
+        n_ctx = getattr(self._cfg, "n_ctx", 2048)
+        if n_ctx > 2048:
+            n_ctx = 2048
+        n_ctx_val = str(n_ctx)
+        base_cmd = [
             str(server_bin),
             "-m", str(model_path),
-            "-c", "2048",
+            "-c", n_ctx_val,
             "-t", "4",
             "-np", "1",
             "-b", "512",
@@ -1069,10 +1072,21 @@ class AndroidBackend(BasePlatformBackend):
             "--cache-type-v", "q8_0",
             "--port", "8080",
         ]
-        if mmprojs:
-            cmd += ["--mmproj", str(mmprojs[0])]
+        # Only load vision projector if specifically needed to keep RAM footprint under 5GB
+        if getattr(self._cfg, "enable_vision", False):
+            mmprojs = list(model_path.parent.glob("*mmproj*.gguf"))
+            if mmprojs:
+                base_cmd += ["--mmproj", str(mmprojs[0])]
+
+        taskset_bin = shutil.which("taskset")
+        if taskset_bin and os.cpu_count() == 8:
+            cmd = [taskset_bin, "-c", "4-7"] + base_cmd
+        else:
+            cmd = base_cmd
+
         try:
-            print(f"⏳ Starting local llama-server in background ({model_path.name})...")
+            print(f"⏳ Starting Alpie ({model_path.name}) in background...")
+            print(f"   Context window: {n_ctx_val} tokens | Performance cores: 4 | Lean KV cache active")
             subprocess.Popen(
                 cmd,
                 stdout=subprocess.DEVNULL,
@@ -1080,7 +1094,7 @@ class AndroidBackend(BasePlatformBackend):
                 start_new_session=True,
             )
             import time
-            for _ in range(35):
+            for _ in range(40):
                 if self._is_bridge_online():
                     return True
                 time.sleep(0.5)

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/backends/openai_backend.py

@@ -180,7 +180,7 @@ class _HTTPXClient:
         elif "127.0.0.1" in base_url or "localhost" in base_url:
             self.http_client = httpx.Client(
                 http2=False,
-                timeout=httpx.Timeout(180.0, connect=5.0, read=180.0, write=30.0),
+                timeout=httpx.Timeout(300.0, connect=10.0, read=300.0, write=30.0),
                 limits=httpx.Limits(max_keepalive_connections=5, max_connections=10),
             )
         else:

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/cli.py

@@ -263,9 +263,10 @@ def main():
 
     if getattr(args, "offline", False):
         cfg.base_url = "offline"
-        # 8192 default fits 4.4GB model + KV cache 100% in 6GB VRAM (4.75GB / 6GB) with zero host-paging
         import os
-        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", 8192))
+        from .paths import is_android
+        default_ctx = 2048 if is_android() else 8192
+        cfg.n_ctx = int(os.environ.get("ALPIECODE_CTX_SIZE", default_ctx))
         os.environ["ALPIECODE_BASE_URL"] = "offline"
 
     if getattr(args, "ctx_size", None):

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/config.py

@@ -233,9 +233,13 @@ def load_config() -> Config:
         except ValueError:
             pass
 
-    # For offline mode, set high-performance 16k context (16384 tokens) for big multi-file projects
-    # Fits completely in 6GB VRAM on RTX 3050 with zero paging
-    if data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
+    # On mobile (Android / Termux), keep context at 2048 to prevent ZRAM thrashing with 9B models
+    if is_android() and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
+        if data.get("n_ctx", 32768) > 2048:
+            data["n_ctx"] = 2048
+        if data.get("max_tokens", 8192) > 1024:
+            data["max_tokens"] = 1024
+    elif data.get("base_url") == "offline" and not any(os.environ.get(v) for v in ("ALPIECODE_N_CTX", "ALPIECODE_CTX_SIZE")):
         if data.get("n_ctx") in (32768, 4096, 16384):
             data["n_ctx"] = 8192
         if data.get("max_tokens", 8192) > 4096:

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/context.py

@@ -379,8 +379,8 @@ class ContextManager:
         context_blocks.extend(recent_messages)
 
         # ── Budget Verification ──
-        reserved_headroom = 2048 if effective_limit <= 8192 else 4096
-        prompt_budget = max(1024, effective_limit - reserved_headroom)
+        reserved_headroom = 512 if effective_limit <= 2048 else (2048 if effective_limit <= 8192 else 4096)
+        prompt_budget = max(512, effective_limit - reserved_headroom)
 
         if estimate_tokens(context_blocks) > prompt_budget:
             context_blocks = compact_messages(context_blocks, keep_recent=4 if effective_limit <= 8192 else 8)

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/discovery.py

@@ -490,6 +490,15 @@ COMPLEXITY_CONFIG = {
 
 # -- Pre-Read Context Injection ---------------------------------------------
 
+def _is_home_or_root(path: Path) -> bool:
+    """Check if path is the user home directory or system root."""
+    try:
+        resolved = path.resolve()
+        return resolved in (Path.home().resolve(), Path("/").resolve(), Path("C:\\").resolve())
+    except Exception:
+        return False
+
+
 def gather_relevant_context(
     task: str,
     workdir: Path,
@@ -512,8 +521,12 @@ def gather_relevant_context(
 
     task_lower = task.lower().strip()
 
-    # Skip pre-reading repo files for standalone algorithms or scripts (e.g. palindrome, calculator)
-    standalone_kws = ["palindrome", "fibonacci", "quicksort", "bubblesort", "factorial", "hello world", "calculator", "reverse string", "reverse_string"]
+    # Skip pre-reading repo files for standalone algorithms or scripts (e.g. palindrome, calculator, primes)
+    standalone_kws = [
+        "palindrome", "fibonacci", "quicksort", "bubblesort", "factorial",
+        "hello world", "calculator", "reverse string", "reverse_string",
+        "prime", "primes", "prime number", "prime numbers",
+    ]
     if any(kw in task_lower for kw in standalone_kws):
         return None
     sections: List[str] = []
@@ -577,7 +590,9 @@ def gather_relevant_context(
     task_lower = task.lower()
     try:
         all_files = []
-        for p in workdir.rglob("*"):
+        is_broad = _is_home_or_root(workdir)
+        file_iter = workdir.glob("*") if is_broad else workdir.rglob("*")
+        for p in file_iter:
             if p.is_file() and not any(
                 skip in str(p) for skip in [
                     ".git/", "__pycache__", "node_modules", ".venv",
@@ -585,6 +600,8 @@ def gather_relevant_context(
                 ]
             ):
                 all_files.append(str(p.relative_to(workdir)))
+                if len(all_files) >= 500:
+                    break
         # Match filenames or stems mentioned in the task
         for rel in all_files:
             fname = Path(rel).stem.lower()
@@ -609,6 +626,9 @@ def build_symbol_index(workdir: Path, max_files: int = 40) -> Dict[str, List[str
 
     Extracts classes, methods, and functions across Python files.
     """
+    if _is_home_or_root(workdir):
+        return {}
+
     symbols: Dict[str, List[str]] = {}
     count = 0
     import ast

{alpiecode-10.7.0 → alpiecode-10.7.2}/src/codeagent/orchestrator.py

@@ -453,39 +453,31 @@ class AgentOrchestrator:
             yield AgentEvent("turn_start", {"turn": turn, "thinking": turn_enable_thinking})
 
             # In offline mode, guide the model with current workspace progress
-            if is_offline and turn >= 1:
-                existing_files = set(session_touched_files)
-                try:
-                    for ep in session.workdir.rglob("*"):
-                        if ep.is_file() and not any(p in ep.parts for p in (".git", "node_modules", ".venv", "__pycache__", ".alpiecode")):
-                            if ep.name != "walkthrough.md":
-                                rel = ep.relative_to(session.workdir).as_posix()
-                                existing_files.add(rel)
-                except Exception:
-                    pass
-                if existing_files:
-                    file_list = ", ".join(sorted(list(existing_files)))
-                    state_hint = f"[Workspace State: Files created so far: {file_list}. Do NOT re-create these files. Proceed with remaining files or tests.]"
-                    last_msgs = session.context.messages
-                    if last_msgs and not any(state_hint in str(m.get("content", "")) for m in last_msgs[-2:]):
-                        session.context.add_user_message(state_hint)
+            if is_offline and session_touched_files:
+                file_list = ", ".join(sorted(list(session_touched_files)))
+                state_hint = f"[Workspace State: Files created so far: {file_list}. Do NOT re-create these files. Proceed with remaining files or tests.]"
+                last_msgs = session.context.messages
+                if last_msgs and not any(state_hint in str(m.get("content", "")) for m in last_msgs[-2:]):
+                    session.context.add_user_message(state_hint)
 
             try:
                 if is_offline:
                     # In offline mode, dynamically allocate output tokens based on context headroom
-                    n_ctx = getattr(cfg, "n_ctx", 8192)
-                    tools_overhead = 800 if active_tools else 0
+                    n_ctx = getattr(cfg, "n_ctx", 2048 if getattr(session.workdir, "_is_mobile", False) else 8192)
                     try:
                         used_tokens = session.context.estimate_tokens()
                     except Exception:
-                        used_tokens = 1000
+                        used_tokens = 600
 
-                    # If headroom is tight (< 1500 tokens), proactively compact context
-                    if n_ctx - used_tokens - tools_overhead < 1500 and hasattr(session.context, "compact_for_headroom"):
-                        used_tokens = session.context.compact_for_headroom(target_headroom=2048, n_ctx=n_ctx, tools_overhead=tools_overhead)
+                    # Scale headroom threshold with context window (e.g. 512 for 2048 mobile ctx, 1500 for 8192 desktop ctx)
+                    tight_headroom_threshold = 512 if n_ctx <= 2048 else 1500
+                    if n_ctx - used_tokens < tight_headroom_threshold and hasattr(session.context, "compact_for_headroom"):
+                        target_hr = 512 if n_ctx <= 2048 else 2048
+                        used_tokens = session.context.compact_for_headroom(target_headroom=target_hr, n_ctx=n_ctx, tools_overhead=0)
 
-                    available_headroom = max(512, n_ctx - used_tokens - tools_overhead - 64)
-                    max_tokens = min(4096, available_headroom)
+                    available_headroom = max(256, n_ctx - used_tokens - 32)
+                    token_ceiling = 1024 if n_ctx <= 2048 else 4096
+                    max_tokens = min(token_ceiling, available_headroom)
                 elif turn_enable_thinking:
                     max_tokens = max(effective_max_tokens, 16384)
                 else:

{alpiecode-10.7.0 → alpiecode-10.7.2}/test/test_non_thinking_and_local_stream.py

@@ -134,3 +134,123 @@ def test_prompt_builder_lean_offline_prompt():
     assert "You are running in OFFLINE mode" in prompt
     assert "Execution & Goal Convergence Rules" not in prompt
     assert len(prompt) < 3500  # Lean offline prompt under 3500 chars (~600 tokens vs 4500 cloud tokens)
+
+
+def test_android_backend_skips_mmproj_for_code_tasks(tmp_path):
+    from pathlib import Path
+    from codeagent.backends.local_backend import AndroidBackend
+    cfg = Config(base_url="offline")
+    backend = AndroidBackend(cfg)
+
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+    fake_mmproj = tmp_path / "alpie-vl-mmproj-f16.gguf"
+    fake_mmproj.touch()
+
+    with patch.object(backend, "_find_llama_server_bin", return_value=Path("/bin/llama-server")):
+        with patch.object(backend, "_find_gguf_model", return_value=fake_model):
+            with patch("subprocess.Popen") as mock_popen:
+                with patch.object(backend, "_is_bridge_online", side_effect=[False, True]):
+                    backend._ensure_local_server()
+                    assert mock_popen.called
+                    args = mock_popen.call_args[0][0]
+                    # By default (for code tasks), --mmproj must NOT be loaded
+                    assert "--mmproj" not in args
+                    assert "-c" in args
+                    assert "2048" in args
+
+
+def test_offline_orchestrator_turn1_no_workspace_file_explosion(tmp_path):
+    """Verify that offline orchestrator on Turn 1 does not inject thousands of workspace files."""
+    from codeagent.orchestrator import AgentOrchestrator
+    from codeagent.session import SessionManager
+    from codeagent.backends.base import ChatResponse
+
+    # Create dummy files in workspace
+    for i in range(50):
+        (tmp_path / f"file_{i}.txt").write_text("hello")
+
+    cfg = Config(base_url="offline", n_ctx=2048)
+    mock_backend = MagicMock()
+    mock_backend.name = "MockOffline"
+    mock_backend.is_available = True
+    mock_backend.is_offline = True
+    mock_backend.context_window = 2048
+
+    captured_messages = []
+    def mock_chat_stream(messages, **kwargs):
+        captured_messages.append(list(messages))
+        yield ("token", {"delta": "DONE: completed"})
+        yield ("done", ChatResponse(content="DONE: completed"))
+
+    mock_backend.chat_completion_stream = mock_chat_stream
+
+    orchestrator = AgentOrchestrator(mock_backend)
+    session_mgr = SessionManager()
+    session = session_mgr.create_session(tmp_path, max_tokens=2048)
+
+    events = list(orchestrator.run_task(
+        session=session,
+        task="create a python script that calculates prime numbers",
+        cfg=cfg,
+    ))
+
+    # Verify that captured messages did NOT inject workspace file list
+    assert len(captured_messages) > 0
+    first_turn_msgs = captured_messages[0]
+    for msg in first_turn_msgs:
+        content_str = str(msg.get("content", ""))
+        assert "file_49.txt" not in content_str
+        assert "Workspace State: Files created so far" not in content_str
+
+
+def test_local_backend_bridge_omits_tools_payload():
+    """Verify that LocalBackend bridge requests do not include tools payload by default."""
+    from codeagent.backends.local_backend import LocalBackend
+    cfg = Config(base_url="offline")
+    backend = LocalBackend(cfg)
+
+    with patch("httpx.Client") as mock_client_cls:
+        mock_client = MagicMock()
+        mock_resp = MagicMock()
+        mock_resp.status_code = 200
+        mock_resp.text = '{"choices":[{"message":{"content":"hello"}}]}'
+        mock_resp.iter_lines.return_value = ['data: {"choices":[{"delta":{"content":"hi"}}]}', 'data: [DONE]']
+        mock_client.build_request.return_value = MagicMock()
+        mock_client.send.return_value = mock_resp
+        mock_client.post.return_value = mock_resp
+        mock_client_cls.return_value = mock_client
+
+        with patch.object(backend, "_get_bridge_url", return_value="http://127.0.0.1:8080"):
+            # Stream call
+            list(backend._bridge_chat_completion_stream(
+                messages=[{"role": "user", "content": "hi"}],
+                tools=[{"type": "function", "function": {"name": "test"}}],
+            ))
+            _, kwargs = mock_client.build_request.call_args
+            assert "tools" not in kwargs["json"]
+
+            # Non-stream call
+            backend._bridge_chat_completion(
+                messages=[{"role": "user", "content": "hi"}],
+                tools=[{"type": "function", "function": {"name": "test"}}],
+            )
+            _, kwargs = mock_client.post.call_args
+            assert "tools" not in kwargs["json"]
+
+
+def test_discovery_guard_against_home_dir():
+    """Verify that discovery functions safely handle home directory."""
+    from pathlib import Path
+    from codeagent.discovery import _is_home_or_root, build_symbol_index, gather_relevant_context, TaskContext
+    assert _is_home_or_root(Path.home()) is True
+
+    # build_symbol_index should return empty dict without scanning
+    assert build_symbol_index(Path.home()) == {}
+
+    # gather_relevant_context should return None for prime task
+    ctx = TaskContext(project_type="python", file_count=100)
+    res = gather_relevant_context("create a python script that calculates prime numbers", Path.home(), ctx)
+    assert res is None
+
+