memorix 0.5.0 → 0.5.1

package/dist/cli/index.js

@@ -2631,10 +2631,10 @@ var init_engine2 = __esm({
         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 path8 of [configPath, globalPath]) {
+            if (existsSync4(path8)) {
               try {
-                const content = readFileSync2(path6, "utf-8");
+                const content = readFileSync2(path8, "utf-8");
                 const servers = adapter.parse(content);
                 if (servers.length > 0) {
                   mcpConfigs[target] = servers;
@@ -3376,9 +3376,202 @@ var init_retention = __esm({
   }
 });
 
-// src/server.ts
+// 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 sendError(res, message, status = 500) {
+  sendJson(res, { error: message }, status);
+}
+function filterByProject(items, projectId) {
+  return items.filter((item) => item.projectId === projectId);
+}
+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 {
+    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;
+        }
+        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;
+      }
+      default:
+        sendError(res, "Not found", 404);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    sendError(res, message);
+  }
+}
+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 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);
+    }
+  }
+}
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
+}
+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/server.ts
+var server_exports2 = {};
+__export(server_exports2, {
   createMemorixServer: () => createMemorixServer
 });
 import { watch } from "fs";
@@ -3996,10 +4189,89 @@ 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: fileURLToPath3 } = 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(fileURLToPath3(import.meta.url)), "..", "dashboard", "static"),
+          pathMod.default.join(pathMod.default.dirname(fileURLToPath3(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 };
 }
 var OBSERVATION_TYPES;
-var init_server = __esm({
+var init_server2 = __esm({
   "src/server.ts"() {
     "use strict";
     init_esm_shims();
@@ -4052,7 +4324,7 @@ var init_serve = __esm({
       },
       run: async ({ args }) => {
         const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-        const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+        const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
         const projectRoot = args.cwd || process.cwd();
         const { server, projectId } = await createMemorixServer2(projectRoot);
         const transport = new StdioServerTransport();
@@ -4164,8 +4436,8 @@ var init_sync = __esm({
       run: async ({ args }) => {
         const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { RulesSyncer: RulesSyncer2 } = await Promise.resolve().then(() => (init_syncer(), syncer_exports));
-        const { promises: fs4 } = await import("fs");
-        const path6 = await import("path");
+        const { promises: fs5 } = await import("fs");
+        const path8 = await import("path");
         p2.intro("memorix sync");
         const project = detectProject2();
         p2.log.info(`Project: ${project.name} (${project.id})`);
@@ -4233,9 +4505,9 @@ var init_sync = __esm({
           process.exit(0);
         }
         for (const file of files) {
-          const fullPath = path6.join(project.rootPath, file.filePath);
-          await fs4.mkdir(path6.dirname(fullPath), { recursive: true });
-          await fs4.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = path8.join(project.rootPath, file.filePath);
+          await fs5.mkdir(path8.dirname(fullPath), { recursive: true });
+          await fs5.writeFile(fullPath, file.content, "utf-8");
           p2.log.success(`Written: ${file.filePath}`);
         }
         p2.outro(`Synced ${files.length} rule(s) to ${target} format`);
@@ -4960,10 +5232,52 @@ var init_hooks = __esm({
   }
 });
 
+// src/cli/commands/dashboard.ts
+var dashboard_exports = {};
+__export(dashboard_exports, {
+  default: () => dashboard_default
+});
+import { defineCommand as defineCommand9 } from "citty";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import path7 from "path";
+var dashboard_default;
+var init_dashboard = __esm({
+  "src/cli/commands/dashboard.ts"() {
+    "use strict";
+    init_esm_shims();
+    dashboard_default = defineCommand9({
+      meta: {
+        name: "dashboard",
+        description: "Launch the Memorix Web Dashboard"
+      },
+      args: {
+        port: {
+          type: "string",
+          description: "Port to run the dashboard on (default: 3210)",
+          default: "3210"
+        }
+      },
+      run: async ({ args }) => {
+        const { detectProject: detectProject2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
+        const { getProjectDataDir: getProjectDataDir2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+        const { startDashboard: startDashboard2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+        const project = detectProject2();
+        const dataDir = await getProjectDataDir2(project.id);
+        const port = parseInt(args.port, 10) || 3210;
+        const cliDir = path7.dirname(fileURLToPath2(import.meta.url));
+        const staticDir = path7.join(cliDir, "..", "dashboard", "static");
+        await startDashboard2(dataDir, port, staticDir, project.id, project.name);
+        await new Promise(() => {
+        });
+      }
+    });
+  }
+});
+
 // src/cli/index.ts
 init_esm_shims();
-import { defineCommand as defineCommand9, runMain } from "citty";
-var main = defineCommand9({
+import { defineCommand as defineCommand10, runMain } from "citty";
+var main = defineCommand10({
   meta: {
     name: "memorix",
     version: "0.3.9",
@@ -4974,7 +5288,8 @@ var main = defineCommand9({
     status: () => Promise.resolve().then(() => (init_status(), status_exports)).then((m) => m.default),
     sync: () => Promise.resolve().then(() => (init_sync(), sync_exports)).then((m) => m.default),
     hook: () => Promise.resolve().then(() => (init_hook(), hook_exports)).then((m) => m.default),
-    hooks: () => Promise.resolve().then(() => (init_hooks(), hooks_exports)).then((m) => m.default)
+    hooks: () => Promise.resolve().then(() => (init_hooks(), hooks_exports)).then((m) => m.default),
+    dashboard: () => Promise.resolve().then(() => (init_dashboard(), dashboard_exports)).then((m) => m.default)
   },
   run() {
   }