superlocalmemory 3.2.3 → 3.3.1

package/src/superlocalmemory/cli/commands.py

@@ -41,6 +41,12 @@ def dispatch(args: Namespace) -> None:
         "hooks": cmd_hooks,
         "session-context": cmd_session_context,
         "observe": cmd_observe,
+        # V3.3 commands
+        "decay": cmd_decay,
+        "quantize": cmd_quantize,
+        "consolidate": cmd_consolidate,
+        "soft-prompts": cmd_soft_prompts,
+        "reap": cmd_reap,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -102,6 +108,11 @@ def cmd_mode(args: Namespace) -> None:
         )
         updated.save()
         print(f"Mode set to: {args.value.upper()}")
+
+        # V3.3: Check if embedding model changed — inform about re-indexing
+        if (config.embedding.provider != updated.embedding.provider
+                or config.embedding.model_name != updated.embedding.model_name):
+            print("  ⚠ Embedding model changed. Re-indexing will run on next recall.")
     else:
         print(f"Current mode: {config.mode.value.upper()}")
 
@@ -1118,27 +1129,122 @@ def cmd_hooks(args: Namespace) -> None:
 
 
 def cmd_session_context(args: Namespace) -> None:
-    """Print session context (for hook scripts and piping)."""
-    from superlocalmemory.hooks.auto_recall import AutoRecall
+    """Print session context (for hook scripts and piping).
+
+    Uses a FAST PATH that queries SQLite directly (no engine/Ollama needed).
+    This ensures the SessionStart hook completes within its 15s timeout even
+    when Ollama requires a 60s+ cold start.  The fast path returns:
+      - Core Memory blocks (always-on context)
+      - Recent high-importance memories (last 7 days)
+      - Session summary from last session
+    Falls back to the full engine path only if --full is passed explicitly.
+    """
+    import sqlite3
+    from pathlib import Path
     from superlocalmemory.core.config import SLMConfig
-    from superlocalmemory.core.engine import MemoryEngine
 
+    use_full = getattr(args, "full", False)
+
+    if use_full:
+        # Full engine path (slow, requires Ollama) — for explicit CLI use
+        try:
+            from superlocalmemory.hooks.auto_recall import AutoRecall
+            from superlocalmemory.core.engine import MemoryEngine
+            config = SLMConfig.load()
+            engine = MemoryEngine(config)
+            engine.initialize()
+            auto = AutoRecall(
+                engine=engine,
+                config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
+            )
+            context = auto.get_session_context(
+                query=getattr(args, "query", "") or "recent decisions and important context",
+            )
+            if context:
+                print(context)
+        except Exception as exc:
+            logger.debug("session-context (full) failed: %s", exc)
+        return
+
+    # ── FAST PATH: direct SQLite, no engine, <500ms ──────────────
     try:
         config = SLMConfig.load()
-        engine = MemoryEngine(config)
-        engine.initialize()
+        db_path = config.base_dir / "memory.db"
+        if not db_path.exists():
+            return
 
-        auto = AutoRecall(
-            engine=engine,
-            config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
-        )
-        context = auto.get_session_context(
-            query=getattr(args, "query", "") or "recent decisions and important context",
-        )
-        if context:
-            print(context)
+        pid = config.active_profile
+        conn = sqlite3.connect(str(db_path))
+        conn.row_factory = sqlite3.Row
+        sections = []
+
+        # 1. Core Memory blocks (compiled high-value context)
+        try:
+            rows = conn.execute(
+                "SELECT block_type, content FROM core_memory_blocks "
+                "WHERE profile_id = ? ORDER BY block_type",
+                (pid,),
+            ).fetchall()
+            if rows:
+                blocks = [f"[{r['block_type']}] {r['content']}" for r in rows]
+                sections.append("## Core Memory\n" + "\n".join(blocks))
+        except sqlite3.OperationalError:
+            pass
+
+        # 2. Recent important memories (last 7 days, top 10 by importance)
+        try:
+            rows = conn.execute(
+                "SELECT content, fact_type, created_at FROM atomic_facts "
+                "WHERE profile_id = ? "
+                "AND created_at >= datetime('now', '-7 days') "
+                "AND lifecycle = 'active' "
+                "ORDER BY importance DESC, created_at DESC LIMIT 10",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = []
+                for r in rows:
+                    content = r["content"][:200]
+                    items.append(f"- [{r['fact_type'] or 'fact'}] {content}")
+                sections.append("## Recent Context (7 days)\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        # 3. Session markers (last session summary)
+        try:
+            rows = conn.execute(
+                "SELECT content, created_at FROM atomic_facts "
+                "WHERE profile_id = ? AND content LIKE 'Session%' "
+                "ORDER BY created_at DESC LIMIT 3",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = [f"- {r['content'][:150]}" for r in rows]
+                sections.append("## Recent Sessions\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        # 4. V3.3 Soft prompts (auto-learned patterns)
+        try:
+            rows = conn.execute(
+                "SELECT category, content FROM soft_prompt_templates "
+                "WHERE profile_id = ? AND active = 1 "
+                "ORDER BY confidence DESC LIMIT 5",
+                (pid,),
+            ).fetchall()
+            if rows:
+                items = [f"- [{r['category']}] {r['content'][:150]}" for r in rows]
+                sections.append("## Learned Patterns\n" + "\n".join(items))
+        except sqlite3.OperationalError:
+            pass
+
+        conn.close()
+
+        if sections:
+            header = f"# SLM Session Context — {config.active_profile}"
+            print(header + "\n\n" + "\n\n".join(sections))
     except Exception as exc:
-        logger.debug("session-context failed: %s", exc)
+        logger.debug("session-context (fast) failed: %s", exc)
 
 
 def cmd_observe(args: Namespace) -> None:
@@ -1174,3 +1280,301 @@ def cmd_observe(args: Namespace) -> None:
             print(f"Not captured: {decision.reason}")
     except Exception as exc:
         logger.debug("observe failed: %s", exc)
+
+
+# -- V3.3 Commands -----------------------------------------------------------
+
+
+def cmd_decay(args: Namespace) -> None:
+    """Run Ebbinghaus forgetting decay cycle."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    use_json = getattr(args, "json", False)
+    dry_run = getattr(args, "dry_run", True)
+    profile = getattr(args, "profile", "")
+
+    try:
+        config = SLMConfig.load()
+        engine = MemoryEngine(config)
+        engine.initialize()
+        pid = profile or engine.profile_id
+
+        from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+        from superlocalmemory.learning.forgetting_scheduler import (
+            ForgettingScheduler,
+        )
+
+        ebbinghaus = EbbinghausCurve(config.forgetting)
+        scheduler = ForgettingScheduler(
+            engine._db, ebbinghaus, config.forgetting,
+        )
+        result = scheduler.run_decay_cycle(pid, force=True)
+    except Exception as exc:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("decay", error={"code": "DECAY_ERROR", "message": str(exc)})
+            sys.exit(1)
+        raise
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("decay", data={"dry_run": dry_run, **result},
+                   next_actions=[
+                       {"command": "slm decay --execute --json", "description": "Apply transitions"},
+                       {"command": "slm status --json", "description": "Check system status"},
+                   ])
+        return
+
+    if result.get("skipped"):
+        print(f"Skipped: {result.get('reason', 'unknown')}")
+        return
+
+    total = result.get("total", 0)
+    print(f"Decay cycle complete (dry_run={dry_run})")
+    print(f"  Total facts:  {total}")
+    print(f"  Active:       {result.get('active', 0)}")
+    print(f"  Warm:         {result.get('warm', 0)}")
+    print(f"  Cold:         {result.get('cold', 0)}")
+    print(f"  Archive:      {result.get('archive', 0)}")
+    print(f"  Forgotten:    {result.get('forgotten', 0)}")
+    print(f"  Transitions:  {result.get('transitions', 0)}")
+
+
+def cmd_quantize(args: Namespace) -> None:
+    """Run EAP embedding quantization cycle."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    use_json = getattr(args, "json", False)
+    dry_run = getattr(args, "dry_run", True)
+    profile = getattr(args, "profile", "")
+
+    try:
+        config = SLMConfig.load()
+        engine = MemoryEngine(config)
+        engine.initialize()
+        pid = profile or engine.profile_id
+
+        from superlocalmemory.math.ebbinghaus import EbbinghausCurve
+        from superlocalmemory.dynamics.eap_scheduler import EAPScheduler
+        from superlocalmemory.storage.quantized_store import (
+            QuantizedEmbeddingStore,
+        )
+
+        from superlocalmemory.math.polar_quant import PolarQuantEncoder
+        from superlocalmemory.math.qjl import QJLEncoder
+
+        ebbinghaus = EbbinghausCurve(config.forgetting)
+        polar = PolarQuantEncoder(config.quantization.polar)
+        qjl = QJLEncoder(config.quantization.qjl)
+        qstore = QuantizedEmbeddingStore(
+            engine._db, polar, qjl, config.quantization,
+        )
+        scheduler = EAPScheduler(
+            engine._db, ebbinghaus, qstore, config.quantization,
+        )
+        result = scheduler.run_eap_cycle(pid)
+    except Exception as exc:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("quantize", error={"code": "EAP_ERROR", "message": str(exc)})
+            sys.exit(1)
+        raise
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("quantize", data={"dry_run": dry_run, **result},
+                   next_actions=[
+                       {"command": "slm quantize --execute --json", "description": "Apply changes"},
+                       {"command": "slm status --json", "description": "Check status"},
+                   ])
+        return
+
+    print(f"EAP quantization cycle (dry_run={dry_run})")
+    print(f"  Total:       {result.get('total', 0)}")
+    print(f"  Downgrades:  {result.get('downgrades', 0)}")
+    print(f"  Upgrades:    {result.get('upgrades', 0)}")
+    print(f"  Skipped:     {result.get('skipped', 0)}")
+    print(f"  Errors:      {result.get('errors', 0)}")
+
+
+def cmd_consolidate(args: Namespace) -> None:
+    """Run cognitive consolidation pipeline."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    use_json = getattr(args, "json", False)
+    cognitive = getattr(args, "cognitive", False)
+    profile = getattr(args, "profile", "")
+
+    if not cognitive:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("consolidate", error={
+                "code": "MISSING_FLAG",
+                "message": "Use --cognitive to run CCQ pipeline",
+            })
+            sys.exit(1)
+        print("Use --cognitive to run CCQ consolidation pipeline.")
+        print("  slm consolidate --cognitive")
+        return
+
+    try:
+        config = SLMConfig.load()
+        engine = MemoryEngine(config)
+        engine.initialize()
+        pid = profile or engine.profile_id
+
+        from superlocalmemory.encoding.cognitive_consolidator import (
+            CognitiveConsolidator,
+        )
+
+        consolidator = CognitiveConsolidator(db=engine._db)
+        result = consolidator.run_pipeline(pid)
+    except Exception as exc:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("consolidate", error={
+                "code": "CCQ_ERROR", "message": str(exc),
+            })
+            sys.exit(1)
+        raise
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("consolidate", data={
+            "clusters_found": result.clusters_found,
+            "blocks_created": result.blocks_created,
+            "facts_archived": result.facts_archived,
+            "compression_ratio": round(result.compression_ratio, 3),
+        }, next_actions=[
+            {"command": "slm list --json", "description": "List recent memories"},
+            {"command": "slm status --json", "description": "Check status"},
+        ])
+        return
+
+    print("CCQ Cognitive Consolidation")
+    print(f"  Clusters found:     {result.clusters_found}")
+    print(f"  Blocks created:     {result.blocks_created}")
+    print(f"  Facts archived:     {result.facts_archived}")
+    print(f"  Compression ratio:  {result.compression_ratio:.3f}")
+
+
+def cmd_soft_prompts(args: Namespace) -> None:
+    """List active soft prompts (auto-learned user patterns)."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    use_json = getattr(args, "json", False)
+    profile = getattr(args, "profile", "")
+
+    try:
+        config = SLMConfig.load()
+        engine = MemoryEngine(config)
+        engine.initialize()
+        pid = profile or engine.profile_id
+
+        rows = engine._db.execute(
+            "SELECT prompt_id, category, content, confidence, "
+            "  effectiveness, token_count, version, created_at "
+            "FROM soft_prompt_templates "
+            "WHERE profile_id = ? AND active = 1 "
+            "ORDER BY confidence DESC",
+            (pid,),
+        )
+        prompts = []
+        for row in rows:
+            r = dict(row)
+            prompts.append({
+                "prompt_id": r["prompt_id"],
+                "category": r["category"],
+                "content": r["content"],
+                "confidence": round(float(r["confidence"]), 3),
+                "effectiveness": round(float(r["effectiveness"]), 3),
+                "token_count": int(r["token_count"]),
+                "version": int(r["version"]),
+                "created_at": r["created_at"],
+            })
+    except Exception as exc:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("soft-prompts", error={
+                "code": "QUERY_ERROR", "message": str(exc),
+            })
+            sys.exit(1)
+        raise
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("soft-prompts", data={
+            "prompts": prompts, "count": len(prompts), "profile": pid,
+        }, next_actions=[
+            {"command": "slm status --json", "description": "Check status"},
+        ])
+        return
+
+    if not prompts:
+        print("No active soft prompts.")
+        return
+
+    print(f"Active soft prompts ({len(prompts)}):\n")
+    for i, p in enumerate(prompts, 1):
+        print(f"  {i}. [{p['category']}] (conf={p['confidence']:.2f})")
+        content_preview = p["content"][:100]
+        if len(p["content"]) > 100:
+            content_preview += "..."
+        print(f"     {content_preview}")
+
+
+def cmd_reap(args: Namespace) -> None:
+    """Find and kill orphaned SLM processes."""
+    use_json = getattr(args, "json", False)
+    dry_run = not getattr(args, "force", False)
+
+    try:
+        from superlocalmemory.infra.process_reaper import (
+            cleanup_all_orphans,
+            ReaperConfig,
+        )
+
+        config = ReaperConfig()
+        result = cleanup_all_orphans(config, dry_run=dry_run)
+    except Exception as exc:
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("reap", error={
+                "code": "REAP_ERROR", "message": str(exc),
+            })
+            sys.exit(1)
+        raise
+
+    if use_json:
+        from superlocalmemory.cli.json_output import json_print
+        json_print("reap", data={
+            "dry_run": dry_run,
+            "total_found": result.get("total_found", 0),
+            "orphans_found": result.get("orphans_found", 0),
+            "killed": result.get("killed", 0),
+            "skipped": result.get("skipped", 0),
+        }, next_actions=[
+            {"command": "slm reap --force --json", "description": "Kill orphans"},
+            {"command": "slm status --json", "description": "Check status"},
+        ])
+        return
+
+    total = result.get("total_found", 0)
+    orphans = result.get("orphans_found", 0)
+    killed = result.get("killed", 0)
+    skipped = result.get("skipped", 0)
+
+    if dry_run:
+        print(f"Process reaper (dry run)")
+    else:
+        print(f"Process reaper")
+    print(f"  Total SLM processes: {total}")
+    print(f"  Orphans found:       {orphans}")
+    print(f"  Killed:              {killed}")
+    print(f"  Skipped:             {skipped}")
+    if dry_run and orphans > 0:
+        print("\n  Use --force to kill orphaned processes.")

package/src/superlocalmemory/cli/main.py

@@ -187,6 +187,50 @@ def main() -> None:
     obs_p = sub.add_parser("observe", help="Auto-capture content (pipe or argument)")
     obs_p.add_argument("content", nargs="?", default="", help="Content to evaluate")
 
+    # -- V3.3 Commands -------------------------------------------------
+    decay_p = sub.add_parser("decay", help="Run Ebbinghaus forgetting decay cycle")
+    decay_p.add_argument(
+        "--dry-run", action="store_true", default=True,
+        help="Preview without applying (default)",
+    )
+    decay_p.add_argument(
+        "--execute", dest="dry_run", action="store_false",
+        help="Apply zone transitions",
+    )
+    decay_p.add_argument("--profile", default="", help="Target profile")
+    decay_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
+    quantize_p = sub.add_parser("quantize", help="Run EAP embedding quantization cycle")
+    quantize_p.add_argument(
+        "--dry-run", action="store_true", default=True,
+        help="Preview without applying (default)",
+    )
+    quantize_p.add_argument(
+        "--execute", dest="dry_run", action="store_false",
+        help="Apply precision changes",
+    )
+    quantize_p.add_argument("--profile", default="", help="Target profile")
+    quantize_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
+    consolidate_p = sub.add_parser("consolidate", help="Run memory consolidation pipeline")
+    consolidate_p.add_argument(
+        "--cognitive", action="store_true",
+        help="Run CCQ cognitive consolidation",
+    )
+    consolidate_p.add_argument("--profile", default="", help="Target profile")
+    consolidate_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
+    sp_p = sub.add_parser("soft-prompts", help="List active soft prompts (auto-learned patterns)")
+    sp_p.add_argument("--profile", default="", help="Target profile")
+    sp_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
+    reap_p = sub.add_parser("reap", help="Find and kill orphaned SLM processes")
+    reap_p.add_argument(
+        "--force", action="store_true",
+        help="Kill orphans (default: dry run only)",
+    )
+    reap_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+
     args = parser.parse_args()
 
     if not args.command: