@vheins/local-memory-mcp 0.5.32 → 0.6.0

package/dist/dashboard/server.js

@@ -1,486 +1,825 @@
 #!/usr/bin/env node
+import {
+  MCP_PROTOCOL_VERSION,
+  PROMPTS,
+  SQLiteStore,
+  TOOL_DEFINITIONS,
+  listResources,
+  logger
+} from "../chunk-XIJO63UU.js";
+
+// src/dashboard/server.ts
 import express from "express";
+import path3 from "path";
+import fs2 from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/mcp/client.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
 import path from "path";
-import fs from "fs";
 import { fileURLToPath } from "url";
-import { randomUUID } from "crypto";
-import { MCPClient } from "../mcp/client.js";
-import { SQLiteStore } from "../mcp/storage/sqlite.js";
-import { logger } from "../mcp/utils/logger.js";
-import { TOOL_DEFINITIONS } from "../mcp/tools/schemas.js";
-import { PROMPTS } from "../mcp/prompts/registry.js";
-import { listResources } from "../mcp/resources/index.js";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-let pkg = { version: "0.0.0" };
-try {
-    const pkgPath = path.join(__dirname, "../../package.json");
-    if (fs.existsSync(pkgPath)) {
-        pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-    }
-}
-catch (e) {
-    // Silent fallback
-}
-const app = express();
-const PORT = process.env.PORT || 3456;
-const startTime = Date.now();
-const db = new SQLiteStore();
-const mcpClient = new MCPClient();
-// --- Middleware ---
-app.use(express.json());
-app.use((req, res, next) => {
-    const start = Date.now();
-    res.on("finish", () => {
-        const duration = Date.now() - start;
-        if (duration > 1000) {
-            logger.warn("Slow request", { method: req.method, path: req.path, duration });
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var RETRY_DELAYS = [1e3, 2e3, 4e3];
+var MAX_RETRIES = 3;
+var MAX_RESTARTS = 3;
+var REQUEST_TIMEOUT_MS = 1e4;
+var MCPClient = class {
+  process = null;
+  requestId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  serverPathOverride;
+  restartCount = 0;
+  constructor(serverPath) {
+    this.serverPathOverride = serverPath;
+  }
+  async start() {
+    if (this.process) return;
+    const serverPath = this.serverPathOverride || path.join(__dirname, "./server.js");
+    this.process = spawn("node", [serverPath], {
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    if (!this.process.stdout || !this.process.stdin) {
+      throw new Error("Failed to spawn MCP server");
+    }
+    this.process.on("close", (code) => {
+      if (this.process === null) {
+        return;
+      }
+      logger.error("MCP server process closed unexpectedly", { code, restartCount: this.restartCount });
+      this.process = null;
+      this.isInitialized = false;
+      if (this.restartCount < MAX_RESTARTS) {
+        this.restartCount++;
+        logger.info("Attempting to restart MCP server", { attempt: this.restartCount });
+        this.start().catch((err) => {
+          logger.error("Failed to restart MCP server", { error: String(err) });
+        });
+      } else {
+        logger.error("Max restart attempts reached, giving up", { maxRestarts: MAX_RESTARTS });
+      }
+    });
+    const rl = createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity
+    });
+    rl.on("line", (line) => {
+      try {
+        const response = JSON.parse(line);
+        if (!response.id) return;
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          this.pendingRequests.delete(response.id);
+          if (response.error) {
+            pending.reject(new Error(response.error.message));
+          } else {
+            pending.resolve(response.result);
+          }
         }
+      } catch (err) {
+        logger.error("Failed to parse MCP response", { error: String(err) });
+      }
     });
-    next();
-});
-// --- API Routes ---
-// Health check
-app.get("/api/health", (req, res) => {
-    const stats = db.getStats();
-    res.json({
-        connected: mcpClient.isConnected(),
-        uptime: Math.floor((Date.now() - startTime) / 1000),
-        version: pkg.version,
-        memoryCount: stats.total,
-        pendingRequests: mcpClient.getPendingCount(),
-        dbPath: db.getDbPath()
+    await this.callWithRetry("initialize", {
+      protocolVersion: MCP_PROTOCOL_VERSION,
+      capabilities: {},
+      clientInfo: { name: "mcp-client", version: "1.0.0" }
     });
-});
-// List all repositories
-app.get("/api/repos", async (req, res) => {
+    if (this.process?.stdin) {
+      this.process.stdin.write(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          method: "notifications/initialized"
+        }) + "\n"
+      );
+    }
+    this.isInitialized = true;
+  }
+  /**
+   * Send a single request without retry. Returns a Promise that rejects on timeout.
+   */
+  callOnce(method, params = {}) {
+    if (!this.process || !this.process.stdin) {
+      return Promise.reject(new Error("MCP server not started"));
+    }
+    const id = ++this.requestId;
+    const request = { jsonrpc: "2.0", id, method, params };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      const timer = setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error("Request timeout"));
+        }
+      }, REQUEST_TIMEOUT_MS);
+      if (timer.unref) timer.unref();
+      this.process.stdin.write(JSON.stringify(request) + "\n");
+    });
+  }
+  /**
+   * Call with retry on timeout — up to MAX_RETRIES retries with exponential backoff.
+   * Req 18.1: retry up to 3x with delays 1s, 2s, 4s.
+   */
+  async callWithRetry(method, params = {}) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        return await this.callOnce(method, params);
+      } catch (err) {
+        lastError = err;
+        const isTimeout = err instanceof Error && err.message === "Request timeout";
+        if (!isTimeout || attempt === MAX_RETRIES) {
+          logger.error("MCP request failed", {
+            method,
+            attempt,
+            error: String(err)
+          });
+          throw err;
+        }
+        const delay = RETRY_DELAYS[attempt];
+        logger.warn("MCP request timed out, retrying", {
+          method,
+          attempt: attempt + 1,
+          delayMs: delay
+        });
+        await sleep(delay);
+      }
+    }
+    throw lastError;
+  }
+  async call(method, params = {}) {
+    return this.callWithRetry(method, params);
+  }
+  async callTool(toolName, args) {
+    return this.call("tools/call", { name: toolName, arguments: args });
+  }
+  async readResource(uri) {
+    return this.call("resources/read", { uri });
+  }
+  /**
+   * Stop the client: reject all pending requests, then kill the process.
+   * Req 18.3: reject all pending requests with "Client stopped".
+   */
+  stop() {
+    for (const [id, pending] of this.pendingRequests) {
+      pending.reject(new Error("Client stopped"));
+      this.pendingRequests.delete(id);
+    }
+    if (this.process) {
+      const proc = this.process;
+      this.process = null;
+      this.isInitialized = false;
+      proc.kill();
+    }
+  }
+  isConnected() {
+    return this.isInitialized && this.process !== null;
+  }
+  /**
+   * Returns the number of requests currently awaiting a response.
+   * Req 18.5
+   */
+  getPendingCount() {
+    return this.pendingRequests.size;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/dashboard/lib/context.ts
+var db = new SQLiteStore();
+var mcpClient = new MCPClient();
+var startTime = Date.now();
+
+// src/dashboard/routes/index.ts
+import { Router as Router4 } from "express";
+
+// src/dashboard/routes/system.routes.ts
+import { Router } from "express";
+
+// src/dashboard/controllers/SystemController.ts
+import fs from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/dashboard/lib/jsonApi.ts
+function jsonApiRes(data, type, extra = {}) {
+  const isArray = Array.isArray(data);
+  const dataLayer = isArray ? data.map((item) => {
+    const { id, ...attributes } = item;
+    return { type, id: String(id || "system"), attributes };
+  }) : (() => {
+    const { id, ...attributes } = data;
+    return { type, id: String(id || attributes.id || "system"), attributes };
+  })();
+  return {
+    jsonapi: { version: "1.1" },
+    data: dataLayer,
+    ...extra
+  };
+}
+function jsonApiError(message, status = 500) {
+  return {
+    jsonapi: { version: "1.1" },
+    errors: [{ status: String(status), detail: message }]
+  };
+}
+function getAttributes(req) {
+  return req.body.data?.attributes || req.body;
+}
+
+// src/dashboard/lib/helpers.ts
+function condenseRecentActions(actions, limit) {
+  const condensed = [];
+  for (const action of actions) {
+    const prev = condensed[condensed.length - 1];
+    const same = prev && prev.action === action.action && prev.query === action.query && prev.memory_id === action.memory_id;
+    const within = prev && Math.abs(new Date(prev.created_at).getTime() - new Date(action.created_at).getTime()) <= 6e5;
+    if (same && within) {
+      prev.burstCount++;
+      prev.created_at = action.created_at;
+    } else {
+      condensed.push({ ...action, burstCount: 1 });
+    }
+  }
+  return condensed.slice(0, limit);
+}
+
+// src/dashboard/controllers/SystemController.ts
+var __dirname2 = path2.dirname(fileURLToPath2(import.meta.url));
+var pkg = { version: "0.0.0" };
+try {
+  const pkgPath = path2.join(__dirname2, "../../../package.json");
+  if (fs.existsSync(pkgPath)) {
+    pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  }
+} catch {
+}
+var SystemController = class {
+  static getHealth(req, res) {
+    const stats = db.system.getGlobalStats();
+    const health = {
+      connected: mcpClient.isConnected(),
+      uptime: Math.floor((Date.now() - startTime) / 1e3),
+      version: pkg.version,
+      memoryCount: stats.totalMemories,
+      pendingRequests: mcpClient.getPendingCount(),
+      dbPath: db.getDbPath()
+    };
+    res.json(jsonApiRes(health, "health"));
+  }
+  static getRepos(req, res) {
     try {
-        const repos = db.listRepoNavigation();
-        res.json({ repos });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-// Get global or repo stats
-app.get("/api/stats", async (req, res) => {
+      const repos = db.system.listRepoNavigation();
+      res.json(
+        jsonApiRes(
+          repos.map((r) => ({ id: r.repo, name: r.repo, ...r })),
+          "repository"
+        )
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static getStats(req, res) {
     try {
-        const repo = req.query.repo;
-        const stats = db.getDashboardStats(repo);
-        res.json(stats);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-// Get recent actions
-app.get("/api/recent-actions", async (req, res) => {
+      const repo = req.query.repo;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const stats = db.system.getDashboardStats(repo);
+      res.json(jsonApiRes(stats, "system-stats"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static getRecentActions(req, res) {
     try {
-        const repo = req.query.repo;
-        const pageSize = Math.min(50, Math.max(1, parseInt(req.query.pageSize) || 10));
-        const page = Math.max(1, parseInt(req.query.page) || 1);
-        const rawActions = db.getRecentActions(repo, 100);
-        const allCondensed = condenseRecentActions(rawActions, 100);
-        const offset = (page - 1) * pageSize;
-        res.json({
-            actions: allCondensed.slice(offset, offset + pageSize),
-            pagination: { page, pageSize, totalItems: allCondensed.length }
-        });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-// Memory endpoints
-app.get("/api/memories", async (req, res) => {
+      const repo = req.query.repo;
+      const pageSize = Math.min(50, Math.max(1, parseInt(req.query.pageSize) || 10));
+      const page = Math.max(1, parseInt(req.query.page) || 1);
+      const rawActions = db.actions.getRecentActions(repo, 100);
+      const actions = rawActions.map((a) => ({
+        ...a,
+        query: a.query || void 0,
+        response: a.response || void 0,
+        memory_id: a.memory_id || void 0,
+        task_id: a.task_id || void 0,
+        memory_title: a.memory_title || void 0,
+        memory_type: a.memory_type || void 0
+      }));
+      const allCondensed = condenseRecentActions(actions, 100);
+      const offset = (page - 1) * pageSize;
+      const items = allCondensed.slice(offset, offset + pageSize);
+      res.json(
+        jsonApiRes(items, "recent-action", {
+          meta: { page, pageSize, totalItems: allCondensed.length }
+        })
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static getCapabilities(req, res) {
+    const caps = {
+      tools: TOOL_DEFINITIONS || [],
+      resources: listResources().resources || [],
+      prompts: Object.values(PROMPTS) || []
+    };
+    res.json(jsonApiRes(caps, "capability"));
+  }
+  static getExport(req, res) {
     try {
-        const { repo, type, search, minImportance, maxImportance, sortBy, sortOrder } = req.query;
-        const page = Math.max(1, parseInt(req.query.page || "1", 10));
-        const pageSize = Math.min(100, Math.max(1, parseInt(req.query.pageSize || "25", 10)));
-        if (!repo)
-            return res.status(400).json({ error: "repo is required" });
-        const result = db.listMemoriesForDashboard({
-            repo: repo,
-            type: type,
-            search: search,
-            minImportance: minImportance ? parseInt(minImportance) : undefined,
-            maxImportance: maxImportance ? parseInt(maxImportance) : undefined,
-            sortBy: sortBy,
-            sortOrder: sortOrder === "asc" ? "asc" : "desc",
-            limit: pageSize,
-            offset: (page - 1) * pageSize,
-        });
-        res.json({
-            memories: result.items,
-            pagination: {
-                page,
-                pageSize,
-                totalItems: result.total,
-                totalPages: Math.ceil(result.total / pageSize)
-            }
-        });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.get("/api/memories/:id", async (req, res) => {
+      const { repo } = req.query;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const memories = db.memories.getAllMemoriesWithStats(repo);
+      const tasks = db.tasks.getTasksByRepo(repo);
+      const allComments = db.tasks.getAllTaskCommentsByRepo(repo);
+      const commentsByTaskId = allComments.reduce(
+        (acc, comment) => {
+          if (!acc[comment.task_id]) acc[comment.task_id] = [];
+          acc[comment.task_id].push(comment);
+          return acc;
+        },
+        {}
+      );
+      const tasksWithComments = tasks.map((t) => ({
+        ...t,
+        comments: commentsByTaskId[t.id] || []
+      }));
+      const exportData = {
+        repo,
+        exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+        memories,
+        tasks: tasksWithComments
+      };
+      res.json(jsonApiRes(exportData, "export"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static async callTool(req, res) {
     try {
-        const memory = db.getByIdWithStats(req.params.id);
-        if (!memory)
-            throw new Error("Memory not found");
-        db.logAction("read", memory.scope.repo, { memoryId: memory.id, resultCount: 1 });
-        res.json(memory);
-    }
-    catch (err) {
-        res.status(404).json({ error: err.message });
-    }
-});
-app.post("/api/memories", async (req, res) => {
+      if (!mcpClient.isConnected()) await mcpClient.start();
+      const { name } = req.params;
+      const args = getAttributes(req);
+      const result = await mcpClient.callTool(name, args);
+      res.json(jsonApiRes(result, "tool-result"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+};
+
+// src/dashboard/routes/system.routes.ts
+var router = Router();
+router.get("/health", SystemController.getHealth);
+router.get("/repos", SystemController.getRepos);
+router.get("/stats", SystemController.getStats);
+router.get("/recent-actions", SystemController.getRecentActions);
+router.get("/capabilities", SystemController.getCapabilities);
+router.get("/export", SystemController.getExport);
+router.post("/tools/:name/call", SystemController.callTool);
+var system_routes_default = router;
+
+// src/dashboard/routes/memory.routes.ts
+import { Router as Router2 } from "express";
+
+// src/dashboard/controllers/MemoriesController.ts
+import { randomUUID } from "crypto";
+var MemoriesController = class {
+  static list(req, res) {
     try {
-        const { repo, type, content } = req.body;
-        if (!repo || !type || !content)
-            return res.status(400).json({ error: "Required fields missing" });
-        const id = randomUUID();
-        db.insert({ ...req.body, id, created_at: new Date().toISOString(), updated_at: new Date().toISOString(), scope: { repo } });
-        db.logAction("write", repo, { memoryId: id });
-        res.json({ success: true, id });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.put("/api/memories/:id", async (req, res) => {
+      const query = req.query;
+      const { repo, type, search, minImportance, maxImportance, sortBy, sortOrder } = query;
+      const page = Math.max(1, parseInt(query.page || "1", 10));
+      const pageSize = Math.min(100, Math.max(1, parseInt(query.limit || "25", 10)));
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const result = db.memories.listMemoriesForDashboard({
+        repo,
+        type,
+        search,
+        minImportance: minImportance ? parseInt(minImportance) : void 0,
+        maxImportance: maxImportance ? parseInt(maxImportance) : void 0,
+        sortBy,
+        sortOrder: sortOrder?.toUpperCase() === "ASC" ? "ASC" : "DESC",
+        limit: pageSize,
+        offset: (page - 1) * pageSize
+      });
+      res.json(
+        jsonApiRes(result.items, "memory", {
+          meta: {
+            page,
+            pageSize,
+            totalItems: result.total,
+            totalPages: Math.ceil(result.total / pageSize)
+          }
+        })
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static get(req, res) {
     try {
-        const { id } = req.params;
-        const existing = db.getByIdWithStats ? db.getByIdWithStats(id) : db.getById(id);
-        if (!existing)
-            return res.status(404).json({ error: "Memory not found" });
-        const { title, content, type, importance, tags, agent, model, repo } = req.body;
-        const updates = { title, content, type, importance, tags, agent, model, repo, updated_at: new Date().toISOString() };
-        db.update(id, updates);
-        db.logAction("update", existing.repo || req.body.repo || "", { memoryId: id });
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.delete("/api/memories/:id", async (req, res) => {
+      const memory = db.memories.getByIdWithStats(req.params.id);
+      if (!memory) throw new Error("Memory not found");
+      db.actions.logAction("read", memory.scope.repo, { memoryId: memory.id, resultCount: 1 });
+      res.json(jsonApiRes(memory, "memory"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Memory not found";
+      res.status(404).json(jsonApiError(message, 404));
+    }
+  }
+  static create(req, res) {
     try {
-        const { id } = req.params;
-        const existing = db.getByIdWithStats ? db.getByIdWithStats(id) : db.getById(id);
-        if (!existing)
-            return res.status(404).json({ error: "Memory not found" });
-        db.delete(id);
-        db.logAction("delete", existing.repo || "", { memoryId: id });
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.post("/api/memories/bulk-import", async (req, res) => {
+      const attributes = getAttributes(req);
+      const { repo, type, content } = attributes;
+      if (!repo || !type || !content) return res.status(400).json(jsonApiError("Required fields missing", 400));
+      const id = randomUUID();
+      db.memories.insert({
+        ...attributes,
+        id,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: { repo }
+      });
+      db.actions.logAction("write", repo, { memoryId: id });
+      res.json(jsonApiRes({ id }, "memory"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static update(req, res) {
     try {
-        const { items, repo } = req.body;
-        if (!Array.isArray(items) || !repo)
-            return res.status(400).json({ error: "Invalid payload: requires 'items' array and 'repo'" });
-        const entries = items.map(item => ({
-            ...item,
-            id: item.id || randomUUID(),
-            scope: { ...item.scope, repo },
-            created_at: item.created_at || new Date().toISOString(),
-            updated_at: item.updated_at || new Date().toISOString()
-        }));
-        const count = db.bulkInsertMemories(entries);
-        db.logAction("write", repo, { query: `Bulk imported ${count} memories` });
-        res.json({ success: true, count });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.post("/api/memories/bulk-action", async (req, res) => {
+      const { id } = req.params;
+      const existing = db.memories.getByIdWithStats ? db.memories.getByIdWithStats(id) : db.memories.getById(id);
+      if (!existing) return res.status(404).json(jsonApiError("Memory not found", 404));
+      const attributes = getAttributes(req);
+      const { title, content, type, importance, tags, agent, model, repo } = attributes;
+      const updates = {
+        title,
+        content,
+        type,
+        importance,
+        tags,
+        agent,
+        model,
+        repo,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      db.memories.update(id, updates);
+      db.actions.logAction("update", existing.scope?.repo || attributes.repo || "", { memoryId: id });
+      res.json(jsonApiRes({ message: "Updated" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static delete(req, res) {
     try {
-        const { action, ids, updates } = req.body;
-        if (!Array.isArray(ids) || !action)
-            return res.status(400).json({ error: "Invalid payload: requires 'ids' array and 'action'" });
-        let count = 0;
-        if (action === "delete") {
-            count = db.bulkDeleteMemories(ids);
-        }
-        else if (action === "update" || action === "archive") {
-            count = db.bulkUpdateMemories(ids, updates || { status: action === 'archive' ? 'archived' : 'active' });
-        }
-        else {
-            return res.status(400).json({ error: "Invalid action" });
-        }
-        if (ids.length > 0) {
-            const mem = db.getById(ids[0]);
-            db.logAction(action, mem?.scope?.repo || "unknown", { query: `Bulk ${action} applied to ${count} memories` });
-        }
-        res.json({ success: true, count });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-// Task endpoints
-app.get("/api/tasks", async (req, res) => {
+      const { id } = req.params;
+      const existing = db.memories.getByIdWithStats ? db.memories.getByIdWithStats(id) : db.memories.getById(id);
+      if (!existing) return res.status(404).json(jsonApiError("Memory not found", 404));
+      db.memories.delete(id);
+      db.actions.logAction("delete", existing.scope?.repo || "", { memoryId: id });
+      res.json(jsonApiRes({ message: "Deleted" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static bulkCreate(req, res) {
     try {
-        const { repo, status, search } = req.query;
-        const page = Math.max(1, parseInt(req.query.page || "1", 10));
-        const pageSize = Math.min(100, Math.max(1, parseInt(req.query.pageSize || "20", 10)));
-        if (!repo)
-            return res.status(400).json({ error: "repo is required" });
-        let tasks;
-        if (status && status.includes(',')) {
-            tasks = db.getTasksByMultipleStatuses(repo, status.split(','), pageSize, (page - 1) * pageSize, search);
-        }
-        else {
-            tasks = db.getTasksByRepo(repo, status, pageSize, (page - 1) * pageSize, search);
-        }
-        res.json({ tasks, page, pageSize });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.get("/api/tasks/:id", async (req, res) => {
+      const { items, repo } = getAttributes(req);
+      if (!Array.isArray(items) || !repo)
+        return res.status(400).json(jsonApiError("Invalid payload: requires 'items' array and 'repo'", 400));
+      const entries = items.map((item) => ({
+        ...item,
+        id: item.id || randomUUID(),
+        scope: { ...item.scope, repo },
+        created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: item.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      const count = db.memories.bulkInsertMemories(entries);
+      db.actions.logAction("write", repo, { query: `Bulk imported ${count} memories` });
+      res.json(jsonApiRes({ count }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static bulkAction(req, res) {
     try {
-        const task = db.getTaskById(req.params.id);
-        if (!task)
-            throw new Error("Task not found");
-        db.logAction("read", task.repo, { taskId: task.id });
-        res.json(task);
-    }
-    catch (err) {
-        res.status(404).json({ error: err.message });
-    }
-});
-app.put("/api/tasks/:id", async (req, res) => {
+      const { action, ids, updates } = getAttributes(req);
+      if (!Array.isArray(ids) || !action)
+        return res.status(400).json(jsonApiError("Invalid payload: requires 'ids' array and 'action'", 400));
+      let count = 0;
+      if (action === "delete") {
+        count = db.memories.bulkDeleteMemories(ids);
+      } else if (action === "update" || action === "archive") {
+        count = db.memories.bulkUpdateMemories(
+          ids,
+          updates || { status: action === "archive" ? "archived" : "active" }
+        );
+      } else {
+        return res.status(400).json(jsonApiError("Invalid action", 400));
+      }
+      if (ids.length > 0) {
+        const mem = db.memories.getById(ids[0]);
+        db.actions.logAction(action, mem?.scope?.repo || "unknown", {
+          query: `Bulk ${action} applied to ${count} memories`
+        });
+      }
+      res.json(jsonApiRes({ count }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+};
+
+// src/dashboard/routes/memory.routes.ts
+var router2 = Router2();
+router2.get("/", MemoriesController.list);
+router2.post("/", MemoriesController.create);
+router2.post("/import", MemoriesController.bulkCreate);
+router2.post("/action", MemoriesController.bulkAction);
+router2.get("/:id", MemoriesController.get);
+router2.put("/:id", MemoriesController.update);
+router2.delete("/:id", MemoriesController.delete);
+var memory_routes_default = router2;
+
+// src/dashboard/routes/task.routes.ts
+import { Router as Router3 } from "express";
+
+// src/dashboard/controllers/TasksController.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var TasksController = class {
+  static list(req, res) {
     try {
-        const { id } = req.params;
-        const updates = req.body;
-        const existingTask = db.getTaskById(id);
-        if (!existingTask)
-            return res.status(404).json({ error: "Task not found" });
-        db.updateTask(id, updates);
-        if (updates.status && updates.status !== existingTask.status) {
-            db.logAction("update", existingTask.repo, { taskId: id, query: `Status changed to ${updates.status}` });
-            db.insertTaskComment({
-                id: randomUUID(),
-                task_id: id,
-                repo: existingTask.repo,
-                comment: updates.comment || `Status updated via dashboard`,
-                agent: "dashboard",
-                role: "user",
-                model: "web-ui",
-                previous_status: existingTask.status,
-                next_status: updates.status,
-                created_at: new Date().toISOString()
-            });
-        }
-        else if (updates.comment) {
-            db.insertTaskComment({
-                id: randomUUID(),
-                task_id: id,
-                repo: existingTask.repo,
-                comment: updates.comment,
-                agent: "dashboard",
-                role: "user",
-                model: "web-ui",
-                created_at: new Date().toISOString()
-            });
-        }
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.delete("/api/tasks/:id", async (req, res) => {
+      const query = req.query;
+      const { repo, status, search } = query;
+      const page = Math.max(1, parseInt(req.query.page || "1", 10));
+      const pageSize = Math.min(100, Math.max(1, parseInt(req.query.pageSize || "20", 10)));
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      let tasks;
+      if (status && status.includes(",")) {
+        tasks = db.tasks.getTasksByMultipleStatuses(
+          repo,
+          status.split(","),
+          pageSize,
+          (page - 1) * pageSize,
+          search
+        );
+      } else {
+        tasks = db.tasks.getTasksByRepo(
+          repo,
+          status,
+          pageSize,
+          (page - 1) * pageSize,
+          search
+        );
+      }
+      res.json(jsonApiRes(tasks, "task", { meta: { page, pageSize } }));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static get(req, res) {
     try {
-        const { id } = req.params;
-        const task = db.getTaskById(id);
-        if (!task)
-            return res.status(404).json({ error: "Task not found" });
-        db.deleteTask(id);
-        db.logAction("delete", task.repo, { taskId: id });
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.post("/api/tasks/bulk-import", async (req, res) => {
+      const task = db.tasks.getTaskById(req.params.id);
+      if (!task) throw new Error("Task not found");
+      db.actions.logAction("read", task.repo, { taskId: task.id });
+      res.json(jsonApiRes(task, "task"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Task not found";
+      res.status(404).json(jsonApiError(message, 404));
+    }
+  }
+  static create(req, res) {
     try {
-        const { items, repo } = req.body;
-        if (!Array.isArray(items) || !repo)
-            return res.status(400).json({ error: "Invalid payload: requires 'items' array and 'repo'" });
-        const tasks = items.map(t => ({
-            ...t,
-            id: t.id || randomUUID(),
-            repo,
-            task_code: t.task_code || randomUUID().substring(0, 8),
-            created_at: t.created_at || new Date().toISOString(),
-            updated_at: t.updated_at || new Date().toISOString()
-        }));
-        const count = db.bulkInsertTasks(tasks);
-        db.logAction("write", repo, { query: `Bulk imported ${count} tasks` });
-        res.json({ success: true, count });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.put("/api/task-comments/:id", async (req, res) => {
+      const attributes = getAttributes(req);
+      const { repo, task_code, title } = attributes;
+      if (!repo || !task_code || !title) return res.status(400).json(jsonApiError("Required fields missing", 400));
+      if (db.tasks.isTaskCodeDuplicate(repo, task_code))
+        return res.status(400).json(jsonApiError("Duplicate task_code", 400));
+      const id = randomUUID2();
+      db.tasks.insertTask({
+        ...attributes,
+        id,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      db.actions.logAction("write", repo, { taskId: id });
+      res.json(jsonApiRes({ id }, "task"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static update(req, res) {
     try {
-        const { id } = req.params;
-        const { comment } = req.body;
-        const existingComment = db.getTaskCommentById(id);
-        if (!existingComment)
-            return res.status(404).json({ error: "Comment not found" });
-        db.updateTaskComment(id, { comment });
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.delete("/api/task-comments/:id", async (req, res) => {
+      const { id } = req.params;
+      const attributes = getAttributes(req);
+      const existingTask = db.tasks.getTaskById(id);
+      if (!existingTask) return res.status(404).json(jsonApiError("Task not found", 404));
+      db.tasks.updateTask(id, attributes);
+      if (attributes.status && attributes.status !== existingTask.status) {
+        db.actions.logAction("update", existingTask.repo, {
+          taskId: id,
+          query: `Status changed to ${attributes.status}`
+        });
+        db.tasks.insertTaskComment({
+          id: randomUUID2(),
+          task_id: id,
+          repo: existingTask.repo,
+          comment: attributes.comment || `Status updated via dashboard`,
+          agent: "dashboard",
+          role: "user",
+          model: "web-ui",
+          previous_status: existingTask.status,
+          next_status: attributes.status,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (attributes.comment) {
+        db.tasks.insertTaskComment({
+          id: randomUUID2(),
+          task_id: id,
+          repo: existingTask.repo,
+          comment: attributes.comment,
+          agent: "dashboard",
+          role: "user",
+          model: "web-ui",
+          previous_status: null,
+          next_status: null,
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      res.json(jsonApiRes({ message: "Updated" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static delete(req, res) {
     try {
-        const { id } = req.params;
-        db.deleteTaskComment(id);
-        res.json({ success: true });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.post("/api/tasks", async (req, res) => {
+      const { id } = req.params;
+      const task = db.tasks.getTaskById(id);
+      if (!task) return res.status(404).json(jsonApiError("Task not found", 404));
+      db.tasks.deleteTask(id);
+      db.actions.logAction("delete", task.repo, { taskId: id });
+      res.json(jsonApiRes({ message: "Deleted" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static bulkCreate(req, res) {
     try {
-        const { repo, task_code, title } = req.body;
-        if (!repo || !task_code || !title)
-            return res.status(400).json({ error: "Required fields missing" });
-        if (db.isTaskCodeDuplicate(repo, task_code))
-            return res.status(400).json({ error: "Duplicate task_code" });
-        const id = randomUUID();
-        db.insertTask({ ...req.body, id, created_at: new Date().toISOString(), updated_at: new Date().toISOString() });
-        db.logAction("write", repo, { taskId: id });
-        res.json({ success: true, id });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.get("/api/tasks/stats/time", async (req, res) => {
+      const { items, repo } = getAttributes(req);
+      if (!Array.isArray(items) || !repo)
+        return res.status(400).json(jsonApiError("Invalid payload: requires 'items' array and 'repo'", 400));
+      const tasks = items.map((item) => ({
+        ...item,
+        id: item.id || randomUUID2(),
+        repo,
+        task_code: item.task_code || randomUUID2().substring(0, 8),
+        created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: item.updated_at || (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      const count = db.tasks.bulkInsertTasks(tasks);
+      db.actions.logAction("write", repo, { query: `Bulk imported ${count} tasks` });
+      res.json(jsonApiRes({ count }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static getTimeStats(req, res) {
     try {
-        const { repo } = req.query;
-        if (!repo)
-            return res.status(400).json({ error: "repo is required" });
-        const stats = {
-            daily: {
-                ...db.getTaskTimeStats(repo, 'daily'),
-                history: db.getTaskComparisonSeries(repo, 'daily')
-            },
-            weekly: {
-                ...db.getTaskTimeStats(repo, 'weekly'),
-                history: db.getTaskComparisonSeries(repo, 'weekly')
-            },
-            monthly: {
-                ...db.getTaskTimeStats(repo, 'monthly'),
-                history: db.getTaskComparisonSeries(repo, 'monthly')
-            },
-            overall: {
-                ...db.getTaskTimeStats(repo, 'overall'),
-                history: db.getTaskComparisonSeries(repo, 'overall')
-            }
-        };
-        res.json(stats);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.get("/api/capabilities", (req, res) => {
-    res.json({ tools: TOOL_DEFINITIONS || [], resources: listResources().resources || [], prompts: Object.values(PROMPTS) || [] });
-});
-app.get("/api/export", async (req, res) => {
+      const { repo } = req.query;
+      if (!repo) return res.status(400).json(jsonApiError("repo is required", 400));
+      const stats = {
+        daily: {
+          ...db.tasks.getTaskTimeStats(repo, "daily"),
+          history: db.tasks.getTaskComparisonSeries(repo, "daily")
+        },
+        weekly: {
+          ...db.tasks.getTaskTimeStats(repo, "weekly"),
+          history: db.tasks.getTaskComparisonSeries(repo, "weekly")
+        },
+        monthly: {
+          ...db.tasks.getTaskTimeStats(repo, "monthly"),
+          history: db.tasks.getTaskComparisonSeries(repo, "monthly")
+        },
+        overall: {
+          ...db.tasks.getTaskTimeStats(repo, "overall"),
+          history: db.tasks.getTaskComparisonSeries(repo, "overall")
+        }
+      };
+      res.json(jsonApiRes(stats, "performance-stats"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static updateComment(req, res) {
     try {
-        const { repo } = req.query;
-        if (!repo)
-            return res.status(400).json({ error: "repo is required" });
-        const memories = db.getAllMemoriesWithStats(repo);
-        const tasks = db.getTasksByRepo(repo);
-        const allComments = db.getAllTaskCommentsByRepo(repo);
-        const commentsByTaskId = allComments.reduce((acc, comment) => {
-            if (!acc[comment.task_id]) {
-                acc[comment.task_id] = [];
-            }
-            acc[comment.task_id].push(comment);
-            return acc;
-        }, {});
-        const tasksWithComments = tasks.map(t => ({
-            ...t,
-            comments: commentsByTaskId[t.id] || []
-        }));
-        res.json({
-            repo,
-            exported_at: new Date().toISOString(),
-            memories,
-            tasks: tasksWithComments
-        });
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
-});
-app.post("/api/tools/:name/call", async (req, res) => {
+      const { id } = req.params;
+      const { comment } = getAttributes(req);
+      const existingComment = db.tasks.getTaskCommentById(id);
+      if (!existingComment) return res.status(404).json(jsonApiError("Comment not found", 404));
+      db.tasks.updateTaskComment(id, { comment });
+      res.json(jsonApiRes({ message: "Updated" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+  static deleteComment(req, res) {
     try {
-        if (!mcpClient.isConnected()) {
-            await mcpClient.start();
-        }
-        const { name } = req.params;
-        const args = req.body;
-        const result = await mcpClient.callTool(name, args);
-        res.json(result);
-    }
-    catch (err) {
-        res.status(500).json({ error: err.message });
-    }
+      const { id } = req.params;
+      db.tasks.deleteTaskComment(id);
+      res.json(jsonApiRes({ message: "Deleted" }, "status"));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Internal server error";
+      res.status(500).json(jsonApiError(message));
+    }
+  }
+};
+
+// src/dashboard/routes/task.routes.ts
+var router3 = Router3();
+router3.get("/", TasksController.list);
+router3.post("/", TasksController.create);
+router3.post("/import", TasksController.bulkCreate);
+router3.get("/stats/time", TasksController.getTimeStats);
+router3.get("/:id", TasksController.get);
+router3.put("/:id", TasksController.update);
+router3.delete("/:id", TasksController.delete);
+router3.put("/comments/:id", TasksController.updateComment);
+router3.delete("/comments/:id", TasksController.deleteComment);
+var task_routes_default = router3;
+
+// src/dashboard/routes/index.ts
+var router4 = Router4();
+router4.use("/", system_routes_default);
+router4.use("/memories", memory_routes_default);
+router4.use("/tasks", task_routes_default);
+var routes_default = router4;
+
+// src/dashboard/server.ts
+var __dirname3 = path3.dirname(fileURLToPath3(import.meta.url));
+var pkg2 = { version: "0.0.0" };
+try {
+  const pkgPath = path3.join(__dirname3, "../../package.json");
+  if (fs2.existsSync(pkgPath)) {
+    pkg2 = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+  }
+} catch {
+}
+var app = express();
+var PORT = process.env.PORT || 3456;
+app.use(express.json());
+app.use((req, res, next) => {
+  const start = Date.now();
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    if (duration > 1e3) {
+      logger.warn("Slow request", { method: req.method, path: req.path, duration });
+    }
+  });
+  next();
 });
-// --- Static Serving & Final Routes ---
-const staticRoot = fs.existsSync(path.join(__dirname, "public")) ? path.join(__dirname, "public") : path.join(process.cwd(), "src", "dashboard", "public");
+app.use("/api", routes_default);
+var staticRoot = fs2.existsSync(path3.join(__dirname3, "public")) ? path3.join(__dirname3, "public") : path3.join(process.cwd(), "src", "dashboard", "public");
 app.use(express.static(staticRoot));
-app.get("/", (req, res) => {
-    res.sendFile(path.join(staticRoot, "index.html"));
+app.use((req, res, next) => {
+  if (req.path.startsWith("/api")) return next();
+  res.sendFile(path3.join(staticRoot, "index.html"));
 });
-// --- Utilities ---
-function condenseRecentActions(actions, limit) {
-    const condensed = [];
-    for (const action of actions) {
-        const prev = condensed[condensed.length - 1];
-        const same = prev && prev.action === action.action && prev.query === action.query && prev.memory_id === action.memory_id;
-        const within = prev && Math.abs(new Date(prev.created_at).getTime() - new Date(action.created_at).getTime()) <= 600000;
-        if (same && within) {
-            prev.burstCount++;
-            prev.created_at = action.created_at;
-        }
-        else {
-            condensed.push({ ...action, burstCount: 1 });
-        }
-    }
-    return condensed.slice(0, limit);
-}
-// --- Start Server ---
-// The dashboard reads directly from SQLite for its own views, so it should stay
-// usable even when the MCP child process is unavailable.
 if (process.env.DASHBOARD_ENABLE_MCP === "true") {
-    mcpClient.start().catch(e => logger.error("MCP Client failed", { error: e.message }));
+  mcpClient.start().catch((e) => logger.error("MCP Client failed", { error: e.message }));
 }
 app.listen(PORT, () => {
-    console.log(`${new Date().toISOString()} DASHBOARD_STARTING v${pkg.version} on port ${PORT}`);
+  console.log(`${(/* @__PURE__ */ new Date()).toISOString()} DASHBOARD_STARTING v${pkg2.version} on port ${PORT}`);
+});
+process.on("SIGINT", () => {
+  mcpClient.stop();
+  db.close();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  mcpClient.stop();
+  db.close();
+  process.exit(0);
 });
-process.on("SIGINT", () => { mcpClient.stop(); db.close(); process.exit(0); });
-process.on("SIGTERM", () => { mcpClient.stop(); db.close(); process.exit(0); });
-//# sourceMappingURL=server.js.map