kyp-mem 0.3.0 → 0.4.1

package/kyp_mem/ui.py

@@ -1,6 +1,7 @@
 """KYP-MEM web UI — interactive interface for browsing the vault."""
 
 import webbrowser
+from datetime import datetime
 from pathlib import Path
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse
@@ -119,6 +120,116 @@ def create_app(vault_path: str = None) -> FastAPI:
         vault.write_note(path, content, tags, props)
         return JSONResponse({"ok": True, "path": path})
 
+    @app.post("/api/sessions/create")
+    async def create_session(request: Request):
+        body = await request.json()
+        project = body.get("project", "").strip()
+        summary = body.get("summary", "").strip()
+        if not project:
+            return JSONResponse({"error": "Project name required"}, 400)
+        session_id = datetime.now().strftime("%Y-%m-%d_%H%M%S")
+        content = (
+            f"# Session {session_id}\n\n"
+            f"**Project:** {project}\n\n"
+            f"## Summary\n{summary}\n\n"
+            f"## INVESTIGATED\n\n\n"
+            f"## LEARNED\n\n\n"
+            f"## COMPLETED\n\n\n"
+            f"## NEXT STEPS\n\n"
+        )
+        tags = ["session", "manual", project.lower().replace(" ", "-")]
+        path = f"{project}/Sessions/{session_id}.md"
+        vault.write_note(path, content, tags, {})
+        return JSONResponse({"ok": True, "path": path})
+
+    @app.get("/api/sessions/search")
+    def search_sessions(q: str = "", project: str = ""):
+        from .vector import get_session_memory
+        mem = get_session_memory()
+        if not mem or not q:
+            return JSONResponse([])
+        results = mem.search_sessions(q, project=project or None, n_results=10)
+        if not results or not results.get("ids") or not results["ids"][0]:
+            return JSONResponse([])
+        items = []
+        for i, path in enumerate(results["ids"][0]):
+            doc = results["documents"][0][i]
+            dist = results["distances"][0][i]
+            note = vault.index.notes.get(path)
+            items.append({
+                "path": path,
+                "title": note.title if note else path,
+                "distance": dist,
+                "snippet": doc[:300],
+            })
+        return JSONResponse(items)
+
+    @app.get("/api/sessions")
+    def list_sessions(project: str = ""):
+        sessions = {}
+        for path, note in vault.index.notes.items():
+            if "/Sessions/" not in path and not path.startswith("Sessions/"):
+                continue
+            parts = path.split("/")
+            idx = parts.index("Sessions") if "Sessions" in parts else -1
+            proj = "/".join(parts[:idx]) if idx > 0 else "(root)"
+            if project and proj.lower() != project.lower():
+                continue
+            if proj not in sessions:
+                sessions[proj] = []
+            sessions[proj].append({
+                "path": path,
+                "title": note.title,
+                "tags": note.tags,
+                "created": note.created,
+                "updated": note.updated,
+            })
+        for proj in sessions:
+            sessions[proj].sort(key=lambda s: s["path"], reverse=True)
+        return JSONResponse(sessions)
+
+    @app.get("/api/projects")
+    def list_projects():
+        projects = set()
+        for path in vault.index.notes:
+            parts = path.split("/")
+            if len(parts) > 1:
+                projects.add(parts[0])
+        result = []
+        for proj in sorted(projects):
+            session_count = sum(1 for p in vault.index.notes if p.startswith(f"{proj}/Sessions/"))
+            result.append({"name": proj, "session_count": session_count})
+        return JSONResponse(result)
+
+    @app.delete("/api/note/{path:path}")
+    def delete_note(path: str):
+        if vault.delete(path):
+            return JSONResponse({"ok": True})
+        return JSONResponse({"error": "Not found"}, 404)
+
+    @app.post("/api/projects/create")
+    async def create_project(request: Request):
+        body = await request.json()
+        name = body.get("name", "").strip()
+        overview = body.get("overview", "").strip()
+        if not name:
+            return JSONResponse({"error": "Project name required"}, 400)
+        path = f"{name}/Knowledge.md"
+        if vault.read(path):
+            return JSONResponse({"error": "Project already exists"}, 409)
+        content = (
+            f"# {name}\n\n"
+            f"## Overview\n{overview or '(Project description, goals, tech stack)'}\n\n"
+            f"## Architecture\n(System design, key components, data flow)\n\n"
+            f"## Bugs\n### Known\n\n### Fixed\n\n\n"
+            f"## Improvements\n### Planned\n\n### Completed\n\n\n"
+            f"## Key Decisions\n(Important architectural or design decisions)\n\n"
+            f"## Notes\n(Miscellaneous project knowledge)\n"
+        )
+        tags = ["project", "knowledge", name.lower().replace(" ", "-")]
+        vault.write_note(path, content, tags, {})
+        return JSONResponse({"ok": True, "path": path})
+
     @app.post("/api/reload")
     def reload():
         vault._load_all()

package/kyp_mem/vault.py

@@ -200,12 +200,23 @@ class Index:
         return results[:15]
 
 
+from .vector import init_vector_db, get_session_memory
+
 class Vault:
     def __init__(self, vault_path: str):
         self.root = Path(vault_path).expanduser().resolve()
         self.root.mkdir(parents=True, exist_ok=True)
         self.index = Index()
+        init_vector_db(str(self.root))
         self._load_all()
+        self._sync_vector_db()
+
+    def _sync_vector_db(self):
+        mem = get_session_memory()
+        for path, note in self.index.notes.items():
+            if "/Sessions/" in path or path.startswith("Sessions/"):
+                folder = note.folder
+                mem.upsert_session(path, folder, note.content)
 
     def _load_all(self):
         notes = {}
@@ -250,6 +261,8 @@ class Vault:
 
         full.write_text(serialize_note(note), encoding="utf-8")
         self._load_all()
+        if "/Sessions/" in path or path.startswith("Sessions/"):
+            get_session_memory().upsert_session(path, note.folder, note.content)
 
     def delete(self, path: str) -> bool:
         full = self.root / path
@@ -261,6 +274,8 @@ class Vault:
                 parent.rmdir()
                 parent = parent.parent
             self._load_all()
+            if "/Sessions/" in path or path.startswith("Sessions/"):
+                get_session_memory().delete_session(path)
             return True
         return False
 

package/kyp_mem/vector.py

@@ -0,0 +1,43 @@
+import chromadb
+from pathlib import Path
+
+class SessionMemory:
+    def __init__(self, vault_path: str):
+        self.db_path = Path(vault_path).parent / "chroma"
+        self.db_path.mkdir(parents=True, exist_ok=True)
+        self.client = chromadb.PersistentClient(path=str(self.db_path))
+        self.collection = self.client.get_or_create_collection(name="sessions")
+
+    def upsert_session(self, path: str, project: str, content: str):
+        self.collection.upsert(
+            documents=[content],
+            metadatas=[{"project": project}],
+            ids=[path]
+        )
+
+    def delete_session(self, path: str):
+        try:
+            self.collection.delete(ids=[path])
+        except Exception:
+            pass
+
+    def search_sessions(self, query: str, project: str = None, n_results: int = 5):
+        where = {"project": project} if project else None
+        try:
+            results = self.collection.query(
+                query_texts=[query],
+                n_results=n_results,
+                where=where
+            )
+            return results
+        except Exception:
+            return {"ids": [], "documents": [], "metadatas": [], "distances": []}
+
+session_memory = None
+
+def init_vector_db(vault_path: str):
+    global session_memory
+    session_memory = SessionMemory(vault_path)
+
+def get_session_memory():
+    return session_memory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kyp-mem",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Know Your Project — Persistent 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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kyp-mem"
-version = "0.3.0"
+version = "0.4.1"
 description = "Know Your Project — Persistent knowledge base for AI agents. MCP-powered with wikilinks, backlinks, auto-learning, and neon web UI."
 readme = "README.md"
 license = {text = "MIT"}
@@ -30,6 +30,7 @@ dependencies = [
     "pyyaml>=6.0",
     "fastapi>=0.100.0",
     "uvicorn>=0.20.0",
+    "chromadb>=0.4.0",
 ]
 
 [project.urls]