simplicio-loop 3.4.0__tar.gz → 3.9.0__tar.gz

{simplicio_loop-3.4.0/simplicio_loop.egg-info → simplicio_loop-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.4.0
+Version: 3.9.0
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (6 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT

{simplicio_loop-3.4.0 → simplicio_loop-3.9.0}/README.md

@@ -145,7 +145,7 @@ The orchestrator discovers work from any source via pluggable adapters. Each exp
 
 See each adapter's reference doc under `.claude/skills/simplicio-tasks/references/`.
 
-|---
+---
 
 ## 🌐 11 runtimes, one protocol
 
@@ -378,17 +378,25 @@ does this routing for OpenAI-compatible clients at install time.
 
 ### 📈 Simplicio Token Monitor
 
-A live, always-on view of the savings:
+A view of the savings you open when you want — only the capture is always-on:
 
+- **Capture proxy** — **always-on** (the one auto-started service; the wired clients need it
+  reachable). It silently captures + measures Claude + Codex + Hermes in the background.
 - **Web dashboard** — `http://127.0.0.1:9090` — real-time token chart, savings gauge, the LLMs/runtimes
-  and **141/144 providers (98%)** we intercept, and a live proxy log.
+  and **141/144 providers (98%)** we intercept, a live proxy log. **Opens once on the first install**
+  so you see it works, then it's **on-demand** — re-open it any of these ways:
+  - `simplicio-loop dashboard` — works from anywhere after the pip install (no repo path needed);
+    `simplicio-loop dashboard --stop` to close, `--no-browser` to just start the server.
+  - `bash scripts/simplicio-economy.sh monitor` (repo checkout) · `… monitor stop` to close.
+  - just **ask the agent** — "open the token dashboard".
 - **Menu-bar / tray widget** — live tokens saved in the system tray (macOS rumps · Windows/Linux pystray).
-- **One module** — `scripts/simplicio-economy.sh {status|up|wire}` brings up the capture proxy + monitor +
-  tray + the `simplicio-dev-cli` deterministic operator and reports the whole stack.
+  **On-demand:** `bash scripts/simplicio-economy.sh tray` · `… tray stop`.
 
-Install registers all three as auto-start services (macOS launchd · Linux systemd · Windows Startup) via
-`scripts/setup_simplicio.sh`, or the cross-platform `python3 scripts/install_services.py install`. After
-install the monitor + capture run **without invoking the loop** — see `references/token-capture.md`.
+Install auto-starts **only the capture proxy** (macOS launchd · Linux systemd · Windows Startup). The
+dashboard opens **once** on a fresh install (marker-guarded — a re-install/update never reopens it; opt
+out with `SIMPLICIO_NO_DASHBOARD=1`), and the tray never opens by itself — nothing is forced to stay
+open. Manage the stack: `scripts/simplicio-economy.sh {status|up|monitor|tray|wire}`. After install,
+capture runs **without invoking the loop** — see `references/token-capture.md`.
 
 ### 🛠️ The capture engine — one native module, every command
 
@@ -431,7 +439,7 @@ Without the extra, the deterministic stdlib path covers everything; models downl
 (axum reverse proxy), `simplicio-parity` (Rust↔Python parity harness). Build with `maturin` — the Python
 engine works fully without them; the crates only add native speed.
 
-|---
+---
 
 ## 🏛️ Design pillars (in detail)
 
@@ -453,11 +461,45 @@ git clone https://github.com/wesleysimplicio/simplicio-loop
 cd simplicio-loop
 
 # install for your runtime (omit <runtime> to auto-detect)
-bash scripts/install.sh <runtime> [--global]        # macOS / Linux
-pwsh scripts/install.ps1 <runtime> [-Global]        # Windows
+bash scripts/install.sh <runtime> [--global] [--minimal]        # macOS / Linux
+pwsh scripts/install.ps1 <runtime> [-Global]                    # Windows
 # <runtime> ∈ claude codex vscode cursor antigravity kiro opencode gemini aider hermes openclaw
 ```
 
+**Install is complete by default — it installs everything.** One command sets up the whole stack:
+the two loop operators (`simplicio-mapper` + `simplicio-cli`, auto-handling PEP 668 / externally-managed
+Python and symlinking the binaries onto `PATH`), the **full Python stack** (the package + the `[onnx]`
+models backend: onnxruntime + huggingface_hub + tokenizers + pillow, so `simplicio kompress/router/embed/image`
+work), the **6 skills + hooks** with the loop's Stop hook wired, and the **always-on capture proxy**
+with Claude + Codex + Hermes **routed and measured** in the background. The **dashboard opens once** on a
+fresh install, then it's on-demand (`simplicio-loop dashboard` / `simplicio-economy.sh monitor`); the
+**menu-bar tray never opens by itself** — nothing is forced to stay open.
+Pass **`--minimal`** only for headless/CI to skip the heavy deps + the machine services. Verify any time:
+`bash scripts/simplicio-economy.sh status`.
+
+### Update
+
+```bash
+bash scripts/update.sh [<runtime>]    # git pull → reinstall skills/hooks/operators → restart services
+```
+
+`update.sh` stashes local edits, fast-forwards `main`, reinstalls from the fresh source, restarts the
+launchd/systemd services so they run the new code, and prints the live stack + savings.
+
+### Doctor — verify + repair
+
+```bash
+python3 scripts/doctor.py            # report the whole stack (REQUIRED vs OPTIONAL)
+python3 scripts/doctor.py --repair   # install/wire what's fixable; make everything operational
+# also: bash scripts/simplicio-economy.sh doctor [--repair]
+```
+
+`doctor` separates **REQUIRED** (python3, the two loop operators, the 6 skills, the loop hooks, the
+capture proxy — `--repair` installs/wires them) from **OPTIONAL** accelerators (the ONNX models
+backend, the native **Rust** core, the tray dep). **Missing an optional piece is never a failure and
+never blocks** — the Python engine + the deterministic path cover everything; the exit code is 0 as
+long as every REQUIRED item is healthy.
+
 Or, on Claude Code / Cursor, add it as a marketplace plugin:
 
 ```

{simplicio_loop-3.4.0 → simplicio_loop-3.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simplicio-loop"
-version = "3.4.0"
+version = "3.9.0"
 description = "The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (6 skills) that drains any queue of work end-to-end on any LLM/runtime."
 readme = "PYPI.md"
 requires-python = ">=3.8"

simplicio_loop-3.9.0/simplicio_loop/__init__.py

@@ -0,0 +1,18 @@
+"""simplicio-loop — The Universal Looping AI Orchestrator.
+
+A runtime-agnostic super-plugin (6 skills + loop/token hooks) that drains any
+queue of work end-to-end on any LLM/runtime. This package ships the skills and
+hooks and installs them into a runtime's skills location.
+"""
+
+# Single source of truth = the package metadata (pyproject `version`); the literal is only a
+# fallback for an editable/source checkout that was never installed. No more version drift.
+try:
+    from importlib.metadata import version as _v, PackageNotFoundError
+
+    try:
+        __version__ = _v("simplicio-loop")
+    except PackageNotFoundError:
+        __version__ = "3.9.0"
+except Exception:  # pragma: no cover
+    __version__ = "3.9.0"

{simplicio_loop-3.4.0 → simplicio_loop-3.9.0}/simplicio_loop/_bundle/hooks/simplicio_dashboard.py

@@ -21,6 +21,7 @@ import re
 import socket
 import subprocess
 import sys
+import tempfile
 import time
 from pathlib import Path
 
@@ -42,7 +43,8 @@ LOGO_CANDIDATES = [
     REPO_ROOT / "assets" / "simplicio-loop-logo.png",
     Path(HOME) / "Projetos" / "ai" / "simplicio-runtime" / "site" / "assets" / "img" / "simplicio-logo.png",
 ]
-PID_FILE = Path("/tmp") / "simplicio-token-monitor.pid"
+# Cross-platform temp dir (Windows has no /tmp) — must match simplicio_loop/cli.py PID_FILE.
+PID_FILE = Path(tempfile.gettempdir()) / "simplicio-token-monitor.pid"
 PROXY_PORT = os.environ.get("SIMPLICIO_PROXY_PORT", os.environ.get("HEADROOM_PORT", "8788"))
 # Engine call: the native Simplicio engine module, invoked cross-platform via this interpreter.
 ENGINE_CMD = [sys.executable or "python3", str(REPO_ROOT / "engine" / "simplicio_engine.py")]
@@ -60,6 +62,9 @@ RUNTIMES = [
     {"name": "Hermes", "load": "native recall", "loop": "native loop", "state": "native", "intercept": "baseurl", "logo": "hermes", "proc": r"hermes", "families": ["deepseek", "openai"]},
     {"name": "Cursor", "load": ".cursor-plugin", "loop": "Stop hook", "state": "full", "intercept": "baseurl", "logo": "cursor", "proc": r"Cursor\.app|Cursor Helper", "families": ["openai", "anthropic"]},
     {"name": "OpenCode", "load": "AGENTS.md", "loop": "self-paced", "state": "partial", "intercept": "baseurl", "logo": "opencode", "proc": r"opencode", "families": ["openai", "anthropic"]},
+    {"name": "Gemini", "load": "GEMINI.md", "loop": "self-paced", "state": "partial", "intercept": "none", "logo": "gemini", "proc": r"\bgemini\b", "families": []},
+    {"name": "Kiro", "load": ".kiro/steering", "loop": "spec tick", "state": "partial", "intercept": "none", "logo": "kiro", "proc": r"\bkiro\b", "families": []},
+    {"name": "Antigravity", "load": "rules", "loop": "self-paced", "state": "partial", "intercept": "none", "logo": "antigravity", "proc": r"antigravity", "families": []},
 ]
 
 # ── Brand badge: faithful inline vector of the Simplicio hexagon-S mark ───────
@@ -854,8 +859,11 @@ class Handler(http.server.BaseHTTPRequestHandler):
 def main():
     port = int(os.environ.get("PORT", "9090"))
     srv = http.server.HTTPServer(("127.0.0.1", port), Handler)
-    with open(PID_FILE, "w") as f:
-        f.write(str(os.getpid()))
+    try:  # the PID file lets `simplicio-loop dashboard --stop` find us; never fatal if it can't be written
+        PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+        PID_FILE.write_text(str(os.getpid()))
+    except OSError:
+        pass
     print(f"⬡ Simplicio Token Monitor · http://127.0.0.1:{port}")
     print(f"   api: /api/status · refresh: 3s")
     try:

simplicio_loop-3.9.0/simplicio_loop/cli.py

@@ -0,0 +1,180 @@
+"""CLI for simplicio-loop: install the bundled skills + hooks into a runtime."""
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import webbrowser
+from pathlib import Path
+
+from . import __version__
+
+BUNDLE = Path(__file__).resolve().parent / "_bundle"
+DASHBOARD = BUNDLE / "hooks" / "simplicio_dashboard.py"
+# Cross-platform temp dir (Windows has no /tmp) — must match hooks/simplicio_dashboard.py.
+PID_FILE = Path(tempfile.gettempdir()) / "simplicio-token-monitor.pid"
+DEFAULT_DASH_PORT = int(os.environ.get("SIMPLICIO_MONITOR_PORT", "9090"))
+
+
+def _gui_available() -> bool:
+    """True only when opening a browser is safe + non-blocking. On headless Linux (no DISPLAY),
+    webbrowser.open() may launch a text browser that inherits stdin and blocks forever — and a
+    blocking wait() is NOT caught by try/except — so we must skip it there."""
+    if sys.platform == "darwin" or os.name == "nt":
+        return True
+    return bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+
+
+def _copy_tree(src: Path, dst: Path) -> int:
+    """Copy every file under src into dst, preserving structure. Returns file count."""
+    count = 0
+    for item in src.rglob("*"):
+        if item.is_file():
+            out = dst / item.relative_to(src)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(item, out)
+            count += 1
+    return count
+
+
+def install(target: Path, globally: bool) -> int:
+    base = (Path.home() / ".claude") if globally else (target / ".claude")
+    skills_dst = base / "skills"
+    hooks_dst = (base / "hooks") if globally else (target / "hooks")
+
+    if not (BUNDLE / "skills").is_dir():
+        print("error: bundled skills not found in the installed package.", flush=True)
+        return 1
+
+    n_skills = _copy_tree(BUNDLE / "skills", skills_dst)
+    n_hooks = _copy_tree(BUNDLE / "hooks", hooks_dst)
+
+    print(f"simplicio-loop {__version__} installed:")
+    print(f"  skills -> {skills_dst}  ({n_skills} files)")
+    print(f"  hooks  -> {hooks_dst}  ({n_hooks} files)")
+    print("")
+    print("Use it in your agent runtime (Claude Code, Cursor, ...):")
+    print("  /simplicio-tasks finish all the open issues")
+    return 0
+
+
+def _port_up(port: int) -> bool:
+    try:
+        with socket.create_connection(("127.0.0.1", port), 0.5):
+            return True
+    except OSError:
+        return False
+
+
+def _stop_dashboard() -> int:
+    """Best-effort stop: kill the PID the dashboard recorded, then any stray server."""
+    killed = False
+    try:
+        pid = int(PID_FILE.read_text().strip())
+        os.kill(pid, 15)
+        killed = True
+    except (OSError, ValueError):
+        pass
+    if os.name != "nt":  # pkill catches a server started outside this CLI
+        try:
+            subprocess.run(["pkill", "-f", "simplicio_dashboard.py"], check=False)
+            killed = True
+        except OSError:
+            pass
+    try:
+        PID_FILE.unlink()
+    except OSError:
+        pass
+    print("⬡ Token Monitor stopped." if killed else "⬡ dashboard was not running.")
+    return 0
+
+
+def dashboard(port: int, open_browser: bool, stop: bool) -> int:
+    """Open (or stop) the Simplicio Token Monitor dashboard — works from anywhere after a pip
+    install, no repo checkout needed. Starts the bundled server detached if it's not already up,
+    then opens the browser. The dashboard is on-demand: nothing keeps it open, close it freely."""
+    if stop:
+        return _stop_dashboard()
+    url = f"http://127.0.0.1:{port}"
+    if not DASHBOARD.is_file():
+        print("error: bundled dashboard not found in the installed package.", flush=True)
+        return 1
+    if not _port_up(port):
+        logdir = Path.home() / ".simplicio" / "logs"
+        logdir.mkdir(parents=True, exist_ok=True)
+        env = {**os.environ, "PORT": str(port)}
+        # Detach so the server outlives this CLI process (own session / no console window).
+        kw = {"start_new_session": True} if os.name != "nt" else {
+            "creationflags": 0x00000008 | 0x00000200}  # DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP
+        with open(logdir / "token-monitor.log", "ab") as logf:
+            try:
+                subprocess.Popen([sys.executable or "python3", str(DASHBOARD)],
+                                 env=env, stdout=logf, stderr=logf, stdin=subprocess.DEVNULL, **kw)
+            except OSError as e:
+                print(f"error: could not start the dashboard ({e}).", flush=True)
+                return 1
+        for _ in range(25):  # wait up to ~5s for the port to come up
+            if _port_up(port):
+                break
+            time.sleep(0.2)
+    if not _port_up(port):
+        print(f"⬡ failed to start the dashboard — see ~/.simplicio/logs/token-monitor.log", flush=True)
+        return 1
+    print(f"⬡ Simplicio Token Monitor → {url}")
+    if open_browser and _gui_available():
+        try:
+            webbrowser.open(url)
+        except Exception:
+            pass
+    print("   stop it any time:  simplicio-loop dashboard --stop")
+    return 0
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="simplicio-loop",
+        description=(
+            "Install the simplicio-loop super-plugin (6 AI-orchestration skills + "
+            "loop/token-economy hooks) into a runtime's skills location, or open the "
+            "Token Monitor dashboard."
+        ),
+    )
+    parser.add_argument(
+        "command", nargs="?", default="install", choices=["install", "dashboard"],
+        help="action to run: install (default) or dashboard (open the Token Monitor)",
+    )
+    parser.add_argument(
+        "--target", default=".",
+        help="project directory to install into (default: current directory)",
+    )
+    parser.add_argument(
+        "--global", dest="globally", action="store_true",
+        help="install into ~/.claude instead of the project",
+    )
+    parser.add_argument(
+        "--port", type=int, default=DEFAULT_DASH_PORT,
+        help="dashboard port (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--no-browser", dest="no_browser", action="store_true",
+        help="dashboard: start the server but do not open a browser",
+    )
+    parser.add_argument(
+        "--stop", action="store_true", help="dashboard: stop a running Token Monitor",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"simplicio-loop {__version__}",
+    )
+    args = parser.parse_args(argv)
+    if args.command == "dashboard":
+        return dashboard(args.port, not args.no_browser, args.stop)
+    return install(Path(args.target).resolve(), args.globally)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{simplicio_loop-3.4.0 → simplicio_loop-3.9.0/simplicio_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simplicio-loop
-Version: 3.4.0
+Version: 3.9.0
 Summary: The Universal Looping AI Orchestrator — a runtime-agnostic super-plugin (6 skills) that drains any queue of work end-to-end on any LLM/runtime.
 Author-email: Wesley Simplicio <wesleybob4@gmail.com>
 License: MIT

simplicio_loop-3.4.0/simplicio_loop/__init__.py

@@ -1,8 +0,0 @@
-"""simplicio-loop — The Universal Looping AI Orchestrator.
-
-A runtime-agnostic super-plugin (6 skills + loop/token hooks) that drains any
-queue of work end-to-end on any LLM/runtime. This package ships the skills and
-hooks and installs them into a runtime's skills location.
-"""
-
-__version__ = "1.0.3"

simplicio_loop-3.4.0/simplicio_loop/cli.py

@@ -1,76 +0,0 @@
-"""CLI for simplicio-loop: install the bundled skills + hooks into a runtime."""
-from __future__ import annotations
-
-import argparse
-import shutil
-from pathlib import Path
-
-from . import __version__
-
-BUNDLE = Path(__file__).resolve().parent / "_bundle"
-
-
-def _copy_tree(src: Path, dst: Path) -> int:
-    """Copy every file under src into dst, preserving structure. Returns file count."""
-    count = 0
-    for item in src.rglob("*"):
-        if item.is_file():
-            out = dst / item.relative_to(src)
-            out.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(item, out)
-            count += 1
-    return count
-
-
-def install(target: Path, globally: bool) -> int:
-    base = (Path.home() / ".claude") if globally else (target / ".claude")
-    skills_dst = base / "skills"
-    hooks_dst = (base / "hooks") if globally else (target / "hooks")
-
-    if not (BUNDLE / "skills").is_dir():
-        print("error: bundled skills not found in the installed package.", flush=True)
-        return 1
-
-    n_skills = _copy_tree(BUNDLE / "skills", skills_dst)
-    n_hooks = _copy_tree(BUNDLE / "hooks", hooks_dst)
-
-    print(f"simplicio-loop {__version__} installed:")
-    print(f"  skills -> {skills_dst}  ({n_skills} files)")
-    print(f"  hooks  -> {hooks_dst}  ({n_hooks} files)")
-    print("")
-    print("Use it in your agent runtime (Claude Code, Cursor, ...):")
-    print("  /simplicio-tasks finish all the open issues")
-    return 0
-
-
-def main(argv=None) -> int:
-    parser = argparse.ArgumentParser(
-        prog="simplicio-loop",
-        description=(
-            "Install the simplicio-loop super-plugin (6 AI-orchestration skills + "
-            "loop/token-economy hooks) into a runtime's skills location."
-        ),
-    )
-    parser.add_argument(
-        "command", nargs="?", default="install", choices=["install"],
-        help="action to run (default: install)",
-    )
-    parser.add_argument(
-        "--target", default=".",
-        help="project directory to install into (default: current directory)",
-    )
-    parser.add_argument(
-        "--global", dest="globally", action="store_true",
-        help="install into ~/.claude instead of the project",
-    )
-    parser.add_argument(
-        "-V", "--version", action="version", version=f"simplicio-loop {__version__}",
-    )
-    args = parser.parse_args(argv)
-    if args.command == "install":
-        return install(Path(args.target).resolve(), args.globally)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())