superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/cli/mesh_cmd.py

@@ -1,38 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later
-"""`slm mesh` — inspect the local agent mesh from the terminal (M-03, v3.7.9).
-
-Before 3.7.9 the mesh was reachable only via MCP tools, the dashboard, and
-Claude Code skills — there was no terminal command to check broker health or
-list peer sessions. This is a thin, read-only wrapper over the same
-capability-authenticated `/mesh/*` daemon endpoints the MCP tools use.
-"""
-from __future__ import annotations
-
-import json
-from argparse import Namespace
-
-_ACTION_ENDPOINTS = {
-    "status": "/mesh/status",
-    "peers": "/mesh/peers",
-}
-
-
-def cmd_mesh(args: Namespace) -> int:
-    action = getattr(args, "mesh_action", None)
-    endpoint = _ACTION_ENDPOINTS.get(action)
-    if endpoint is None:
-        print("Usage: slm mesh {status|peers}")
-        return 2
-
-    from superlocalmemory.cli.daemon import daemon_request
-
-    result = daemon_request("GET", endpoint)
-    if result is None:
-        print(
-            "Mesh: cannot reach the daemon broker. Is the daemon running? "
-            "(slm serve start)"
-        )
-        return 1
-    print(json.dumps(result, indent=2, sort_keys=True))
-    return 0

package/src/superlocalmemory/cli/migrate_cmd.py

@@ -1,55 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Migration CLI command implementation."""
-
-from __future__ import annotations
-
-
-def cmd_migrate(args):
-    """Run V2 to V3 migration or rollback."""
-    from superlocalmemory.storage.v2_migrator import V2Migrator
-
-    migrator = V2Migrator()
-
-    if getattr(args, "rollback", False):
-        print("Rolling back V3 migration...")
-        result = migrator.rollback()
-        if result.get("success"):
-            for step in result.get("steps", []):
-                print(f"  [ok] {step}")
-            print("Rollback complete. V2 restored.")
-        else:
-            print(f"Rollback failed: {result.get('error', 'unknown')}")
-        return
-
-    if not migrator.detect_v2():
-        print("No V2 installation found. Nothing to migrate.")
-        return
-
-    if migrator.is_already_migrated():
-        print("Already migrated to V3.")
-        return
-
-    stats = migrator.get_v2_stats()
-    print("V2 installation found:")
-    print(f"  Memories: {stats.get('memory_count', 'unknown')}")
-    print(f"  Size: {stats.get('db_size_mb', '?')} MB")
-    print()
-
-    import sys
-    if sys.stdin.isatty():
-        confirm = input("Proceed with migration? [Y/n] ").strip().lower()
-        if confirm not in ("", "y", "yes"):
-            print("Migration cancelled.")
-            return
-
-    result = migrator.migrate()
-    if result.get("success"):
-        for step in result.get("steps", []):
-            print(f"  [ok] {step}")
-        print()
-        print("Migration complete!")
-    else:
-        print(f"Migration failed: {result.get('error', 'unknown')}")

package/src/superlocalmemory/cli/ops_cmd.py

@@ -1,281 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V4 | https://qualixar.com | https://varunpratap.com
-
-"""``slm ops`` — operational recovery & admin remediation.
-
-Subcommands:
-
-* ``slm ops list [--profile P]``
-      Show all failed, stuck, or degraded operations grouped by category.
-      Proxies GET /operations/failed on the running daemon.
-
-* ``slm ops resolve <id> --action {retry|force_reconcile|cancel}``
-      Admin action on a specific operation.
-      Proxies POST /operations/<id>/resolve on the running daemon.
-
-* ``slm ops status``
-      Quick overview: failure counts + writer stall state from /status.
-      No authentication required (status is public).
-
-RBAC: list / resolve require OWNER or ADMIN role on the daemon.
-Unauthenticated users see a clear permission error.
-
-Part of Qualixar | Author: Varun Pratap Bhardwaj
-"""
-
-from __future__ import annotations
-
-import json as _json
-import sys
-import urllib.error as _uerr
-import urllib.request as _urq
-from argparse import Namespace
-from typing import Any
-
-
-_VALID_ACTIONS = ("retry", "force_reconcile", "cancel")
-
-
-# ---------------------------------------------------------------------------
-# Internal helpers
-# ---------------------------------------------------------------------------
-
-def _get_daemon_port() -> int:
-    """Return the active daemon port (default 8765)."""
-    try:
-        from superlocalmemory.cli.daemon import _get_port
-        return _get_port()
-    except Exception:
-        return 8765
-
-
-def _daemon_get(path: str, timeout_s: float = 10.0) -> dict | None:
-    """HTTP GET to the daemon; return parsed JSON or None on failure."""
-    port = _get_daemon_port()
-    url = f"http://127.0.0.1:{port}{path}"
-    try:
-        with _urq.urlopen(url, timeout=timeout_s) as resp:  # noqa: S310
-            raw = resp.read().decode()
-        return _json.loads(raw)
-    except _uerr.HTTPError as exc:
-        if exc.code == 403:
-            _die(
-                "Permission denied: list/resolve requires OWNER or ADMIN role.\n"
-                "Check your SLM credentials or ask your administrator."
-            )
-        body = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
-        _die(f"Daemon returned HTTP {exc.code}: {body}")
-    except _uerr.URLError as exc:
-        _die(
-            f"Could not reach SLM daemon at {url}: {exc.reason}\n"
-            "Make sure the daemon is running: slm serve"
-        )
-    return None  # unreachable; _die exits
-
-
-def _daemon_post(path: str, body: dict, timeout_s: float = 10.0) -> dict | None:
-    """HTTP POST to the daemon; return parsed JSON or None on failure."""
-    port = _get_daemon_port()
-    url = f"http://127.0.0.1:{port}{path}"
-    try:
-        req = _urq.Request(
-            url,
-            data=_json.dumps(body).encode(),
-            headers={"Content-Type": "application/json"},
-            method="POST",
-        )
-        with _urq.urlopen(req, timeout=timeout_s) as resp:  # noqa: S310
-            raw = resp.read().decode()
-        return _json.loads(raw)
-    except _uerr.HTTPError as exc:
-        if exc.code == 403:
-            _die(
-                "Permission denied: resolve requires OWNER or ADMIN role.\n"
-                "Check your SLM credentials or ask your administrator."
-            )
-        if exc.code == 400:
-            body_txt = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
-            _die(f"Bad request: {body_txt}")
-        body_txt = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
-        _die(f"Daemon returned HTTP {exc.code}: {body_txt}")
-    except _uerr.URLError as exc:
-        _die(
-            f"Could not reach SLM daemon at {url}: {exc.reason}\n"
-            "Make sure the daemon is running: slm serve"
-        )
-    return None  # unreachable; _die exits
-
-
-def _die(message: str) -> None:
-    print(f"error: {message}", file=sys.stderr)
-    sys.exit(1)
-
-
-def _print_json(data: Any) -> None:
-    print(_json.dumps(data, indent=2, default=str))
-
-
-# ---------------------------------------------------------------------------
-# Subcommand handlers
-# ---------------------------------------------------------------------------
-
-def _cmd_ops_list(args: Namespace) -> None:
-    """List all failed, stuck, or degraded operations."""
-    profile = getattr(args, "profile", None)
-    path = "/operations/failed"
-    if profile:
-        path = f"{path}?profile={profile}"
-
-    data = _daemon_get(path)
-    if data is None:
-        return
-
-    if getattr(args, "json", False):
-        _print_json(data)
-        return
-
-    total: int = data.get("total", 0)
-    if total == 0:
-        print("All operations healthy. No failures detected.")
-        return
-
-    print(f"Failed operations: {total} total\n")
-
-    dead_letter = data.get("dead_letter", [])
-    if dead_letter:
-        print(f"--- Dead-letter (ingestion exhausted, {len(dead_letter)}) ---")
-        for entry in dead_letter:
-            print(
-                f"  [{entry.get('operation_id', '?')}] "
-                f"type={entry.get('operation_type', '?')} "
-                f"attempts={entry.get('attempts', '?')} "
-                f"profile={entry.get('profile_id', '?')}"
-            )
-            if entry.get("error"):
-                print(f"    error: {entry['error']}")
-        print()
-
-    degraded = data.get("degraded_manifests", [])
-    if degraded:
-        print(f"--- Degraded manifests ({len(degraded)}) ---")
-        for entry in degraded:
-            print(
-                f"  [{entry.get('operation_id', '?')}] "
-                f"state={entry.get('state', '?')} "
-                f"profile={entry.get('profile_id', '?')}"
-            )
-        print()
-
-    exhausted = data.get("exhausted_obligations", [])
-    if exhausted:
-        print(f"--- Exhausted projection obligations ({len(exhausted)}) ---")
-        for entry in exhausted:
-            print(
-                f"  [{entry.get('operation_id', '?')}] "
-                f"kind={entry.get('kind', '?')} "
-                f"attempts={entry.get('attempts', '?')} "
-                f"profile={entry.get('profile_id', '?')}"
-            )
-        print()
-
-    print("Use `slm ops resolve <id> --action cancel|retry|force_reconcile` to remediate.")
-
-
-def _cmd_ops_resolve(args: Namespace) -> None:
-    """Admin action on a specific operation."""
-    operation_id: str = args.operation_id
-    action: str = args.action
-
-    if action not in _VALID_ACTIONS:
-        _die(f"--action must be one of: {', '.join(_VALID_ACTIONS)}")
-
-    result = _daemon_post(
-        f"/operations/{operation_id}/resolve",
-        {"action": action},
-    )
-    if result is None:
-        return
-
-    if getattr(args, "json", False):
-        _print_json(result)
-        return
-
-    success = result.get("success", False)
-    if success:
-        print(
-            f"OK: operation {operation_id!r} resolved with action={action!r}. "
-            f"{result.get('message', '')}"
-        )
-    else:
-        reason = result.get("reason") or result.get("error") or "unknown reason"
-        print(f"Resolve failed: {reason}", file=sys.stderr)
-        sys.exit(1)
-
-
-def _cmd_ops_status(args: Namespace) -> None:
-    """Quick ops-focused health status from the daemon."""
-    data = _daemon_get("/status")
-    if data is None:
-        return
-
-    fields = {
-        "dead_letter_count": data.get("dead_letter_count", 0),
-        "degraded_operations": data.get("degraded_operations", 0),
-        "exhausted_obligations": data.get("exhausted_obligations", 0),
-        "writer_stalled": data.get("writer_stalled", False),
-        "writer_stalled_op_id": data.get("writer_stalled_op_id"),
-        "writer_stalled_age_s": data.get("writer_stalled_age_s"),
-    }
-
-    if getattr(args, "json", False):
-        _print_json(fields)
-        return
-
-    total_issues = (
-        fields["dead_letter_count"]
-        + fields["degraded_operations"]
-        + fields["exhausted_obligations"]
-    )
-    stalled = fields["writer_stalled"]
-
-    if total_issues == 0 and not stalled:
-        print("Operations status: HEALTHY — no failures detected.")
-        return
-
-    print("Operations status: DEGRADED\n")
-    if fields["dead_letter_count"]:
-        print(f"  dead-letter entries    : {fields['dead_letter_count']}")
-    if fields["degraded_operations"]:
-        print(f"  degraded manifests     : {fields['degraded_operations']}")
-    if fields["exhausted_obligations"]:
-        print(f"  exhausted obligations  : {fields['exhausted_obligations']}")
-    if stalled:
-        op_id = fields["writer_stalled_op_id"] or "?"
-        age = fields["writer_stalled_age_s"]
-        age_str = f" (age {age:.1f}s)" if age is not None else ""
-        print(f"  writer STALLED         : op={op_id}{age_str}")
-    print("\nRun `slm ops list` to see details, or check the dashboard.")
-
-
-# ---------------------------------------------------------------------------
-# Public entry point
-# ---------------------------------------------------------------------------
-
-def cmd_ops(args: Namespace) -> None:
-    """Dispatch ``slm ops`` subcommands."""
-    sub = getattr(args, "ops_command", None)
-    handlers = {
-        "list": _cmd_ops_list,
-        "resolve": _cmd_ops_resolve,
-        "status": _cmd_ops_status,
-    }
-    handler = handlers.get(sub)
-    if handler:
-        handler(args)
-    else:
-        print("Usage: slm ops <list|resolve|status> [options]")
-        print("  slm ops list [--profile P] [--json]")
-        print("  slm ops resolve <id> --action {retry|force_reconcile|cancel} [--json]")
-        print("  slm ops status [--json]")
-        sys.exit(1)

package/src/superlocalmemory/cli/optimize_cmd.py

@@ -1,179 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Handlers for ``slm optimize status|on|off|savings``."""
-
-from __future__ import annotations
-
-import dataclasses
-import json
-import sys
-from argparse import Namespace
-
-from superlocalmemory.cli.optimize_constants import (
-    DEFAULT_COST_PER_MILLION_INPUT_TOKENS,
-    OPTIMIZE_DEFAULT_PORT,
-    _PRICING_DATE,
-)
-
-
-def _get_store():
-    from superlocalmemory.optimize.config.store import ConfigStore
-    return ConfigStore()
-
-
-def _get_cache_db():
-    from superlocalmemory.optimize.storage.db import CacheDB
-    return CacheDB()
-
-
-def _write_config(**fields) -> None:
-    """5-step immutable config-write. Call from any handler."""
-    store = _get_store()
-    cfg = store.get()
-    try:
-        cfg = dataclasses.replace(cfg, **fields)
-        store.save(cfg)
-    except ValueError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-    except OSError as e:
-        print(f"Error writing config: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-def cmd_optimize(args: Namespace) -> None:
-    """Top-level dispatcher for ``slm optimize <subcommand>``."""
-    sub = getattr(args, "opt_command", None)
-    _dispatch = {
-        "status": cmd_optimize_status,
-        "on": cmd_optimize_on,
-        "off": cmd_optimize_off,
-        "savings": cmd_optimize_savings,
-    }
-    handler = _dispatch.get(sub or "")
-    if handler:
-        handler(args)
-    else:
-        print("Usage: slm optimize status|on|off|savings [--json] [--since N]")
-        sys.exit(0)
-
-
-def cmd_optimize_status(args: Namespace) -> None:
-    """Print current Optimize module status."""
-    cfg = _get_store().get()
-    use_json = getattr(args, "json", False)
-
-    proxy_running = False
-    try:
-        import urllib.request
-        _url = f"http://127.0.0.1:{OPTIMIZE_DEFAULT_PORT}/health"
-        _req = urllib.request.Request(_url, method="GET")
-        with urllib.request.urlopen(_req, timeout=1) as _resp:
-            proxy_running = _resp.status == 200
-    except Exception:
-        pass
-
-    if use_json:
-        data = {
-            "status": "ok",
-            "optimize_enabled": cfg.enabled,
-            "cache_enabled": cfg.cache_enabled,
-            "semantic_enabled": cfg.semantic_enabled,
-            "compress_enabled": cfg.compress_enabled,
-            "compress_mode": cfg.compress_mode,
-            "proxy_running": proxy_running,
-            "proxy_port": OPTIMIZE_DEFAULT_PORT,
-            "config_version": cfg.config_version,
-        }
-        print(json.dumps(data, indent=2))
-        return
-
-    state = "ON" if cfg.enabled else "OFF"
-    print(f"Optimize: {state}")
-    print(f"  Cache:     {'enabled' if cfg.cache_enabled else 'disabled'}"
-          f"  (exact: {cfg.ttl.exact_seconds}s TTL,"
-          f" semantic: {'OFF' if not cfg.semantic_enabled else f'{cfg.ttl.semantic_seconds}s'})")
-    print(f"  Compress:  {'enabled' if cfg.compress_enabled else 'disabled'}"
-          f"  (mode: {cfg.compress_mode},"
-          f" prose/L2: {'ON' if cfg.compress_prose else 'OFF'})")
-    if cfg.compress_prose or cfg.compress_mode == "aggressive":
-        print("             note: the live proxy applies LOSSLESS compression only;"
-              " lossy Layer-2 (prose) runs via the slm_compress tool.")
-    proxy_status = f"running on :{OPTIMIZE_DEFAULT_PORT}" if proxy_running else "not running"
-    print(f"  Proxy:     {proxy_status}")
-    print(f"  Config:    ~/.superlocalmemory/optimize.json  (version {cfg.config_version})")
-
-
-def cmd_optimize_on(args: Namespace) -> None:
-    """Enable all Optimize features (cache + compress)."""
-    _write_config(enabled=True, cache_enabled=True, compress_enabled=True)
-    use_json = getattr(args, "json", False)
-    if use_json:
-        print(json.dumps({"status": "ok", "optimize_enabled": True}))
-    else:
-        print("Optimize enabled. Run 'slm proxy' to start the proxy."
-              " Daemon hot-reload: active within 2s.")
-
-
-def cmd_optimize_off(args: Namespace) -> None:
-    """Disable all Optimize features. Does NOT stop proxy."""
-    _write_config(
-        enabled=False,
-        cache_enabled=False,
-        semantic_enabled=False,
-        compress_enabled=False,
-    )
-    use_json = getattr(args, "json", False)
-    if use_json:
-        print(json.dumps({"status": "ok", "optimize_enabled": False}))
-    else:
-        print("Optimize disabled. Proxy (if running) will pass through calls unchanged.")
-
-
-def cmd_optimize_savings(args: Namespace) -> None:
-    """Print token/cost savings from CacheDB.metrics_load()."""
-    since = getattr(args, "since", 7)
-    provider = getattr(args, "provider", None)
-    use_json = getattr(args, "json", False)
-
-    if since <= 0:
-        print("Error: --since must be a positive integer.", file=sys.stderr)
-        sys.exit(1)
-
-    snap = _get_cache_db().metrics_load()
-    cfg = _get_store().get()
-
-    tokens_saved = snap.tokens_saved_input + snap.tokens_saved_output + snap.tokens_saved_compress
-    provider_key = provider or "default"
-    rate = DEFAULT_COST_PER_MILLION_INPUT_TOKENS.get(
-        provider_key,
-        DEFAULT_COST_PER_MILLION_INPUT_TOKENS["default"],
-    )
-    # Allow config overrides
-    if cfg.pricing_overrides and provider_key in cfg.pricing_overrides:
-        rate = cfg.pricing_overrides[provider_key].get("input_per_1m_usd", rate)
-
-    estimated_savings_usd = tokens_saved / 1_000_000 * rate
-
-    if use_json:
-        data = {
-            "exact_hits": snap.hits,
-            "semantic_hits": snap.misses,
-            "tokens_saved": tokens_saved,
-            "estimated_savings_usd": round(estimated_savings_usd, 6),
-            "pricing_date": _PRICING_DATE,
-            "tokens_saved_input": snap.tokens_saved_input,
-            "tokens_saved_output": snap.tokens_saved_output,
-            "tokens_saved_compress": snap.tokens_saved_compress,
-        }
-        print(json.dumps(data, indent=2))
-        return
-
-    print(f"Savings (last {since} days):")
-    print(f"  Exact cache hits:    {snap.hits:>5}   ({snap.tokens_saved_input:,} input tokens saved)")
-    print(f"  Semantic cache hits: {snap.misses:>5}")
-    print(f"  Tokens saved (total): {tokens_saved:,}")
-    print(f"  Estimated savings:  ~${estimated_savings_usd:.4f} (at ${rate:.2f}/M tokens)")
-    print(f"  Pricing date: {_PRICING_DATE}")

package/src/superlocalmemory/cli/optimize_constants.py

@@ -1,31 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Constants shared by Optimize CLI handlers.
-
-No imports from optimize.* at module load time (lazy import in functions only).
-"""
-
-from __future__ import annotations
-
-from typing import Final
-
-OPTIMIZE_DEFAULT_PORT: Final[int] = 8765
-
-# Cache skip saves BOTH input+output tokens (whole call avoided).
-# For CLI display we show the conservative input-price lower bound.
-DEFAULT_COST_PER_MILLION_INPUT_TOKENS: Final[dict[str, float]] = {
-    "anthropic": 3.00,
-    "openai":    2.50,
-    "gemini":    1.25,
-    "default":   3.00,
-}
-_PRICING_DATE: Final[str] = "2026-06-07"
-
-AGGRESSIVE_MODE_WARNING: Final[str] = (
-    "WARNING: Aggressive mode may reduce output fidelity.\n"
-    "  Do NOT use for: code generation, legal text, exact-output tasks, math.\n"
-    "  Safe for: summarization, brainstorming, open-ended chat.\n"
-    "  To revert: slm compress mode safe"
-)