kyp-mem 0.4.3 → 0.5.0

package/kyp_mem/ui.py

@@ -1,5 +1,6 @@
 """KYP-MEM web UI — interactive interface for browsing the vault."""
 
+import json
 import webbrowser
 from datetime import datetime
 from pathlib import Path
@@ -28,6 +29,29 @@ def create_app(vault_path: str = None) -> FastAPI:
     def stats():
         return JSONResponse(vault.get_stats())
 
+    @app.get("/api/graph")
+    def graph():
+        nodes = []
+        edges = []
+        seen_edges = set()
+        for path, note in vault.index.notes.items():
+            kind = "session" if "/Sessions/" in path else "note"
+            nodes.append({"id": path, "title": note.title, "kind": kind, "tags": note.tags})
+            for link in (note.links or []):
+                target = None
+                link_lower = link.lower()
+                for p in vault.index.notes:
+                    stem = p.split("/")[-1].replace(".md", "").lower()
+                    if stem == link_lower:
+                        target = p
+                        break
+                if target and target != path:
+                    key = tuple(sorted([path, target]))
+                    if key not in seen_edges:
+                        seen_edges.add(key)
+                        edges.append({"source": path, "target": target})
+        return JSONResponse({"nodes": nodes, "edges": edges})
+
     @app.get("/api/note/{path:path}")
     def read_note(path: str):
         note = vault.read(path)
@@ -177,12 +201,22 @@ def create_app(vault_path: str = None) -> FastAPI:
                 continue
             if proj not in sessions:
                 sessions[proj] = []
+            summary = ""
+            lines = (note.content or "").split("\n")
+            for i, line in enumerate(lines):
+                if line.strip() == "## Summary":
+                    for j in range(i + 1, len(lines)):
+                        if lines[j].strip() and not lines[j].startswith("#"):
+                            summary = lines[j].strip()
+                            break
+                    break
             sessions[proj].append({
                 "path": path,
                 "title": note.title,
                 "tags": note.tags,
                 "created": note.created,
                 "updated": note.updated,
+                "summary": summary,
             })
         for proj in sessions:
             sessions[proj].sort(key=lambda s: s["path"], reverse=True)
@@ -230,6 +264,62 @@ def create_app(vault_path: str = None) -> FastAPI:
         vault.write_note(path, content, tags, {})
         return JSONResponse({"ok": True, "path": path})
 
+    @app.get("/api/token-economics")
+    def token_economics(project: str = ""):
+        from .config import STATS_FILE
+        try:
+            raw = json.loads(STATS_FILE.read_text()) if STATS_FILE.exists() else {}
+        except (json.JSONDecodeError, OSError):
+            raw = {}
+
+        sessions = raw.get("sessions", [])
+        injections = raw.get("injections", [])
+
+        if project:
+            sessions = [s for s in sessions if s.get("project") == project]
+            injections = [i for i in injections if i.get("project") == project]
+
+        total_exploration = sum(s.get("exploration_tokens", 0) for s in sessions)
+        total_files_read = sum(s.get("files_read", 0) for s in sessions)
+        total_commands = sum(s.get("commands_run", 0) for s in sessions)
+        total_files_read_chars = sum(s.get("files_read_chars", 0) for s in sessions)
+        total_commands_chars = sum(s.get("commands_chars", 0) for s in sessions)
+
+        avg_injection_tokens = 0
+        latest_injection_tokens = 0
+        if injections:
+            avg_injection_tokens = sum(i.get("tokens", 0) for i in injections) // len(injections)
+            latest_injection_tokens = injections[-1].get("tokens", 0)
+
+        # Avg exploration per session = what a cold start costs
+        avg_exploration = total_exploration // len(sessions) if sessions else 0
+
+        # Compression ratio: how much memory compresses one session's worth
+        # of exploration into an injection. Lower = better compression.
+        # e.g. 10x means injection is 10x smaller than avg session exploration
+        compression_ratio = round(avg_exploration / latest_injection_tokens, 1) if latest_injection_tokens > 0 and avg_exploration > 0 else 0
+
+        # Per-session savings: injection replaces one cold-start exploration
+        per_session_savings_pct = 0
+        if avg_exploration > 0 and latest_injection_tokens > 0:
+            per_session_savings_pct = round((1 - latest_injection_tokens / avg_exploration) * 100, 1)
+
+        return JSONResponse({
+            "session_count": len(sessions),
+            "total_exploration_tokens": total_exploration,
+            "avg_exploration_per_session": avg_exploration,
+            "total_files_read": total_files_read,
+            "total_files_read_chars": total_files_read_chars,
+            "total_commands": total_commands,
+            "total_commands_chars": total_commands_chars,
+            "injection_count": len(injections),
+            "avg_injection_tokens": avg_injection_tokens,
+            "latest_injection_tokens": latest_injection_tokens,
+            "compression_ratio": compression_ratio,
+            "per_session_savings_pct": max(per_session_savings_pct, 0),
+            "sessions": sessions[-20:],
+        })
+
     @app.post("/api/reload")
     def reload():
         vault._load_all()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyp-mem",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "Know Your Project — Persistent & Session level knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI.",
   "bin": {
     "kyp-mem": "bin/cli.mjs"

package/pyproject.toml

@@ -31,6 +31,7 @@ dependencies = [
     "fastapi>=0.100.0",
     "uvicorn>=0.20.0",
     "chromadb>=0.4.0",
+    "anthropic>=0.40.0",
 ]
 
 [project.urls]