deja-cli 0.1.0__py3-none-any.whl

deja/interfaces/mcp_server.py

@@ -0,0 +1,96 @@
+"""MCP server for deja — thin wrappers over core. No business logic here."""
+from __future__ import annotations
+
+import json
+from typing import Optional
+
+from mcp.server.fastmcp import FastMCP
+
+from deja.config import load_config
+from deja.core.store import MemoryStore
+from deja.interfaces.cli import _format_load_result
+from deja.llm.factory import create_embedding_adapter
+
+mcp = FastMCP("deja")
+
+_store: Optional[MemoryStore] = None
+
+
+async def _get_store() -> MemoryStore:
+    global _store
+    if _store is None:
+        _store = MemoryStore(load_config())
+        await _store.init_db()
+    return _store
+
+
+@mcp.tool()
+async def memory_load(project: Optional[str] = None, context: Optional[str] = None) -> str:
+    """Load memories at session start. Returns type-budgeted memories as compact text
+    (top-5 per type for gotcha/decision/preference/pattern, top-3 procedures by reuse,
+    top-3 recent progress). Call this at the beginning of every session.
+
+    context: task description to re-rank memories by relevance instead of raw confidence.
+    Always pass a short summary of what the user wants to work on — e.g. "fix auth bug in
+    login flow" or "add dark mode to dashboard". Without context, memories are sorted by
+    raw confidence and the most relevant ones may not surface.
+    """
+    store = await _get_store()
+    config = load_config()
+    embedding_adapter = await create_embedding_adapter(config) if context else None
+    result = await store.load_budgeted(project, context=context, embedding_adapter=embedding_adapter)
+    return _format_load_result(result)
+
+
+@mcp.tool()
+async def memory_save(
+    content: str,
+    type: str,
+    project: Optional[str] = None,
+    confidence: float = 1.0,
+    category: str = "agent",
+    domain: Optional[str] = None,
+) -> str:
+    """Save a memory to the vault. Deduplicates automatically — if a near-identical
+    memory already exists, its confidence is bumped instead of inserting a duplicate.
+
+    type: preference | pattern | decision | gotcha | progress | procedure
+    category: user (preferences/habits) | agent (operational knowledge)
+    domain: debug | build | test | deploy | research (optional, for procedure type)
+    """
+    store = await _get_store()
+    mem_id = await store.save(
+        {
+            "content": content,
+            "type": type,
+            "project": project,
+            "scope": f"project:{project}" if project else "global",
+            "confidence": confidence,
+            "category": category,
+            "domain": domain,
+            "source": "mcp",
+        }
+    )
+    return json.dumps({"id": mem_id, "status": "saved"})
+
+
+@mcp.tool()
+async def memory_search(
+    query: str,
+    project: Optional[str] = None,
+    type: Optional[str] = None,
+    limit: int = 10,
+) -> str:
+    """Full-text search over active memories. Use when looking for specific knowledge
+    mid-session. With project: searches global + that project. Without: all scopes."""
+    store = await _get_store()
+    results = await store.search(query, project, mem_type=type, limit=limit)
+    return json.dumps(results, default=str)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

deja/interfaces/web.py

@@ -0,0 +1,104 @@
+"""Web viewer backend for the deja memory vault.
+
+Serves a single-page HTML UI and a minimal JSON API.
+Started by `deja viewer`; not imported elsewhere.
+"""
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import HTMLResponse
+
+from deja.config import load_config
+from deja.core.store import MemoryStore
+
+_store: Optional[MemoryStore] = None
+_HTML = Path(__file__).parent / "web_ui" / "index.html"
+
+
+def _get_store() -> MemoryStore:
+    assert _store is not None, "Store not initialised"
+    return _store
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global _store
+    config = load_config()
+    _store = MemoryStore(config)
+    await _store.init_db()
+    yield
+    await _store.close()
+
+
+app = FastAPI(title="deja vault", lifespan=lifespan)
+
+
+# ── UI ────────────────────────────────────────────────────────────────────────
+
+@app.get("/", response_class=HTMLResponse, include_in_schema=False)
+async def root():
+    return _HTML.read_text(encoding="utf-8")
+
+
+# ── API ───────────────────────────────────────────────────────────────────────
+
+@app.get("/api/memories")
+async def list_memories(
+    project: Optional[str] = Query(None),
+    type: Optional[str] = Query(None),
+    status: str = Query("active"),
+    limit: int = Query(300, ge=1, le=2000),
+    offset: int = Query(0, ge=0),
+):
+    memories, total = await _get_store().list_filtered(
+        project=project, mem_type=type, status=status, limit=limit, offset=offset
+    )
+    return {"memories": memories, "total": total}
+
+
+@app.get("/api/memories/{memory_id}")
+async def get_memory(memory_id: str):
+    mem = await _get_store().get(memory_id)
+    if not mem:
+        raise HTTPException(404, "Memory not found")
+    return mem
+
+
+@app.get("/api/projects")
+async def list_projects():
+    projects = await _get_store().list_projects()
+    return {"projects": projects}
+
+
+@app.get("/api/stats")
+async def get_stats(project: Optional[str] = Query(None)):
+    return await _get_store().get_stats(project)
+
+
+@app.get("/api/search")
+async def search_memories(
+    q: str = Query(..., min_length=1),
+    project: Optional[str] = Query(None),
+    type: Optional[str] = Query(None),
+    limit: int = Query(50, ge=1, le=200),
+):
+    memories = await _get_store().search(
+        q, project=project, mem_type=type, limit=limit, track_usage=False
+    )
+    return {"memories": memories, "query": q}
+
+
+@app.post("/api/memories/{memory_id}/archive")
+async def archive_memory(memory_id: str):
+    await _get_store().archive(memory_id)
+    return {"ok": True}
+
+
+@app.post("/api/memories/{memory_id}/invalidate")
+async def invalidate_memory(memory_id: str):
+    await _get_store().invalidate(memory_id)
+    return {"ok": True}