@shahmilsaari/memory-core 0.2.16 → 0.2.17

package/dist/dashboard-server-EVN4FL4L.js

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+import {
+  detectProject,
+  getChatProviderLabel,
+  startWatch
+} from "./chunk-T4WJR6L6.js";
+import {
+  embed
+} from "./chunk-HAGRPKR3.js";
+import {
+  closePool,
+  deleteMemory,
+  getPool,
+  listMemories,
+  saveMemory,
+  updateMemory
+} from "./chunk-WUL7HLAA.js";
+import {
+  Config
+} from "./chunk-KSLFLWB4.js";
+
+// src/dashboard-server.ts
+import { createHash } from "crypto";
+import { createReadStream, existsSync, readFileSync, watch } from "fs";
+import { createServer } from "http";
+import { extname, join, normalize, relative } from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+var clients = /* @__PURE__ */ new Set();
+var fileStatuses = /* @__PURE__ */ new Map();
+var recentEvents = [];
+var RUNTIME_ENV_KEYS = [
+  "DATABASE_URL",
+  "OLLAMA_URL",
+  "OLLAMA_MODEL",
+  "CHAT_PROVIDER",
+  "CHAT_MODEL",
+  "OLLAMA_CHAT_MODEL",
+  "CHAT_API_KEY"
+];
+function readJsonFile(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function readProjectConfig() {
+  return readJsonFile(join(process.cwd(), ".memory-core.json"), null);
+}
+function parseEnvFile(raw) {
+  const values = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const separatorIndex = trimmed.indexOf("=");
+    if (separatorIndex === -1) continue;
+    const key = trimmed.slice(0, separatorIndex).trim();
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    if (key) values[key] = value;
+  }
+  return values;
+}
+function getRuntimeEnvPath() {
+  const memoryEnv = join(process.cwd(), ".memory-core.env");
+  return existsSync(memoryEnv) ? memoryEnv : join(process.cwd(), ".env");
+}
+function reloadRuntimeEnv() {
+  const envPath = getRuntimeEnvPath();
+  for (const key of RUNTIME_ENV_KEYS) {
+    delete process.env[key];
+  }
+  if (!existsSync(envPath)) return;
+  const values = parseEnvFile(readFileSync(envPath, "utf-8"));
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== "") process.env[key] = value;
+  }
+}
+function readStats() {
+  return readJsonFile(join(process.cwd(), ".memory-core-stats.json"), { rules: {}, files: {} });
+}
+function topEntries(values = {}, limit = 8) {
+  return Object.entries(values).sort((a, b) => b[1] - a[1]).slice(0, limit).map(([name, count]) => ({ name, count }));
+}
+function redactDatabaseUrl(url) {
+  if (!url) return "(not set)";
+  return url.replace(/:\/\/([^:@/]+)(?::[^@/]+)?@/, "://$1:***@");
+}
+function parseDatabaseUrl(url) {
+  if (!url) {
+    return {
+      configured: false,
+      url: "(not set)",
+      host: "(not set)",
+      port: "",
+      database: "",
+      user: ""
+    };
+  }
+  try {
+    const parsed = new URL(url);
+    return {
+      configured: true,
+      url: redactDatabaseUrl(url),
+      host: parsed.hostname,
+      port: parsed.port,
+      database: parsed.pathname.replace(/^\//, ""),
+      user: decodeURIComponent(parsed.username)
+    };
+  } catch {
+    return {
+      configured: true,
+      url: redactDatabaseUrl(url),
+      host: "invalid URL",
+      port: "",
+      database: "",
+      user: ""
+    };
+  }
+}
+async function resolveOllamaModel(ollamaUrl, model) {
+  const res = await fetch(`${ollamaUrl}/api/tags`, { signal: AbortSignal.timeout(5e3) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const data = await res.json();
+  const models = data.models ?? [];
+  const exact = models.find((entry) => entry.name === model);
+  const prefixed = models.find((entry) => entry.name.startsWith(`${model}:`));
+  return (exact ?? prefixed)?.name ?? null;
+}
+async function getModelStatus() {
+  const provider = Config.chatProvider;
+  const checkModel = Config.chatModel;
+  const embeddingModel = Config.ollamaModel;
+  const ollamaUrl = Config.ollamaUrl;
+  const status = {
+    provider,
+    checkModel,
+    chatModel: checkModel,
+    embeddingModel,
+    ollamaUrl,
+    label: getChatProviderLabel(),
+    ollamaReachable: false,
+    checkModelInstalled: provider !== "ollama" ? void 0 : false,
+    checkModelResolved: void 0,
+    embeddingModelInstalled: false,
+    embeddingModelResolved: void 0,
+    apiKeyConfigured: provider === "ollama" ? void 0 : Boolean(Config.chatApiKey),
+    error: void 0
+  };
+  try {
+    const embedding = await resolveOllamaModel(ollamaUrl, embeddingModel);
+    status.ollamaReachable = true;
+    status.embeddingModelInstalled = Boolean(embedding);
+    status.embeddingModelResolved = embedding ?? void 0;
+    if (provider === "ollama") {
+      const chat = checkModel === embeddingModel ? embedding : await resolveOllamaModel(ollamaUrl, checkModel);
+      status.checkModelInstalled = Boolean(chat);
+      status.checkModelResolved = chat ?? void 0;
+    }
+  } catch (err) {
+    status.error = err.message;
+  }
+  return status;
+}
+async function getRuntimeStatus(config) {
+  const detected = detectProject(process.cwd());
+  const declaredArchitectures = [
+    config?.backendArchitecture,
+    config?.frontendFramework
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  const activeArchitectures = declaredArchitectures.length > 0 ? declaredArchitectures : config?.projectType === "backend" ? ["clean-architecture"] : [];
+  const database = parseDatabaseUrl(Config.databaseUrl);
+  let postgres = {
+    ...database,
+    connected: false,
+    error: database.configured ? void 0 : "DATABASE_URL is not set"
+  };
+  if (database.configured) {
+    try {
+      const result = await getPool().query(
+        "SELECT current_database() AS database, current_user AS user"
+      );
+      postgres = {
+        ...postgres,
+        connected: true,
+        error: void 0,
+        serverDatabase: result.rows[0]?.database,
+        serverUser: result.rows[0]?.user
+      };
+    } catch (err) {
+      postgres = {
+        ...postgres,
+        connected: false,
+        error: err.message
+      };
+    }
+  }
+  const model = await getModelStatus();
+  return {
+    project: {
+      name: config?.projectName ?? process.cwd().split("/").pop() ?? "project",
+      type: config?.projectType ?? "unknown",
+      language: config?.language ?? detected.language,
+      initialized: config !== null,
+      declaredArchitectures,
+      activeArchitectures,
+      detected
+    },
+    postgres,
+    model
+  };
+}
+function isRelevantMemory(memory, config, activeArchitectures) {
+  const currentProject = config?.projectName;
+  if (memory.project_name && memory.project_name !== currentProject) return false;
+  if (!["rule", "pattern", "decision", "ignore"].includes(memory.type)) return false;
+  if (memory.architecture && memory.architecture !== "global") {
+    return activeArchitectures.includes(memory.architecture);
+  }
+  const tags = new Set(memory.tags ?? []);
+  const knownArchitectureTags = /* @__PURE__ */ new Set([
+    "angular",
+    "clean-architecture",
+    "express",
+    "fastify",
+    "go-api",
+    "hexagonal",
+    "laravel-service-repository",
+    "modular-monolith",
+    "mvc",
+    "nestjs",
+    "nextjs",
+    "nuxt",
+    "react",
+    "react-native",
+    "svelte",
+    "vue"
+  ]);
+  const architectureTags = [...tags].filter((tag) => knownArchitectureTags.has(tag));
+  if (architectureTags.length === 0) return true;
+  return architectureTags.some((tag) => activeArchitectures.includes(tag));
+}
+function filterMemoriesForProject(memories, config, activeArchitectures) {
+  return memories.filter((memory) => isRelevantMemory(memory, config, activeArchitectures));
+}
+async function getSnapshot() {
+  const config = readProjectConfig();
+  const runtime = await getRuntimeStatus(config);
+  let memories = [];
+  let dbError;
+  try {
+    memories = await listMemories({ limit: 1e4 });
+  } catch (err) {
+    dbError = err.message;
+  }
+  const relevantMemories = filterMemoriesForProject(memories, config, runtime.project.activeArchitectures);
+  const stats = readStats();
+  return {
+    config,
+    runtime,
+    stats: {
+      rules: stats.rules ?? {},
+      files: stats.files ?? {},
+      topRules: topEntries(stats.rules),
+      topFiles: topEntries(stats.files)
+    },
+    files: Array.from(fileStatuses.values()).sort((a, b) => b.lastSeen.localeCompare(a.lastSeen)),
+    events: recentEvents,
+    memories: relevantMemories,
+    memoryCount: {
+      total: memories.length,
+      relevant: relevantMemories.length
+    },
+    dbError
+  };
+}
+function sendJson(res, status, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(status, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf-8"));
+}
+function parseTags(value) {
+  if (Array.isArray(value)) {
+    return value.map(String).map((tag) => tag.trim()).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    return value.split(",").map((tag) => tag.trim()).filter(Boolean);
+  }
+  return [];
+}
+async function handleApi(req, res, url) {
+  try {
+    if (req.method === "GET" && url.pathname === "/api/snapshot") {
+      sendJson(res, 200, await getSnapshot());
+      return;
+    }
+    if (req.method === "POST" && url.pathname === "/api/memories") {
+      const body = await readBody(req);
+      const content = typeof body.content === "string" ? body.content.trim() : "";
+      if (!content) {
+        sendJson(res, 400, { error: "content is required" });
+        return;
+      }
+      const config = readProjectConfig();
+      await saveMemory({
+        type: typeof body.type === "string" ? body.type : "rule",
+        scope: typeof body.scope === "string" ? body.scope : "project",
+        architecture: typeof config?.backendArchitecture === "string" ? config.backendArchitecture : typeof config?.frontendFramework === "string" ? config.frontendFramework : void 0,
+        projectName: typeof config?.projectName === "string" ? config.projectName : void 0,
+        title: typeof body.title === "string" ? body.title : void 0,
+        content,
+        reason: typeof body.reason === "string" && body.reason.trim() ? body.reason.trim() : void 0,
+        context: {},
+        tags: parseTags(body.tags),
+        embedding: await embed(content)
+      });
+      await broadcastSnapshot();
+      sendJson(res, 201, { ok: true });
+      return;
+    }
+    const memoryMatch = url.pathname.match(/^\/api\/memories\/(\d+)$/);
+    if (memoryMatch && req.method === "PATCH") {
+      const id = Number(memoryMatch[1]);
+      const body = await readBody(req);
+      const content = typeof body.content === "string" ? body.content.trim() : void 0;
+      const updated = await updateMemory(id, {
+        type: typeof body.type === "string" ? body.type : void 0,
+        scope: typeof body.scope === "string" ? body.scope : void 0,
+        title: typeof body.title === "string" ? body.title : void 0,
+        content,
+        reason: typeof body.reason === "string" && body.reason.trim() ? body.reason.trim() : void 0,
+        tags: parseTags(body.tags),
+        embedding: content ? await embed(content) : void 0
+      });
+      if (!updated) {
+        sendJson(res, 404, { error: `No memory found with ID ${id}` });
+        return;
+      }
+      await broadcastSnapshot();
+      sendJson(res, 200, updated);
+      return;
+    }
+    if (memoryMatch && req.method === "DELETE") {
+      const id = Number(memoryMatch[1]);
+      const deleted = await deleteMemory(id);
+      if (!deleted) {
+        sendJson(res, 404, { error: `No memory found with ID ${id}` });
+        return;
+      }
+      await broadcastSnapshot();
+      sendJson(res, 200, { ok: true });
+      return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+  } catch (err) {
+    sendJson(res, 500, { error: err.message });
+  }
+}
+function contentType(path) {
+  switch (extname(path)) {
+    case ".html":
+      return "text/html; charset=utf-8";
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".svg":
+      return "image/svg+xml";
+    case ".json":
+      return "application/json; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}
+function serveStatic(req, res, url) {
+  const dashboardDir = join(fileURLToPath(new URL(".", import.meta.url)), "dashboard");
+  const requested = url.pathname === "/" ? "/index.html" : url.pathname;
+  const filePath = normalize(join(dashboardDir, requested));
+  if (!filePath.startsWith(dashboardDir) || relative(dashboardDir, filePath).startsWith("..")) {
+    res.writeHead(403);
+    res.end("Forbidden");
+    return;
+  }
+  if (!existsSync(filePath)) {
+    if (!existsSync(join(dashboardDir, "index.html"))) {
+      res.writeHead(503, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Dashboard assets are missing. Run `npm run build` before `memory-core dashboard`.");
+      return;
+    }
+    createReadStream(join(dashboardDir, "index.html")).pipe(res.writeHead(200, { "content-type": contentType("index.html") }));
+    return;
+  }
+  createReadStream(filePath).pipe(res.writeHead(200, { "content-type": contentType(filePath) }));
+}
+function encodeFrame(payload) {
+  const body = Buffer.from(payload);
+  if (body.length <= 125) {
+    return Buffer.concat([Buffer.from([129, body.length]), body]);
+  }
+  if (body.length <= 65535) {
+    const header2 = Buffer.alloc(4);
+    header2[0] = 129;
+    header2[1] = 126;
+    header2.writeUInt16BE(body.length, 2);
+    return Buffer.concat([header2, body]);
+  }
+  const header = Buffer.alloc(10);
+  header[0] = 129;
+  header[1] = 127;
+  header.writeBigUInt64BE(BigInt(body.length), 2);
+  return Buffer.concat([header, body]);
+}
+function sendWs(socket, payload) {
+  if (socket.destroyed) return;
+  socket.write(encodeFrame(JSON.stringify(payload)));
+}
+function broadcast(payload) {
+  for (const client of clients) sendWs(client, payload);
+}
+async function broadcastSnapshot() {
+  broadcast({ type: "snapshot", timestamp: (/* @__PURE__ */ new Date()).toISOString(), snapshot: await getSnapshot() });
+}
+function handleWatchEvent(event) {
+  recentEvents.push(event);
+  if (recentEvents.length > 100) recentEvents.shift();
+  if (event.type === "saved") {
+    fileStatuses.set(event.file, {
+      file: event.file,
+      status: "checking",
+      lastSeen: event.timestamp,
+      violations: []
+    });
+  }
+  if (event.type === "clean") {
+    fileStatuses.set(event.file, {
+      file: event.file,
+      status: "clean",
+      lastSeen: event.timestamp,
+      violations: []
+    });
+  }
+  if (event.type === "violations") {
+    fileStatuses.set(event.file, {
+      file: event.file,
+      status: "violations",
+      lastSeen: event.timestamp,
+      violations: event.violations
+    });
+  }
+  broadcast({ type: "watch", event });
+  void broadcastSnapshot();
+}
+function acceptWebSocket(req, socket) {
+  const key = req.headers["sec-websocket-key"];
+  if (typeof key !== "string") {
+    socket.destroy();
+    return;
+  }
+  const accept = createHash("sha1").update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest("base64");
+  socket.write([
+    "HTTP/1.1 101 Switching Protocols",
+    "Upgrade: websocket",
+    "Connection: Upgrade",
+    `Sec-WebSocket-Accept: ${accept}`,
+    "",
+    ""
+  ].join("\r\n"));
+  clients.add(socket);
+  socket.on("close", () => clients.delete(socket));
+  socket.on("error", () => clients.delete(socket));
+  sendWs(socket, { type: "connected", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  void broadcastSnapshot();
+}
+function startConfigWatch() {
+  let timer;
+  const watchedFiles = [".env", ".memory-core.env", ".memory-core.json", ".memory-core-stats.json"];
+  const watchers = watchedFiles.map((file) => join(process.cwd(), file)).filter((filePath) => existsSync(filePath)).map((filePath) => watch(filePath, () => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      reloadRuntimeEnv();
+      recentEvents.push({
+        type: "error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Configuration reloaded from ${filePath.split("/").pop()}`
+      });
+      if (recentEvents.length > 100) recentEvents.shift();
+      void broadcastSnapshot();
+    }, 150);
+  }));
+  return () => {
+    if (timer) clearTimeout(timer);
+    for (const watcher of watchers) watcher.close();
+  };
+}
+async function startDashboard(options = {}) {
+  reloadRuntimeEnv();
+  const port = options.port ?? 5178;
+  const stopConfigWatch = startConfigWatch();
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname.startsWith("/api/")) {
+      void handleApi(req, res, url);
+      return;
+    }
+    serveStatic(req, res, url);
+  });
+  server.on("upgrade", (req, socket) => {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    if (url.pathname !== "/ws") {
+      socket.destroy();
+      return;
+    }
+    acceptWebSocket(req, socket);
+  });
+  server.on("close", () => {
+    stopConfigWatch();
+    void closePool();
+  });
+  await new Promise((resolve) => {
+    server.listen(port, resolve);
+  });
+  console.log(chalk.green(`
+  Dashboard: http://localhost:${port}
+`));
+  if (options.watch ?? true) {
+    void startWatch({
+      path: options.path,
+      onEvent: handleWatchEvent,
+      exitOnSetupFailure: false
+    });
+  }
+}
+export {
+  startDashboard
+};

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@shahmilsaari/memory-core",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "description": "Universal AI memory core — generate AI context files from architecture profiles with RAG support",
+  "homepage": "https://memory-core.shahmilsaari.my/",
   "type": "module",
   "bin": {
     "memory-core": "dist/cli.js"
@@ -12,7 +13,13 @@
     "profiles"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && vite build --config dashboard/vite.config.ts",
+    "docs:start": "npm run site:start",
+    "docs:build": "node scripts/build-static-docs.mjs",
+    "docs:serve": "npm run site:serve",
+    "site:build": "npm run docs:build && node scripts/assemble-static-site.mjs",
+    "site:serve": "node scripts/serve-static-site.mjs --dir site-build --host 127.0.0.1 --port 3010",
+    "site:start": "npm run site:build && npm run site:serve",
     "typecheck": "tsc --noEmit",
     "lint": "node scripts/lint.mjs",
     "smoke:pack": "node scripts/pack-smoke.mjs",
@@ -33,12 +40,15 @@
     "pg": "^8.11.0"
   },
   "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^4.0.4",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.0.0",
     "@types/pg": "^8.11.0",
+    "svelte": "^5.55.5",
     "tsup": "^8.0.0",
     "tsx": "^4.7.0",
-    "typescript": "^5.4.0"
+    "typescript": "^5.4.0",
+    "vite": "^5.4.21"
   },
   "engines": {
     "node": ">=18.0.0"