memorix 0.5.0 → 0.5.2

package/dist/index.js

@@ -28,6 +28,103 @@ var init_esm_shims = __esm({
   }
 });
 
+// src/store/persistence.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+import os from "os";
+async function getProjectDataDir(projectId, baseDir) {
+  const dataDir = baseDir ?? DEFAULT_DATA_DIR;
+  await fs.mkdir(dataDir, { recursive: true });
+  return dataDir;
+}
+function getGraphFilePath(projectDir2) {
+  return path2.join(projectDir2, "graph.jsonl");
+}
+async function saveGraphJsonl(projectDir2, entities, relations) {
+  const lines = [
+    ...entities.map(
+      (e) => JSON.stringify({ type: "entity", name: e.name, entityType: e.entityType, observations: e.observations })
+    ),
+    ...relations.map(
+      (r) => JSON.stringify({ type: "relation", from: r.from, to: r.to, relationType: r.relationType })
+    )
+  ];
+  await fs.writeFile(getGraphFilePath(projectDir2), lines.join("\n"), "utf-8");
+}
+async function loadGraphJsonl(projectDir2) {
+  const filePath = getGraphFilePath(projectDir2);
+  try {
+    const data = await fs.readFile(filePath, "utf-8");
+    const lines = data.split("\n").filter((line) => line.trim() !== "");
+    return lines.reduce(
+      (graph, line) => {
+        const item = JSON.parse(line);
+        if (item.type === "entity") {
+          graph.entities.push({
+            name: item.name,
+            entityType: item.entityType,
+            observations: item.observations
+          });
+        }
+        if (item.type === "relation") {
+          graph.relations.push({
+            from: item.from,
+            to: item.to,
+            relationType: item.relationType
+          });
+        }
+        return graph;
+      },
+      {
+        entities: [],
+        relations: []
+      }
+    );
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { entities: [], relations: [] };
+    }
+    throw error;
+  }
+}
+async function saveObservationsJson(projectDir2, observations2) {
+  const filePath = path2.join(projectDir2, "observations.json");
+  await fs.writeFile(filePath, JSON.stringify(observations2, null, 2), "utf-8");
+}
+async function loadObservationsJson(projectDir2) {
+  const filePath = path2.join(projectDir2, "observations.json");
+  try {
+    const data = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function saveIdCounter(projectDir2, nextId2) {
+  const filePath = path2.join(projectDir2, "counter.json");
+  await fs.writeFile(filePath, JSON.stringify({ nextId: nextId2 }), "utf-8");
+}
+async function loadIdCounter(projectDir2) {
+  const filePath = path2.join(projectDir2, "counter.json");
+  try {
+    const data = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(data).nextId ?? 1;
+  } catch {
+    return 1;
+  }
+}
+var DEFAULT_DATA_DIR;
+var init_persistence = __esm({
+  "src/store/persistence.ts"() {
+    "use strict";
+    init_esm_shims();
+    DEFAULT_DATA_DIR = path2.join(os.homedir(), ".memorix", "data");
+  }
+});
+
 // src/types.ts
 var OBSERVATION_ICONS;
 var init_types = __esm({
@@ -848,111 +945,212 @@ var init_retention = __esm({
   }
 });
 
-// src/index.ts
-init_esm_shims();
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// src/server.ts
-init_esm_shims();
-import { watch } from "fs";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-// src/memory/graph.ts
-init_esm_shims();
-
-// src/store/persistence.ts
-init_esm_shims();
-import { promises as fs } from "fs";
-import path2 from "path";
-import os from "os";
-var DEFAULT_DATA_DIR = path2.join(os.homedir(), ".memorix", "data");
-async function getProjectDataDir(projectId, baseDir) {
-  const dataDir = baseDir ?? DEFAULT_DATA_DIR;
-  await fs.mkdir(dataDir, { recursive: true });
-  return dataDir;
+// src/dashboard/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startDashboard: () => startDashboard
+});
+import { createServer } from "http";
+import { promises as fs4 } from "fs";
+import path6 from "path";
+import { exec } from "child_process";
+function sendJson(res, data, status = 200) {
+  res.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Access-Control-Allow-Origin": "*"
+  });
+  res.end(JSON.stringify(data));
 }
-function getGraphFilePath(projectDir2) {
-  return path2.join(projectDir2, "graph.jsonl");
+function sendError(res, message, status = 500) {
+  sendJson(res, { error: message }, status);
 }
-async function saveGraphJsonl(projectDir2, entities, relations) {
-  const lines = [
-    ...entities.map(
-      (e) => JSON.stringify({ type: "entity", name: e.name, entityType: e.entityType, observations: e.observations })
-    ),
-    ...relations.map(
-      (r) => JSON.stringify({ type: "relation", from: r.from, to: r.to, relationType: r.relationType })
-    )
-  ];
-  await fs.writeFile(getGraphFilePath(projectDir2), lines.join("\n"), "utf-8");
+function filterByProject(items, projectId) {
+  return items.filter((item) => item.projectId === projectId);
 }
-async function loadGraphJsonl(projectDir2) {
-  const filePath = getGraphFilePath(projectDir2);
+async function handleApi(req, res, dataDir, projectId, projectName) {
+  const url = new URL(req.url || "/", `http://${req.headers.host}`);
+  const apiPath = url.pathname.replace("/api", "");
   try {
-    const data = await fs.readFile(filePath, "utf-8");
-    const lines = data.split("\n").filter((line) => line.trim() !== "");
-    return lines.reduce(
-      (graph, line) => {
-        const item = JSON.parse(line);
-        if (item.type === "entity") {
-          graph.entities.push({
-            name: item.name,
-            entityType: item.entityType,
-            observations: item.observations
-          });
+    switch (apiPath) {
+      case "/project": {
+        sendJson(res, { id: projectId, name: projectName });
+        break;
+      }
+      case "/graph": {
+        const graph = await loadGraphJsonl(dataDir);
+        sendJson(res, graph);
+        break;
+      }
+      case "/observations": {
+        const allObs = await loadObservationsJson(dataDir);
+        const observations2 = filterByProject(allObs, projectId);
+        sendJson(res, observations2);
+        break;
+      }
+      case "/stats": {
+        const graph = await loadGraphJsonl(dataDir);
+        const allObs = await loadObservationsJson(dataDir);
+        const observations2 = filterByProject(allObs, projectId);
+        const nextId2 = await loadIdCounter(dataDir);
+        const typeCounts = {};
+        for (const obs of observations2) {
+          const t = obs.type || "unknown";
+          typeCounts[t] = (typeCounts[t] || 0) + 1;
         }
-        if (item.type === "relation") {
-          graph.relations.push({
-            from: item.from,
-            to: item.to,
-            relationType: item.relationType
-          });
-        }
-        return graph;
-      },
-      {
-        entities: [],
-        relations: []
+        const sorted = [...observations2].sort((a, b) => (b.id || 0) - (a.id || 0)).slice(0, 10);
+        sendJson(res, {
+          entities: graph.entities.length,
+          relations: graph.relations.length,
+          observations: observations2.length,
+          nextId: nextId2,
+          typeCounts,
+          recentObservations: sorted
+        });
+        break;
+      }
+      case "/retention": {
+        const allObs = await loadObservationsJson(dataDir);
+        const observations2 = filterByProject(allObs, projectId);
+        const now = Date.now();
+        const scored = observations2.map((obs) => {
+          const age = now - new Date(obs.createdAt || now).getTime();
+          const ageHours = age / (1e3 * 60 * 60);
+          const importance = obs.importance ?? 5;
+          const accessCount = obs.accessCount ?? 0;
+          const lambda = 0.01;
+          const decayScore = importance * Math.exp(-lambda * ageHours);
+          const accessBonus = Math.min(accessCount * 0.5, 3);
+          const score = Math.min(decayScore + accessBonus, 10);
+          const isImmune2 = importance >= 8 || obs.type === "gotcha" || obs.type === "decision";
+          return {
+            id: obs.id,
+            title: obs.title,
+            type: obs.type,
+            entityName: obs.entityName,
+            score: Math.round(score * 100) / 100,
+            isImmune: isImmune2,
+            ageHours: Math.round(ageHours * 10) / 10,
+            accessCount
+          };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        const activeCount = scored.filter((s) => s.score >= 3).length;
+        const staleCount = scored.filter((s) => s.score < 3 && s.score >= 1).length;
+        const archiveCount = scored.filter((s) => s.score < 1).length;
+        const immuneCount = scored.filter((s) => s.isImmune).length;
+        sendJson(res, {
+          summary: { active: activeCount, stale: staleCount, archive: archiveCount, immune: immuneCount },
+          items: scored
+        });
+        break;
       }
-    );
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return { entities: [], relations: [] };
+      default:
+        sendError(res, "Not found", 404);
     }
-    throw error;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    sendError(res, message);
   }
 }
-async function saveObservationsJson(projectDir2, observations2) {
-  const filePath = path2.join(projectDir2, "observations.json");
-  await fs.writeFile(filePath, JSON.stringify(observations2, null, 2), "utf-8");
-}
-async function loadObservationsJson(projectDir2) {
-  const filePath = path2.join(projectDir2, "observations.json");
+async function serveStatic(req, res, staticDir) {
+  let urlPath = new URL(req.url || "/", `http://${req.headers.host}`).pathname;
+  if (urlPath === "/" || !urlPath.includes(".")) {
+    urlPath = "/index.html";
+  }
+  const filePath = path6.join(staticDir, urlPath);
+  if (!filePath.startsWith(staticDir)) {
+    sendError(res, "Forbidden", 403);
+    return;
+  }
   try {
-    const data = await fs.readFile(filePath, "utf-8");
-    return JSON.parse(data);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return [];
+    const data = await fs4.readFile(filePath);
+    const ext = path6.extname(filePath);
+    res.writeHead(200, {
+      "Content-Type": MIME_TYPES[ext] || "application/octet-stream",
+      "Cache-Control": "no-cache"
+    });
+    res.end(data);
+  } catch {
+    try {
+      const indexData = await fs4.readFile(path6.join(staticDir, "index.html"));
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(indexData);
+    } catch {
+      sendError(res, "Not found", 404);
     }
-    throw error;
   }
 }
-async function saveIdCounter(projectDir2, nextId2) {
-  const filePath = path2.join(projectDir2, "counter.json");
-  await fs.writeFile(filePath, JSON.stringify({ nextId: nextId2 }), "utf-8");
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
 }
-async function loadIdCounter(projectDir2) {
-  const filePath = path2.join(projectDir2, "counter.json");
-  try {
-    const data = await fs.readFile(filePath, "utf-8");
-    return JSON.parse(data).nextId ?? 1;
-  } catch {
-    return 1;
-  }
+async function startDashboard(dataDir, port, staticDir, projectId, projectName, autoOpen = true) {
+  const resolvedStaticDir = staticDir;
+  const server = createServer(async (req, res) => {
+    const url = req.url || "/";
+    if (url.startsWith("/api/")) {
+      await handleApi(req, res, dataDir, projectId, projectName);
+    } else {
+      await serveStatic(req, res, resolvedStaticDir);
+    }
+  });
+  return new Promise((resolve2, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.error(`Port ${port} is already in use. Try: memorix dashboard --port ${port + 1}`);
+        reject(err);
+      } else {
+        reject(err);
+      }
+    });
+    server.listen(port, () => {
+      const url = `http://localhost:${port}`;
+      console.error(`
+  Memorix Dashboard`);
+      console.error(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+      console.error(`  Project:  ${projectName} (${projectId})`);
+      console.error(`  Local:    ${url}`);
+      console.error(`  Data dir: ${dataDir}`);
+      console.error(`
+  Press Ctrl+C to stop
+`);
+      if (autoOpen) openBrowser(url);
+      resolve2();
+    });
+  });
 }
+var MIME_TYPES;
+var init_server = __esm({
+  "src/dashboard/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_persistence();
+    MIME_TYPES = {
+      ".html": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".ico": "image/x-icon"
+    };
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+init_esm_shims();
+import { watch } from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
 
 // src/memory/graph.ts
+init_esm_shims();
+init_persistence();
 var KnowledgeGraphManager = class {
   entities = [];
   relations = [];
@@ -1075,6 +1273,7 @@ var KnowledgeGraphManager = class {
 // src/memory/observations.ts
 init_esm_shims();
 init_orama_store();
+init_persistence();
 
 // src/compact/token-budget.ts
 init_esm_shims();
@@ -1578,6 +1777,9 @@ function normalizeGitRemote(remote) {
   }
 }
 
+// src/server.ts
+init_persistence();
+
 // src/rules/syncer.ts
 init_esm_shims();
 import { promises as fs2 } from "fs";
@@ -2888,10 +3090,10 @@ var WorkspaceSyncEngine = class _WorkspaceSyncEngine {
     for (const [target, adapter] of this.adapters) {
       const configPath = adapter.getConfigPath(this.projectRoot);
       const globalPath = adapter.getConfigPath();
-      for (const path6 of [configPath, globalPath]) {
-        if (existsSync4(path6)) {
+      for (const path7 of [configPath, globalPath]) {
+        if (existsSync4(path7)) {
           try {
-            const content = readFileSync2(path6, "utf-8");
+            const content = readFileSync2(path7, "utf-8");
             const servers = adapter.parse(content);
             if (servers.length > 0) {
               mcpConfigs[target] = servers;
@@ -3792,6 +3994,85 @@ Entity: ${entityName} | Type: ${type} | Project: ${project.id}${enrichment}`
       };
     }
   );
+  let dashboardRunning = false;
+  server.registerTool(
+    "memorix_dashboard",
+    {
+      title: "Launch Dashboard",
+      description: "Launch the Memorix Web Dashboard in the browser. Shows knowledge graph, observations, retention scores, and project stats in a visual interface.",
+      inputSchema: {
+        port: z.number().optional().describe("Port to run the dashboard on (default: 3210)")
+      }
+    },
+    async ({ port: dashboardPort }) => {
+      const portNum = dashboardPort || 3210;
+      const url = `http://localhost:${portNum}`;
+      if (dashboardRunning) {
+        const { exec: exec2 } = await import("child_process");
+        const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+        exec2(cmd, () => {
+        });
+        return {
+          content: [{ type: "text", text: `Dashboard is already running at ${url}. Opened in browser.` }]
+        };
+      }
+      try {
+        const pathMod = await import("path");
+        const fsMod = await import("fs");
+        const { fileURLToPath: fileURLToPath2 } = await import("url");
+        const { startDashboard: startDashboard2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+        const candidates = [
+          pathMod.default.join(__dirname, "..", "dashboard", "static"),
+          pathMod.default.join(__dirname, "dashboard", "static"),
+          pathMod.default.join(pathMod.default.dirname(fileURLToPath2(import.meta.url)), "..", "dashboard", "static"),
+          pathMod.default.join(pathMod.default.dirname(fileURLToPath2(import.meta.url)), "dashboard", "static")
+        ];
+        for (const [i, c] of candidates.entries()) {
+          const hasIndex = fsMod.existsSync(pathMod.default.join(c, "index.html"));
+          console.error(`[memorix] candidate[${i}]: ${c} (has index.html: ${hasIndex})`);
+        }
+        let staticDir = candidates[0];
+        for (const c of candidates) {
+          if (fsMod.existsSync(pathMod.default.join(c, "index.html"))) {
+            staticDir = c;
+            break;
+          }
+        }
+        console.error(`[memorix] Dashboard staticDir: ${staticDir}`);
+        startDashboard2(projectDir2, portNum, staticDir, project.id, project.name, false).then(() => {
+          dashboardRunning = true;
+        }).catch((err) => {
+          console.error("[memorix] Dashboard error:", err);
+          dashboardRunning = false;
+        });
+        await new Promise((resolve2) => setTimeout(resolve2, 800));
+        dashboardRunning = true;
+        const { exec: execCmd } = await import("child_process");
+        const openCmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+        execCmd(openCmd, () => {
+        });
+        return {
+          content: [{
+            type: "text",
+            text: [
+              `Memorix Dashboard started!`,
+              ``,
+              `URL: ${url}`,
+              `Project: ${project.name} (${project.id})`,
+              `Static: ${staticDir}`,
+              ``,
+              `The dashboard has been opened in your default browser.`,
+              `It shows your knowledge graph, observations, retention scores, and project stats.`
+            ].join("\n")
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Failed to start dashboard: ${err instanceof Error ? err.message : String(err)}` }]
+        };
+      }
+    }
+  );
   return { server, graphManager, projectId: project.id };
 }