@smilintux/skmemory 0.7.2 → 0.9.2

package/skmemory/mcp_server.py

@@ -32,14 +32,14 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
-from typing import Any, Optional
+from typing import Any
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
-from .store import MemoryStore
 from .models import MemoryLayer
+from .store import MemoryStore
 
 logger = logging.getLogger("skmemory.mcp")
 
@@ -49,7 +49,7 @@ server = Server("skmemory")
 # Shared store instance
 # ---------------------------------------------------------------------------
 
-_store: Optional[MemoryStore] = None
+_store: MemoryStore | None = None
 
 
 def _get_store() -> MemoryStore:
@@ -215,9 +215,7 @@ async def list_tools() -> list[Tool]:
         ),
         Tool(
             name="memory_consolidate",
-            description=(
-                "Compress a session's short-term memories into one mid-term memory."
-            ),
+            description=("Compress a session's short-term memories into one mid-term memory."),
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -275,9 +273,7 @@ async def list_tools() -> list[Tool]:
         ),
         Tool(
             name="memory_health",
-            description=(
-                "Full health check across all backends (primary, vector, graph)."
-            ),
+            description=("Full health check across all backends (primary, vector, graph)."),
             inputSchema={"type": "object", "properties": {}, "required": []},
         ),
         Tool(
@@ -306,6 +302,67 @@ async def list_tools() -> list[Tool]:
                 "required": ["action"],
             },
         ),
+        # ── Synthesis & Auto-Context ──────────────────────────────
+        Tool(
+            name="memory_synthesize_daily",
+            description=(
+                "Synthesize today's (or a given date's) memories into a single "
+                "narrative entry stored in mid-term. No LLM — uses tag frequency, "
+                "emotional arc, and template-based narrative."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "date": {
+                        "type": "string",
+                        "description": "Date to synthesize (YYYY-MM-DD). Defaults to today.",
+                    },
+                },
+                "required": [],
+            },
+        ),
+        Tool(
+            name="memory_synthesize_dreams",
+            description=(
+                "Process dream-engine memories into curated narrative memories "
+                "grouped by theme. Creates one mid-term memory per theme cluster."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "since": {
+                        "type": "string",
+                        "description": (
+                            "Only process dreams after this date (YYYY-MM-DD). "
+                            "Defaults to 7 days ago."
+                        ),
+                    },
+                },
+                "required": [],
+            },
+        ),
+        Tool(
+            name="memory_auto_context",
+            description=(
+                "Search all memory layers for context related to keywords. "
+                "Deduplicates results and ranks by relevance + emotional intensity + importance. "
+                "Returns results within a token budget. Use this for contextual auto-search."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "keywords": {
+                        "type": "string",
+                        "description": "Space-separated keywords to search for.",
+                    },
+                    "token_budget": {
+                        "type": "integer",
+                        "description": "Max tokens for results (default: 2000).",
+                    },
+                },
+                "required": ["keywords"],
+            },
+        ),
         # ── Telegram ───────────────────────────────────────────────
         Tool(
             name="telegram_import",
@@ -524,21 +581,25 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
             promoted = store.promote(memory_id, target, summary=summary)
             if promoted is None:
                 return _error_response(f"Memory not found: {memory_id}")
-            return _json_response({
-                "promoted_id": promoted.id,
-                "source_id": memory_id,
-                "target_layer": target_str,
-            })
+            return _json_response(
+                {
+                    "promoted_id": promoted.id,
+                    "source_id": memory_id,
+                    "target_layer": target_str,
+                }
+            )
 
         elif name == "memory_consolidate":
             session_id = arguments["session_id"]
             summary = arguments["summary"]
             consolidated = store.consolidate_session(session_id, summary)
-            return _json_response({
-                "memory_id": consolidated.id,
-                "session_id": session_id,
-                "consolidated": True,
-            })
+            return _json_response(
+                {
+                    "memory_id": consolidated.id,
+                    "session_id": session_id,
+                    "consolidated": True,
+                }
+            )
 
         elif name == "memory_context":
             token_budget = int(arguments.get("token_budget", 4000))
@@ -589,8 +650,8 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
             return _json_response(health)
 
         elif name == "memory_verify":
-            from .fortress import FortifiedMemoryStore
             from .config import SKMEMORY_HOME
+            from .fortress import FortifiedMemoryStore
 
             fortress = FortifiedMemoryStore(
                 primary=store.primary,
@@ -601,14 +662,102 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
             return _json_response(result)
 
         elif name == "memory_audit":
-            from .fortress import AuditLog
             from .config import SKMEMORY_HOME
+            from .fortress import AuditLog
 
             n = int(arguments.get("last", 20))
             audit = AuditLog(path=SKMEMORY_HOME / "audit.jsonl")
             records = audit.tail(n)
             return _json_response(records)
 
+        # ── Synthesis & Auto-Context tools ────────────────────
+        elif name == "memory_synthesize_daily":
+            from .journal import Journal
+            from .synthesis import JournalSynthesizer
+
+            date = arguments.get("date")
+            synthesizer = JournalSynthesizer(store, Journal())
+            memory = synthesizer.synthesize_daily(date)
+            return _json_response(
+                {
+                    "memory_id": memory.id,
+                    "title": memory.title,
+                    "themes": memory.metadata.get("themes", []),
+                    "memory_count": memory.metadata.get("memory_count", 0),
+                }
+            )
+
+        elif name == "memory_synthesize_dreams":
+            from .journal import Journal
+            from .synthesis import JournalSynthesizer
+
+            since = arguments.get("since")
+            synthesizer = JournalSynthesizer(store, Journal())
+            memories = synthesizer.synthesize_dreams(since)
+            return _json_response(
+                {
+                    "synthesized": len(memories),
+                    "clusters": [
+                        {
+                            "memory_id": m.id,
+                            "title": m.title,
+                            "theme": m.metadata.get("theme", ""),
+                            "dream_count": m.metadata.get("dream_count", 0),
+                        }
+                        for m in memories
+                    ],
+                }
+            )
+
+        elif name == "memory_auto_context":
+            keywords_str = arguments["keywords"]
+            token_budget = int(arguments.get("token_budget", 2000))
+            keywords = keywords_str.split()
+
+            # Search for each keyword and collect results
+            seen_ids: set[str] = set()
+            all_results: list[dict] = []
+
+            for kw in keywords[:10]:  # cap at 10 keywords
+                results = store.search(kw, limit=10)
+                for m in results:
+                    if m.id not in seen_ids:
+                        seen_ids.add(m.id)
+                        all_results.append(
+                            {
+                                "id": m.id,
+                                "title": m.title,
+                                "summary": m.summary or m.content[:200],
+                                "layer": m.layer.value,
+                                "intensity": m.emotional.intensity,
+                                "tags": m.tags[:5],
+                                "source": m.source,
+                            }
+                        )
+
+            # Rank by intensity (higher = more relevant emotional context)
+            all_results.sort(key=lambda r: r["intensity"], reverse=True)
+
+            # Trim to token budget (estimate: title + summary per entry)
+            trimmed: list[dict] = []
+            used_tokens = 0
+            for entry in all_results:
+                text = entry["title"] + " " + entry["summary"]
+                est = int(len(text.split()) * 1.3)
+                if used_tokens + est > token_budget:
+                    break
+                used_tokens += est
+                trimmed.append(entry)
+
+            return _json_response(
+                {
+                    "results": trimmed,
+                    "total_found": len(all_results),
+                    "returned": len(trimmed),
+                    "token_estimate": used_tokens,
+                }
+            )
+
         # ── Telegram tools ────────────────────────────────────
         elif name == "telegram_import":
             from .importers.telegram import import_telegram
@@ -663,17 +812,21 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
         elif name == "telegram_catchup":
             from .importers.telegram_api import import_telegram_api
 
-            chat = args["chat"]
-            limit = args.get("limit", 2000)
-            since = args.get("since")
-            min_length = args.get("min_length", 20)
-            tags_str = args.get("tags", "")
+            chat = arguments["chat"]
+            limit = arguments.get("limit", 2000)
+            since = arguments.get("since")
+            min_length = arguments.get("min_length", 20)
+            tags_str = arguments.get("tags", "")
             tags = [t.strip() for t in tags_str.split(",") if t.strip()] if tags_str else None
 
-            store = MemoryStore()
             stats = import_telegram_api(
-                store, chat, mode="catchup", limit=limit, since=since,
-                min_message_length=min_length, tags=tags,
+                store,
+                chat,
+                mode="catchup",
+                limit=limit,
+                since=since,
+                min_message_length=min_length,
+                tags=tags,
             )
             return _json_response(stats)
 

package/skmemory/models.py

@@ -11,7 +11,7 @@ import hashlib
 import uuid
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -90,12 +90,8 @@ class Memory(BaseModel):
     """
 
     id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    created_at: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
-    updated_at: str = Field(
-        default_factory=lambda: datetime.now(timezone.utc).isoformat()
-    )
+    created_at: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    updated_at: str = Field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
 
     layer: MemoryLayer = Field(default=MemoryLayer.SHORT)
     role: MemoryRole = Field(default=MemoryRole.GENERAL)
@@ -123,11 +119,17 @@ class Memory(BaseModel):
         default_factory=list,
         description="IDs of related memories (graph edges)",
     )
-    parent_id: Optional[str] = Field(
+    parent_id: str | None = Field(
         default=None,
         description="ID of parent memory (for hierarchical chains)",
     )
 
+    context_tag: str = Field(
+        default="@chef-only",
+        description="Audience context tag: @public, @community, @work-circle, @inner-circle, "
+        "@chef-only, or scoped like @work:chiro. Conservative default: @chef-only.",
+    )
+
     intent: str = Field(
         default="",
         description="WHY this memory was stored — the purpose, not just the content. "

package/skmemory/openclaw.py

@@ -19,14 +19,11 @@ Or from the OpenClaw JS plugin (calls CLI under the hood).
 from __future__ import annotations
 
 import json
-import os
 from pathlib import Path
-from typing import Any, Optional
 
-from .models import EmotionalSnapshot, MemoryLayer, MemoryRole
-from .store import MemoryStore
 from .backends.sqlite_backend import SQLiteBackend
-
+from .models import EmotionalSnapshot, MemoryLayer
+from .store import MemoryStore
 
 OPENCLAW_BASE = Path.home() / ".openclaw"
 SKMEMORY_OPENCLAW_DIR = OPENCLAW_BASE / "plugins" / "skmemory"
@@ -48,14 +45,15 @@ class SKMemoryPlugin:
 
     def __init__(
         self,
-        base_path: Optional[str] = None,
-        skvector_url: Optional[str] = None,
-        skvector_key: Optional[str] = None,
+        base_path: str | None = None,
+        skvector_url: str | None = None,
+        skvector_key: str | None = None,
     ) -> None:
         vector = None
         if skvector_url:
             try:
                 from .backends.skvector_backend import SKVectorBackend
+
                 vector = SKVectorBackend(url=skvector_url, api_key=skvector_key)
             except Exception:
                 pass
@@ -97,10 +95,10 @@ class SKMemoryPlugin:
         content: str = "",
         *,
         layer: str = "short-term",
-        tags: Optional[list[str]] = None,
+        tags: list[str] | None = None,
         intensity: float = 0.0,
         valence: float = 0.0,
-        emotions: Optional[list[str]] = None,
+        emotions: list[str] | None = None,
         source: str = "openclaw",
     ) -> str:
         """Capture a memory snapshot.
@@ -152,16 +150,11 @@ class SKMemoryPlugin:
                 "ORDER BY created_at DESC LIMIT ?",
                 (q, q, q, limit),
             ).fetchall()
-            return [
-                self.store.primary._row_to_memory_summary(r) for r in rows
-            ]
+            return [self.store.primary._row_to_memory_summary(r) for r in rows]
         results = self.store.search(query, limit=limit)
-        return [
-            {"id": m.id, "title": m.title, "layer": m.layer.value}
-            for m in results
-        ]
+        return [{"id": m.id, "title": m.title, "layer": m.layer.value} for m in results]
 
-    def recall(self, memory_id: str) -> Optional[dict]:
+    def recall(self, memory_id: str) -> dict | None:
         """Retrieve a full memory by ID.
 
         Args:
@@ -191,7 +184,7 @@ class SKMemoryPlugin:
             "context_prompt": result.context_prompt,
         }
 
-    def export(self, output_path: Optional[str] = None) -> str:
+    def export(self, output_path: str | None = None) -> str:
         """Export all memories to a dated JSON backup.
 
         Args:
@@ -229,9 +222,8 @@ class SKMemoryPlugin:
         """
         try:
             from . import __version__
+
             state["skmemory_version"] = __version__
-            SKMEMORY_STATE_FILE.write_text(
-                json.dumps(state, indent=2), encoding="utf-8"
-            )
+            SKMEMORY_STATE_FILE.write_text(json.dumps(state, indent=2), encoding="utf-8")
         except Exception:
             pass

package/skmemory/post_install.py

@@ -0,0 +1,86 @@
+"""Post-install auto-registration for skmemory.
+
+Runs `skmemory register` automatically after pip install to ensure:
+  - MCP server is registered in Claude Code, Cursor, etc.
+  - Auto-save hooks are installed in Claude Code settings
+  - Skill symlink is created
+
+Called via:
+  - `skmemory-post-install` console script (entry point)
+  - `pip install skmemory && skmemory-post-install`
+  - Automatically on first `skmemory` CLI invocation (if not yet registered)
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def _is_registered() -> bool:
+    """Check if hooks are already installed (quick check)."""
+    settings = Path.home() / ".claude" / "settings.json"
+    if not settings.exists():
+        return False
+    try:
+        import json
+
+        data = json.loads(settings.read_text())
+        hooks = data.get("hooks", {})
+        return "PreCompact" in hooks and "SessionEnd" in hooks
+    except Exception:
+        return False
+
+
+def run_post_install() -> None:
+    """Register skmemory MCP server, hooks, and skill symlinks."""
+    from .register import detect_environments, register_package
+
+    print("skmemory: running post-install registration...")
+
+    detected = detect_environments()
+    if not detected:
+        print("  No supported environments detected. Skipping.")
+        return
+
+    print(f"  Detected: {', '.join(detected)}")
+
+    skill_md = Path(__file__).parent.parent / "SKILL.md"
+    if not skill_md.exists():
+        skill_md = Path(__file__).parent / "SKILL.md"
+
+    result = register_package(
+        name="skmemory",
+        skill_md_path=skill_md,
+        mcp_command="skmemory-mcp",
+        mcp_args=[],
+        install_hooks=True,
+        environments=detected,
+    )
+
+    skill_action = result.get("skill", {}).get("action", "—")
+    print(f"  Skill: {skill_action}")
+
+    mcp = result.get("mcp", {})
+    for env_name, action in mcp.items():
+        print(f"  MCP ({env_name}): {action}")
+
+    hooks = result.get("hooks", {})
+    if hooks:
+        print(f"  Hooks: {hooks.get('action', '—')}")
+
+    print("skmemory: post-install complete.")
+
+
+def main() -> None:
+    """Entry point for skmemory-post-install console script."""
+    try:
+        run_post_install()
+    except Exception as exc:
+        # Never fail the install — registration is best-effort
+        print(f"skmemory: post-install warning: {exc}", file=sys.stderr)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/skmemory/predictive.py

@@ -25,7 +25,6 @@ import math
 import time
 from collections import Counter, defaultdict
 from pathlib import Path
-from typing import Optional
 
 from pydantic import BaseModel, Field
 
@@ -62,7 +61,7 @@ class PredictiveRecall:
 
     def __init__(
         self,
-        log_path: Optional[Path] = None,
+        log_path: Path | None = None,
         max_events: int = 5000,
     ) -> None:
         self._log_path = log_path or DEFAULT_ACCESS_LOG
@@ -100,7 +99,10 @@ class PredictiveRecall:
         current_session: list[AccessEvent] = []
 
         for event in sorted(self._events, key=lambda e: e.timestamp):
-            if current_session and (event.timestamp - current_session[-1].timestamp) > session_window:
+            if (
+                current_session
+                and (event.timestamp - current_session[-1].timestamp) > session_window
+            ):
                 sessions.append(current_session)
                 current_session = []
             current_session.append(event)
@@ -111,7 +113,7 @@ class PredictiveRecall:
             ids_in_session = [e.memory_id for e in session]
             for i, mid in enumerate(ids_in_session):
                 self._frequency[mid] += 1
-                for other in ids_in_session[i + 1:]:
+                for other in ids_in_session[i + 1 :]:
                     if other != mid:
                         self._cooccurrence[mid][other] += 1
                         self._cooccurrence[other][mid] += 1
@@ -120,7 +122,9 @@ class PredictiveRecall:
             for tag in event.tags:
                 self._tag_affinity[tag][event.memory_id] += 1
 
-    def log_access(self, memory_id: str, tags: Optional[list[str]] = None, layer: str = "", context: str = "") -> None:
+    def log_access(
+        self, memory_id: str, tags: list[str] | None = None, layer: str = "", context: str = ""
+    ) -> None:
         """Record a memory access event for pattern learning.
 
         Args:
@@ -144,15 +148,15 @@ class PredictiveRecall:
             self._tag_affinity[tag][memory_id] += 1
 
         if len(self._events) > self._max_events:
-            self._events = self._events[-self._max_events:]
+            self._events = self._events[-self._max_events :]
             self._rebuild_indices()
 
         self._save()
 
     def predict(
         self,
-        recent_ids: Optional[list[str]] = None,
-        active_tags: Optional[list[str]] = None,
+        recent_ids: list[str] | None = None,
+        active_tags: list[str] | None = None,
         limit: int = 10,
     ) -> list[dict]:
         """Predict which memories will be needed next.
@@ -228,5 +232,5 @@ class PredictiveRecall:
     def _save(self) -> None:
         """Persist the access log to disk."""
         self._log_path.parent.mkdir(parents=True, exist_ok=True)
-        data = [e.model_dump() for e in self._events[-self._max_events:]]
+        data = [e.model_dump() for e in self._events[-self._max_events :]]
         self._log_path.write_text(json.dumps(data, indent=2))