alpiecode 10.6.4__tar.gz → 10.6.6__tar.gz

{alpiecode-10.6.4 → alpiecode-10.6.6}/PKG-INFO

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

{alpiecode-10.6.4 → alpiecode-10.6.6}/pyproject.toml

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

{alpiecode-10.6.4 → alpiecode-10.6.6}/src/alpiecode.egg-info/PKG-INFO

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

{alpiecode-10.6.4 → alpiecode-10.6.6}/src/codeagent/__init__.py

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

{alpiecode-10.6.4 → alpiecode-10.6.6}/src/codeagent/backends/local_backend.py

@@ -1,11 +1,14 @@
 import os
 import shutil
+import subprocess
 import sys
-from typing import Any, List, Optional
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
 
 from ..config import Config
 from ..local_model import LocalModel
-from ..paths import is_android, is_ios
+from ..paths import ensure_dir, get_alpiecode_dir, is_android, is_ios
 from .base import ChatResponse, ToolCall
 
 
@@ -425,7 +428,7 @@ class iOSBackend(BasePlatformBackend):
             import llama_cpp
             return True
         except ImportError:
-            return self._is_bridge_online()
+            return self._is_bridge_online() or self._is_wasm_available()
 
     def _get_bridge_url(self) -> str:
         return os.environ.get("IOS_LLAMA_BRIDGE", "http://127.0.0.1:8080").rstrip("/")
@@ -438,6 +441,224 @@ class iOSBackend(BasePlatformBackend):
         except Exception:
             return False
 
+    def _get_wasm_binary_path(self) -> Optional[Path]:
+        """Locate the llama.wasm binary for a-Shell / WASI execution."""
+        custom = os.environ.get("ALPIECODE_WASM_PATH") or os.environ.get("LLAMA_WASM_PATH")
+        if custom and Path(custom).exists():
+            return Path(custom)
+        candidates = [
+            get_alpiecode_dir() / "bin" / "llama.wasm",
+            get_alpiecode_dir() / "bin" / "llama-cli.wasm",
+            Path.home() / "Documents" / ".alpiecode" / "bin" / "llama.wasm",
+            Path.home() / ".alpiecode" / "bin" / "llama.wasm",
+            Path(sys.prefix) / "bin" / "llama.wasm",
+            Path.cwd() / "llama.wasm",
+            Path.cwd() / ".alpiecode" / "bin" / "llama.wasm",
+        ]
+        for c in candidates:
+            if c.is_file():
+                return c
+        w_bin = shutil.which("llama.wasm") or shutil.which("llama-cli.wasm")
+        if w_bin:
+            return Path(w_bin)
+        return None
+
+    def _get_model_path_safe(self) -> Path:
+        """Resolve model path whether _ensure_model returns LocalModel or Path."""
+        model_obj = self._ensure_model()
+        if hasattr(model_obj, "ensure_model"):
+            return model_obj.ensure_model()
+        if hasattr(model_obj, "model_path") and model_obj.model_path:
+            return Path(model_obj.model_path)
+        return Path(model_obj)
+
+    def _is_wasm_available(self) -> bool:
+        """Check if WASM runner (wasm command or executable .wasm) is available in a-Shell."""
+        has_wasm_cmd = shutil.which("wasm") is not None
+        wasm_bin = self._get_wasm_binary_path()
+        return bool(has_wasm_cmd or wasm_bin)
+
+    def _ensure_wasm_runner(self) -> Tuple[str, Path]:
+        """Verify WASM binary and return (wasm_command, wasm_binary_path)."""
+        wasm_bin = self._get_wasm_binary_path()
+        bin_dir = ensure_dir(get_alpiecode_dir() / "bin")
+        default_wasm = bin_dir / "llama.wasm"
+
+        if not wasm_bin:
+            # Attempt automatic download from HuggingFace so user doesn't have to manually transfer files
+            try:
+                from huggingface_hub import hf_hub_download
+                repo = getattr(self._cfg, "model_repo", "169Pi/alpie_learn_gguf")
+                downloaded = hf_hub_download(
+                    repo_id=repo,
+                    filename="llama.wasm",
+                    local_dir=str(bin_dir),
+                )
+                if downloaded and Path(downloaded).exists():
+                    wasm_bin = Path(downloaded)
+            except Exception:
+                pass
+
+        if not wasm_bin:
+            raise RuntimeError(
+                f"\n╭────────────────────────────────────────────────────────────╮\n"
+                f"│  a-Shell WebAssembly Inference:                            │\n"
+                f"│  llama.wasm binary not found.                              │\n"
+                f"│                                                            │\n"
+                f"│  To enable offline inference in a-Shell:                   │\n"
+                f"│  1. Place 'llama.wasm' into:                               │\n"
+                f"│     {str(default_wasm)[:55]:<55}│\n"
+                f"│  2. Or set: export ALPIECODE_WASM_PATH=/path/to/llama.wasm │\n"
+                f"╰────────────────────────────────────────────────────────────╯"
+            )
+
+        runner = shutil.which("wasm") or "wasm"
+        return runner, wasm_bin
+
+    def _format_messages_to_prompt(self, messages: List[dict]) -> str:
+        """Format OpenAI-style message dictionary list into ChatML prompt string."""
+        sanitized = self._sanitize_messages_for_gguf(messages)
+        parts = []
+        for msg in sanitized:
+            role = msg.get("role", "user")
+            content = msg.get("content", "")
+            parts.append(f"<|im_start|>{role}\n{content}<|im_end|>")
+        parts.append("<|im_start|>assistant\n")
+        return "\n".join(parts)
+
+    def _wasm_chat_completion(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: float = 0.2,
+        max_tokens: int = 2048,
+        enable_thinking: bool = True,
+    ) -> ChatResponse:
+        runner, wasm_path = self._ensure_wasm_runner()
+        model_path = self._get_model_path_safe()
+        prompt = self._format_messages_to_prompt(messages)
+
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".txt") as tf:
+            tf.write(prompt)
+            prompt_file = tf.name
+
+        try:
+            n_ctx = str(getattr(self._cfg, "n_ctx", 4096))
+            base_args = [
+                "-m", str(model_path),
+                "-f", prompt_file,
+                "-n", str(max_tokens),
+                "--temp", str(temperature),
+                "-c", n_ctx,
+                "--no-mmap",
+                "--simple-io",
+                "--no-display-prompt",
+                "-t", "4",
+            ]
+            if shutil.which(runner):
+                cmd = [runner, str(wasm_path)] + base_args
+            else:
+                cmd = [str(wasm_path)] + base_args
+
+            res = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+            if res.returncode != 0:
+                err = res.stderr.strip() or res.stdout.strip()
+                if "memory" in err.lower() or "bounds" in err.lower() or "alloc" in err.lower():
+                    raise RuntimeError(
+                        f"\n❌ WASM Memory Allocation Failed for '{model_path.name}'.\n"
+                        f"   The model size ({model_path.stat().st_size / (1024**3):.2f} GB) exceeded the 32-bit WASM limit (~2-4 GB).\n"
+                        f"   Details: {err[:200]}"
+                    )
+                raise RuntimeError(f"WASM llama execution failed (code {res.returncode}): {err[:250]}")
+
+            raw_output = res.stdout.strip()
+            content = raw_output
+            reasoning = None
+            if "<think>" in raw_output and "</think>" in raw_output:
+                p1, p2 = raw_output.split("</think>", 1)
+                reasoning = p1.replace("<think>", "").strip()
+                content = p2.strip()
+            elif "<think>" in raw_output:
+                content = raw_output.replace("<think>", "").strip()
+
+            return ChatResponse(content=content, reasoning=reasoning, tool_calls=None, raw={"output": raw_output})
+        finally:
+            try:
+                os.remove(prompt_file)
+            except Exception:
+                pass
+
+    def _wasm_chat_completion_stream(
+        self,
+        messages: List[dict],
+        tools: Optional[List[dict]] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        enable_thinking: bool = True,
+    ):
+        runner, wasm_path = self._ensure_wasm_runner()
+        model_path = self._get_model_path_safe()
+        prompt = self._format_messages_to_prompt(messages)
+
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False, suffix=".txt") as tf:
+            tf.write(prompt)
+            prompt_file = tf.name
+
+        proc = None
+        try:
+            n_ctx = str(getattr(self._cfg, "n_ctx", 4096))
+            t_val = str(temperature if temperature is not None else 0.2)
+            m_val = str(max_tokens if max_tokens is not None else 2048)
+
+            base_args = [
+                "-m", str(model_path),
+                "-f", prompt_file,
+                "-n", m_val,
+                "--temp", t_val,
+                "-c", n_ctx,
+                "--no-mmap",
+                "--simple-io",
+                "--no-display-prompt",
+                "-t", "4",
+            ]
+            if shutil.which(runner):
+                cmd = [runner, str(wasm_path)] + base_args
+            else:
+                cmd = [str(wasm_path)] + base_args
+
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1)
+            full_content = []
+            for line in proc.stdout:
+                if line:
+                    full_content.append(line)
+                    yield ("token", {"delta": line})
+            proc.wait()
+            if proc.returncode != 0:
+                err = proc.stderr.read().strip() if proc.stderr else ""
+                if "memory" in err.lower() or "bounds" in err.lower():
+                    raise RuntimeError(
+                        f"\n❌ WASM Memory Allocation Failed for '{model_path.name}'.\n"
+                        f"   Details: {err[:200]}"
+                    )
+                if not full_content:
+                    raise RuntimeError(f"WASM execution exited with code {proc.returncode}: {err[:200]}")
+
+            yield ("done", ChatResponse(
+                content="".join(full_content).strip(),
+                reasoning=None,
+                tool_calls=None,
+            ))
+        finally:
+            if proc and proc.poll() is None:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+            try:
+                os.remove(prompt_file)
+            except Exception:
+                pass
+
     def chat_completion(
         self,
         messages: List[dict],
@@ -455,12 +676,18 @@ class iOSBackend(BasePlatformBackend):
         if self._is_bridge_online():
             return self._bridge_chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
 
+        if self._is_wasm_available():
+            return self._wasm_chat_completion(messages, tools, temperature, max_tokens, enable_thinking)
+
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
-            "│  iOS Native Inference:                                     │\n"
+            "│  iOS Native Inference (a-Shell / Container):               │\n"
             "│  Dynamic compilation via pip is disabled on iOS.           │\n"
-            "│  llama.cpp must be pre-bundled with the iOS app container   │\n"
-            "│  or served via a local bridge (e.g. http://127.0.0.1:8080). │\n"
+            "│                                                            │\n"
+            "│  Choose one of the following to run offline on iOS:        │\n"
+            "│  1. a-Shell WASM: Place llama.wasm into ~/.alpiecode/bin/  │\n"
+            "│  2. Local Bridge: Run local server on 127.0.0.1:8080       │\n"
+            "│  3. Pre-bundled: llama.cpp inside iOS app container        │\n"
             "╰────────────────────────────────────────────────────────────╯"
         )
 
@@ -527,12 +754,19 @@ class iOSBackend(BasePlatformBackend):
             yield from self._bridge_chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
             return
 
+        if self._is_wasm_available():
+            yield from self._wasm_chat_completion_stream(messages, tools, temperature, max_tokens, enable_thinking)
+            return
+
         raise RuntimeError(
             "\n╭────────────────────────────────────────────────────────────╮\n"
-            "│  iOS Native Inference:                                     │\n"
+            "│  iOS Native Inference (a-Shell / Container):               │\n"
             "│  Dynamic compilation via pip is disabled on iOS.           │\n"
-            "│  llama.cpp must be pre-bundled with the iOS app container   │\n"
-            "│  or served via a local bridge (e.g. http://127.0.0.1:8080). │\n"
+            "│                                                            │\n"
+            "│  Choose one of the following to run offline on iOS:        │\n"
+            "│  1. a-Shell WASM: Place llama.wasm into ~/.alpiecode/bin/  │\n"
+            "│  2. Local Bridge: Run local server on 127.0.0.1:8080       │\n"
+            "│  3. Pre-bundled: llama.cpp inside iOS app container        │\n"
             "╰────────────────────────────────────────────────────────────╯"
         )
 

{alpiecode-10.6.4 → alpiecode-10.6.6}/test/test_local_model_download.py

@@ -286,3 +286,100 @@ def test_embedded_hf_token_used_when_no_env(monkeypatch):
             from codeagent.local_model import EMBEDDED_HF_TOKEN
             assert EMBEDDED_HF_TOKEN in captured_tokens
 
+
+def test_ios_backend_wasm_dispatch(tmp_path, monkeypatch):
+    """When llama_cpp is absent and bridge is offline, iOSBackend dispatches to WASM runner."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_run = MagicMock()
+    mock_run.returncode = 0
+    mock_run.stdout = "<think>Analyzing code...</think>\nHello from WASM offline!"
+    mock_run.stderr = ""
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.run", return_value=mock_run) as run_spy:
+        res = b.chat_completion([{"role": "user", "content": "hello"}])
+        assert res.content == "Hello from WASM offline!"
+        assert res.reasoning == "Analyzing code..."
+
+        # Verify command arguments
+        assert run_spy.called
+        cmd = run_spy.call_args[0][0]
+        assert cmd[0] == "/usr/bin/wasm"
+        assert cmd[1] == str(wasm_bin)
+        assert "-m" in cmd
+        assert str(fake_model) in cmd
+        assert "-f" in cmd
+
+
+def test_ios_backend_wasm_streaming(tmp_path, monkeypatch):
+    """iOSBackend streams tokens line-by-line via WASM runner."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_proc = MagicMock()
+    mock_proc.stdout = ["Hello ", "from ", "stream!"]
+    mock_proc.returncode = 0
+    mock_proc.poll.return_value = 0
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.Popen", return_value=mock_proc):
+        stream = list(b.chat_completion_stream([{"role": "user", "content": "hi"}]))
+        tokens = [payload["delta"] for tag, payload in stream if tag == "token"]
+        assert "".join(tokens) == "Hello from stream!"
+        assert stream[-1][0] == "done"
+        assert stream[-1][1].content == "Hello from stream!"
+
+
+def test_ios_backend_wasm_memory_error(tmp_path, monkeypatch):
+    """WASM runtime memory allocation failure throws actionable diagnostic."""
+    from codeagent.backends.local_backend import iOSBackend
+    cfg = load_config()
+    b = iOSBackend(cfg)
+
+    wasm_bin = tmp_path / "llama.wasm"
+    wasm_bin.touch()
+    fake_model = tmp_path / "alpie-vl-text-q3_k_m.gguf"
+    fake_model.touch()
+
+    monkeypatch.setenv("ALPIECODE_WASM_PATH", str(wasm_bin))
+
+    mock_run = MagicMock()
+    mock_run.returncode = 1
+    mock_run.stdout = ""
+    mock_run.stderr = "RuntimeError: out of bounds memory access / memory allocation failed"
+
+    with patch.dict("sys.modules", {"llama_cpp": None}), \
+         patch.object(b, "_is_bridge_online", return_value=False), \
+         patch.object(b, "_ensure_model", return_value=fake_model), \
+         patch("shutil.which", return_value="/usr/bin/wasm"), \
+         patch("subprocess.run", return_value=mock_run):
+        with pytest.raises(RuntimeError) as exc_info:
+            b.chat_completion([{"role": "user", "content": "hello"}])
+        assert "WASM Memory Allocation Failed" in str(exc_info.value)
+        assert "32-bit WASM limit" in str(exc_info.value)
+
+