simplicio-cli 0.4.3__tar.gz → 0.5.1__tar.gz

{simplicio_cli-0.4.3/simplicio_cli.egg-info → simplicio_cli-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-cli
-Version: 0.4.3
+Version: 0.5.1
 Summary: Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT
@@ -36,8 +36,12 @@ Requires-Dist: simplicio-prompt>=1.12.0
 Requires-Dist: httpx>=0.27
 Requires-Dist: orjson>=3.10
 Requires-Dist: diskcache>=5.6
+Requires-Dist: libcst>=1.8
 Provides-Extra: bench
 Requires-Dist: fpdf2>=2.7; extra == "bench"
+Provides-Extra: local
+Requires-Dist: llama-cpp-python>=0.3.2; extra == "local"
+Requires-Dist: huggingface-hub>=0.23; extra == "local"
 Dynamic: license-file
 
 # simplicio-cli
@@ -351,7 +355,9 @@ The install ships **three Simplicio packages** that play distinct roles:
   (`bench/run_fanout.py`) measures both real PHPUnit pass-rate and a
   structural regex check on every subagent and surfaces the gap; full
   ongoing numbers in [`bench/results_fanout.md`](bench/results_fanout.md) ·
-  [`bench/results_fanout.pdf`](bench/results_fanout.pdf).
+  [`bench/results_fanout.pdf`](bench/results_fanout.pdf). Set
+  `BENCH_SINDICO_SRC` / `BENCH_SINDICO_WORK` when the local
+  `sistema-sindico` checkout and work copy are not under `/tmp`.
 
 Each is independently published on PyPI; ship them as a set so the CLI's
 mapper-rich precedent ranking, contract-shaped prompts, and (when called
@@ -540,6 +546,7 @@ user prompt. UserPromptSubmit is the right pre-hook for routing decisions.
 | DeepSeek | `deepseek-chat` | `https://api.deepseek.com` |
 | OpenAI | `gpt-4.1` | `https://api.openai.com/v1` |
 | Local (Ollama) | `llama3` | `http://localhost:11434/v1` |
+| Local (in-process) | `local-llama/default` | *(leave unset)* |
 | Anthropic native | `claude-opus-4-7` | *(leave unset)* |
 
 If `SIMPLICIO_BASE_URL` is unset and the key is `ANTHROPIC_API_KEY`, it uses the
@@ -550,6 +557,40 @@ your `base_url` — so **any** OpenAI-like provider works without code changes.
 simplicio smoke      # prints provider config + one test call
 ```
 
+### Path 4 — offline-first local model (zero key, zero HTTP)
+
+simplicio ships an **in-process** backend powered by
+[`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python). When **no
+provider is configured** (`SIMPLICIO_MODEL` *and* `SIMPLICIO_BASE_URL` both
+unset), it runs **Qwen2.5-Coder-1.5B-Instruct (Q5_K_M GGUF)** directly — small,
+code-specialized, fast on CPU, no API key, no Ollama, no HTTP overhead. The
+6-layer contract is what makes a 1.5B usable: it lifts the same model from ~34%
+to ~88% pass-rate on the local benchmark.
+
+```bash
+pip install 'simplicio-cli[local]'          # pulls llama-cpp-python + huggingface-hub
+
+simplicio task "add input validation to createUser" \
+  --target src/users.ts --local              # forces the local model
+
+# the GGUF is fetched once from the Hugging Face Hub, then cached + reused
+```
+
+Explicit routes (override the default model/weights):
+
+```bash
+SIMPLICIO_MODEL=local-llama/default                                  # bundled default
+SIMPLICIO_MODEL=local-llama/bartowski/Qwen2.5-Coder-7B-Instruct-GGUF::Qwen2.5-Coder-7B-Instruct-Q4_K_M.gguf
+SIMPLICIO_MODEL=local-llama//models/my-model.gguf                    # direct local path
+SIMPLICIO_LOCAL_MODEL_PATH=/models/my-model.gguf                     # always wins
+```
+
+Tuning knobs (all optional): `SIMPLICIO_LOCAL_CTX` (context window, default
+`8192`), `SIMPLICIO_LOCAL_THREADS`, `SIMPLICIO_LOCAL_GPU_LAYERS` (offload to GPU,
+default `0`), `SIMPLICIO_LOCAL_MAX_TOKENS` (generation cap),
+`SIMPLICIO_LOCAL_TEMP` (default `0.1`), `SIMPLICIO_LOCAL_MODEL_REPO` /
+`SIMPLICIO_LOCAL_MODEL_FILE`.
+
 ### The pipeline (both paths)
 
 Whichever entry point you use, each task runs through the same engine:

{simplicio_cli-0.4.3 → simplicio_cli-0.5.1}/README.md

@@ -309,7 +309,9 @@ The install ships **three Simplicio packages** that play distinct roles:
   (`bench/run_fanout.py`) measures both real PHPUnit pass-rate and a
   structural regex check on every subagent and surfaces the gap; full
   ongoing numbers in [`bench/results_fanout.md`](bench/results_fanout.md) ·
-  [`bench/results_fanout.pdf`](bench/results_fanout.pdf).
+  [`bench/results_fanout.pdf`](bench/results_fanout.pdf). Set
+  `BENCH_SINDICO_SRC` / `BENCH_SINDICO_WORK` when the local
+  `sistema-sindico` checkout and work copy are not under `/tmp`.
 
 Each is independently published on PyPI; ship them as a set so the CLI's
 mapper-rich precedent ranking, contract-shaped prompts, and (when called
@@ -498,6 +500,7 @@ user prompt. UserPromptSubmit is the right pre-hook for routing decisions.
 | DeepSeek | `deepseek-chat` | `https://api.deepseek.com` |
 | OpenAI | `gpt-4.1` | `https://api.openai.com/v1` |
 | Local (Ollama) | `llama3` | `http://localhost:11434/v1` |
+| Local (in-process) | `local-llama/default` | *(leave unset)* |
 | Anthropic native | `claude-opus-4-7` | *(leave unset)* |
 
 If `SIMPLICIO_BASE_URL` is unset and the key is `ANTHROPIC_API_KEY`, it uses the
@@ -508,6 +511,40 @@ your `base_url` — so **any** OpenAI-like provider works without code changes.
 simplicio smoke      # prints provider config + one test call
 ```
 
+### Path 4 — offline-first local model (zero key, zero HTTP)
+
+simplicio ships an **in-process** backend powered by
+[`llama-cpp-python`](https://github.com/abetlen/llama-cpp-python). When **no
+provider is configured** (`SIMPLICIO_MODEL` *and* `SIMPLICIO_BASE_URL` both
+unset), it runs **Qwen2.5-Coder-1.5B-Instruct (Q5_K_M GGUF)** directly — small,
+code-specialized, fast on CPU, no API key, no Ollama, no HTTP overhead. The
+6-layer contract is what makes a 1.5B usable: it lifts the same model from ~34%
+to ~88% pass-rate on the local benchmark.
+
+```bash
+pip install 'simplicio-cli[local]'          # pulls llama-cpp-python + huggingface-hub
+
+simplicio task "add input validation to createUser" \
+  --target src/users.ts --local              # forces the local model
+
+# the GGUF is fetched once from the Hugging Face Hub, then cached + reused
+```
+
+Explicit routes (override the default model/weights):
+
+```bash
+SIMPLICIO_MODEL=local-llama/default                                  # bundled default
+SIMPLICIO_MODEL=local-llama/bartowski/Qwen2.5-Coder-7B-Instruct-GGUF::Qwen2.5-Coder-7B-Instruct-Q4_K_M.gguf
+SIMPLICIO_MODEL=local-llama//models/my-model.gguf                    # direct local path
+SIMPLICIO_LOCAL_MODEL_PATH=/models/my-model.gguf                     # always wins
+```
+
+Tuning knobs (all optional): `SIMPLICIO_LOCAL_CTX` (context window, default
+`8192`), `SIMPLICIO_LOCAL_THREADS`, `SIMPLICIO_LOCAL_GPU_LAYERS` (offload to GPU,
+default `0`), `SIMPLICIO_LOCAL_MAX_TOKENS` (generation cap),
+`SIMPLICIO_LOCAL_TEMP` (default `0.1`), `SIMPLICIO_LOCAL_MODEL_REPO` /
+`SIMPLICIO_LOCAL_MODEL_FILE`.
+
 ### The pipeline (both paths)
 
 Whichever entry point you use, each task runs through the same engine:

{simplicio_cli-0.4.3 → simplicio_cli-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simplicio-cli"
-version = "0.4.3"
+version = "0.5.1"
 description = "Portable task-to-code pipeline that works with any LLM. Turn a one-line task into a verified code change — diff + test + verify loop. +55 pts on a 156-check benchmark, 21% faster, ~same tokens."
 readme = "README.md"
 license = { text = "MIT" }
@@ -50,10 +50,14 @@ dependencies = [
   "httpx>=0.27",
   "orjson>=3.10",
   "diskcache>=5.6",
+  "libcst>=1.8",
 ]
 
 [project.optional-dependencies]
 bench = ["fpdf2>=2.7"]
+# Offline-first in-process inference (Path 4). Pulls the llama.cpp Python
+# bindings plus huggingface-hub to fetch the default Qwen2.5-Coder-1.5B GGUF.
+local = ["llama-cpp-python>=0.3.2", "huggingface-hub>=0.23"]
 
 [project.urls]
 Homepage = "https://github.com/wesleysimplicio/simplicio-cli"
@@ -73,7 +77,16 @@ where = ["."]
 include = ["simplicio*"]
 
 [tool.setuptools.package-data]
-simplicio = ["templates/*.md", "templates/*.sh"]
+simplicio = [
+  "templates/*.md",
+  "templates/*.sh",
+  "templates/recipes/**/*.json",
+  "templates/recipes/**/*.yaml",
+  "templates/recipes/**/*.yml",
+  "templates/stacks/**/*",
+  "templates/stacks/*/tree/.gitignore",
+  "templates/stacks/*/tree/.eslintrc.json",
+]
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

simplicio_cli-0.5.1/simplicio/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.1"

simplicio_cli-0.5.1/simplicio/_cache.py

@@ -0,0 +1,269 @@
+"""Content-addressed completion cache for provider outputs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import tempfile
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+def _env_flag(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() not in {"0", "false", "no", "off"}
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or not raw.strip():
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def _cache_root() -> Path:
+    override = os.environ.get("SIMPLICIO_CACHE_DIR")
+    if override:
+        return Path(override)
+    return Path.home() / ".simplicio" / "cache"
+
+
+def make_key(provider_id: str, model: str, prompt: str, **kwargs: Any) -> str:
+    payload = {
+        "v": 1,
+        "provider_id": provider_id,
+        "model": model,
+        "prompt": prompt,
+        "kwargs": kwargs,
+    }
+    raw = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+
+@dataclass
+class CacheEntry:
+    completion: str
+    provider_id: str = ""
+    model: str = ""
+    created_at: float = field(default_factory=time.time)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "completion": self.completion,
+            "provider_id": self.provider_id,
+            "model": self.model,
+            "created_at": self.created_at,
+            "metadata": dict(self.metadata),
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "CacheEntry":
+        return cls(
+            completion=str(payload.get("completion", "")),
+            provider_id=str(payload.get("provider_id", "")),
+            model=str(payload.get("model", "")),
+            created_at=float(payload.get("created_at") or time.time()),
+            metadata=dict(payload.get("metadata") or {}),
+        )
+
+
+class CompletionCache:
+    def __init__(
+        self,
+        root: Optional[Path] = None,
+        *,
+        ttl_days: Optional[float] = None,
+        max_mb: Optional[float] = None,
+    ) -> None:
+        self.root = Path(root) if root is not None else _cache_root()
+        self.ttl_days = (
+            ttl_days
+            if ttl_days is not None
+            else _env_float("SIMPLICIO_CACHE_TTL_DAYS", 30)
+        )
+        self.max_mb = (
+            max_mb if max_mb is not None else _env_float("SIMPLICIO_CACHE_MAX_MB", 500)
+        )
+        self.hits = 0
+        self.misses = 0
+        self.puts = 0
+
+    @property
+    def enabled(self) -> bool:
+        return _env_flag("SIMPLICIO_CACHE", True)
+
+    @property
+    def bust(self) -> bool:
+        return _env_flag("SIMPLICIO_BUST_CACHE", False)
+
+    def path_for(self, key: str) -> Path:
+        return self.root / key[:2] / f"{key}.json"
+
+    def get(self, key: str) -> Optional[CacheEntry]:
+        if not self.enabled or self.bust:
+            self.misses += 1
+            return None
+        path = self.path_for(key)
+        try:
+            if not path.exists():
+                self.misses += 1
+                return None
+            if self._is_expired(path):
+                self._safe_unlink(path)
+                self.misses += 1
+                return None
+        except OSError:
+            self.misses += 1
+            return None
+        try:
+            with path.open("r", encoding="utf-8") as handle:
+                entry = CacheEntry.from_dict(json.load(handle))
+                self.hits += 1
+                return entry
+        except (OSError, ValueError, TypeError):
+            self._safe_unlink(path)
+            self.misses += 1
+            return None
+
+    def put(self, key: str, entry: CacheEntry) -> None:
+        if not self.enabled:
+            return
+        path = self.path_for(key)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            fd, tmp_name = tempfile.mkstemp(
+                prefix=f".{path.stem}.",
+                suffix=".tmp",
+                dir=str(path.parent),
+            )
+        except OSError:
+            return
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as handle:
+                json.dump(entry.to_dict(), handle, sort_keys=True)
+            try:
+                os.replace(tmp_name, path)
+            except OSError:
+                return
+        finally:
+            if os.path.exists(tmp_name):
+                self._safe_unlink(Path(tmp_name))
+        self.puts += 1
+        self._evict_if_needed()
+
+    def clear(self) -> int:
+        n = self.stats()["entries"]
+        if self.root.exists():
+            shutil.rmtree(self.root)
+        return int(n)
+
+    def stats(self) -> Dict[str, Any]:
+        files = list(self._files())
+        total_bytes = sum(path.stat().st_size for path in files if path.exists())
+        now = time.time()
+        oldest = None
+        if files:
+            oldest = max(0.0, now - min(path.stat().st_mtime for path in files))
+        return {
+            "enabled": self.enabled,
+            "bust": self.bust,
+            "root": str(self.root),
+            "entries": len(files),
+            "hits": self.hits,
+            "misses": self.misses,
+            "puts": self.puts,
+            "hit_rate": round(self.hits / (self.hits + self.misses), 4)
+            if self.hits + self.misses
+            else 0.0,
+            "bytes": total_bytes,
+            "mb": round(total_bytes / (1024 * 1024), 3),
+            "oldest_age_s": round(oldest, 3) if oldest is not None else None,
+            "ttl_days": self.ttl_days,
+            "max_mb": self.max_mb,
+        }
+
+    def _files(self) -> list[Path]:
+        try:
+            if not self.root.exists():
+                return []
+            return [
+                path
+                for path in self.root.rglob("*.json")
+                if path.is_file() and _is_completion_cache_file(self.root, path)
+            ]
+        except OSError:
+            return []
+
+    def _is_expired(self, path: Path) -> bool:
+        if self.ttl_days <= 0:
+            return False
+        max_age = self.ttl_days * 86400
+        return (time.time() - path.stat().st_mtime) > max_age
+
+    def _evict_if_needed(self) -> None:
+        max_bytes = int(max(0.0, self.max_mb) * 1024 * 1024)
+        if max_bytes <= 0:
+            return
+        files = self._files()
+        total = sum(path.stat().st_size for path in files if path.exists())
+        if total <= max_bytes:
+            return
+        for path in sorted(files, key=lambda p: p.stat().st_mtime):
+            size = path.stat().st_size
+            self._safe_unlink(path)
+            total -= size
+            if total <= max_bytes:
+                break
+
+    @staticmethod
+    def _safe_unlink(path: Path) -> None:
+        try:
+            path.unlink()
+        except OSError:
+            return
+
+
+_cache: Optional[CompletionCache] = None
+
+
+def cache() -> CompletionCache:
+    global _cache
+    if _cache is None:
+        _cache = CompletionCache()
+    return _cache
+
+
+def _is_completion_cache_file(root: Path, path: Path) -> bool:
+    try:
+        rel = path.relative_to(root)
+    except ValueError:
+        return False
+    return (
+        len(rel.parts) == 2
+        and len(path.stem) == 64
+        and rel.parts[0] == path.stem[:2]
+    )
+
+
+def reset_for_tests() -> None:
+    global _cache
+    _cache = None
+
+
+__all__ = [
+    "CacheEntry",
+    "CompletionCache",
+    "cache",
+    "make_key",
+    "reset_for_tests",
+]

simplicio_cli-0.5.1/simplicio/cache_cli.py

@@ -0,0 +1,68 @@
+"""cache_cli.py — `simplicio cache` subcommand (stats / clear).
+
+Lightweight management surface for the content-addressed completion cache
+landed by issue #34.
+
+  simplicio cache stats            print hit/miss/size/oldest
+  simplicio cache clear            wipe cache directory
+  simplicio cache stats --json     machine-readable
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from ._cache import cache
+
+
+def _cmd_stats(args: argparse.Namespace) -> int:
+    s = cache().stats()
+    if args.json:
+        print(json.dumps({
+            "entries": s.entries,
+            "size_bytes": s.size_bytes,
+            "size_mb": round(s.size_bytes / (1024 * 1024), 2),
+            "oldest_age_days": s.oldest_age_days,
+            "enabled": s.enabled,
+            "bust_active": s.bust_active,
+            "root": s.root,
+        }, indent=2))
+        return 0
+    print(f"simplicio cache stats")
+    print(f"  root              {s.root}")
+    print(f"  enabled           {'yes' if s.enabled else 'no (SIMPLICIO_CACHE=0)'}")
+    print(f"  bust active       {'YES (SIMPLICIO_BUST_CACHE=1)' if s.bust_active else 'no'}")
+    print(f"  entries           {s.entries}")
+    print(f"  size              {s.size_bytes / (1024 * 1024):.2f} MB")
+    print(f"  oldest entry      {s.oldest_age_days} days")
+    return 0
+
+
+def _cmd_clear(args: argparse.Namespace) -> int:
+    if not args.force:
+        print("[cache] refusing to clear without --force; "
+              "this removes every cached completion.", file=sys.stderr)
+        return 2
+    removed = cache().clear()
+    print(f"[cache] cleared {removed} entries", file=sys.stderr)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="simplicio cache")
+    sub = p.add_subparsers(dest="verb", required=True)
+
+    ps = sub.add_parser("stats", help="show cache size/age/state")
+    ps.add_argument("--json", action="store_true")
+
+    pc = sub.add_parser("clear", help="remove every cached completion")
+    pc.add_argument("--force", action="store_true",
+                    help="required: confirm destructive op")
+
+    args = p.parse_args(argv)
+    if args.verb == "stats":
+        return _cmd_stats(args)
+    if args.verb == "clear":
+        return _cmd_clear(args)
+    return 2