mnemosyne-core 2.0.0

package/dist/server/api.js

@@ -0,0 +1,1699 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/config.ts
+function parseValue(v) {
+  const trimmed = v.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (trimmed === "null" || trimmed === "~") return null;
+  if (/^-?\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+  if (/^-?\d+\.\d+$/.test(trimmed)) return parseFloat(trimmed);
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseYaml(text) {
+  const lines = text.split("\n");
+  const root = {};
+  const stack = [{ obj: root, indent: -1, isArray: false }];
+  for (const rawLine of lines) {
+    const commentIdx = rawLine.indexOf("#");
+    const line = commentIdx >= 0 ? rawLine.slice(0, commentIdx) : rawLine;
+    if (!line.trim()) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const parent = stack[stack.length - 1];
+    if (trimmed.startsWith("- ")) {
+      const valueStr2 = trimmed.slice(2).trim();
+      if (!parent.isArray) {
+      }
+      let target = parent.obj;
+      if (!Array.isArray(target)) {
+        target = [];
+      }
+      if (valueStr2.includes(":")) {
+        const item = {};
+        const colonIdx2 = valueStr2.indexOf(":");
+        const k = valueStr2.slice(0, colonIdx2).trim();
+        const v = valueStr2.slice(colonIdx2 + 1).trim();
+        item[k] = parseValue(v);
+        target.push(item);
+      } else {
+        target.push(parseValue(valueStr2));
+      }
+      continue;
+    }
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = trimmed.slice(0, colonIdx).trim();
+    const valueStr = trimmed.slice(colonIdx + 1).trim();
+    if (!valueStr) {
+      const newObj = {};
+      parent.obj[key] = newObj;
+      stack.push({ obj: newObj, indent, isArray: false });
+    } else {
+      parent.obj[key] = parseValue(valueStr);
+    }
+  }
+  return root;
+}
+function loadConfig() {
+  const configPath = (0, import_path.resolve)(process.cwd(), "config.yaml");
+  if (!(0, import_fs.existsSync)(configPath)) {
+    console.warn("[Config] config.yaml not found, using defaults");
+    return defaultConfig();
+  }
+  try {
+    const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
+    const parsed = parseYaml(raw);
+    return mergeDeep(defaultConfig(), parsed);
+  } catch (err) {
+    console.error("[Config] Failed to parse config.yaml:", err.message);
+    return defaultConfig();
+  }
+}
+function defaultConfig() {
+  return {
+    server: { port: 7321, host: "localhost", version: "2.0.0" },
+    database: { path: "data/nexus.db", wal_mode: true, vec_extension_path: "data/vec0" },
+    storage: { files_dir: "data/files", max_file_size_mb: 50, backups_dir: "data/backups", backup_interval_hours: 24, max_backups: 7 },
+    limits: { max_atoms_per_project: 1e4, rate_limit_requests: 100, rate_limit_window_ms: 6e4 },
+    embeddings: { model: "Xenova/all-MiniLM-L6-v2", dimension: 384, max_text_length: 1e4 },
+    features: { mcp_enabled: true, auto_index_enabled: true, file_processing_enabled: true },
+    index: { debounce_ms: 3e4 },
+    search: { semantic_weight: 0.6, fts_weight: 0.4 },
+    bonds: { default_type: "relates" }
+  };
+}
+function mergeDeep(target, source) {
+  if (!source || typeof source !== "object") return target;
+  const output = { ...target };
+  for (const key of Object.keys(source)) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      output[key] = mergeDeep(target[key] || {}, source[key]);
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+var import_fs, import_path, CONFIG;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    CONFIG = loadConfig();
+  }
+});
+
+// src/server/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  embedText: () => embedText,
+  embedTexts: () => embedTexts,
+  isReady: () => isReady
+});
+async function getExtractor() {
+  if (extractor) return extractor;
+  if (loadError) return null;
+  if (loading) {
+    while (loading) await new Promise((r) => setTimeout(r, 100));
+    return extractor;
+  }
+  loading = true;
+  try {
+    extractor = await (0, import_transformers.pipeline)("feature-extraction", CONFIG.embeddings.model, {
+      quantized: true
+      // Use quantized model for faster download
+    });
+    console.log(`[Embedder] Model loaded: ${CONFIG.embeddings.model}`);
+    return extractor;
+  } catch (err) {
+    loadError = err;
+    console.error("[Embedder] Failed to load model:", err.message);
+    return null;
+  } finally {
+    loading = false;
+  }
+}
+async function embedText(text) {
+  const ext = await getExtractor();
+  if (!ext) return null;
+  const truncated = text.slice(0, CONFIG.embeddings.max_text_length);
+  if (!truncated.trim()) return null;
+  try {
+    const output = await ext(truncated, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+  } catch (err) {
+    console.error("[Embedder] Embedding failed:", err.message);
+    return null;
+  }
+}
+async function embedTexts(texts) {
+  const ext = await getExtractor();
+  if (!ext) return texts.map(() => null);
+  const results = [];
+  for (const text of texts) {
+    const truncated = text.slice(0, CONFIG.embeddings.max_text_length);
+    if (!truncated.trim()) {
+      results.push(null);
+      continue;
+    }
+    try {
+      const output = await ext(truncated, { pooling: "mean", normalize: true });
+      results.push(Array.from(output.data));
+    } catch {
+      results.push(null);
+    }
+  }
+  return results;
+}
+function isReady() {
+  return extractor !== null;
+}
+var import_transformers, extractor, loading, loadError;
+var init_embedder = __esm({
+  "src/server/embedder.ts"() {
+    "use strict";
+    import_transformers = require("@xenova/transformers");
+    init_config();
+    extractor = null;
+    loading = false;
+    loadError = null;
+  }
+});
+
+// src/server/api.ts
+var api_exports = {};
+__export(api_exports, {
+  API: () => ApiRouter
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/mcp/tools.ts
+var TOOLS = [
+  {
+    name: "nexus_list_projects",
+    description: "List all projects in the Mnemosyne knowledge base.",
+    inputSchema: { type: "object", properties: {} },
+    handler: (_args, store) => {
+      return { projects: store.getProjects().map((p) => ({ id: p.id, name: p.name, description: p.description, atomCount: store.getAtomsByProject(p.id).length })) };
+    }
+  },
+  {
+    name: "nexus_search",
+    description: "Search atoms and blocks by keyword. Returns ranked results.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        project: { type: "string", description: "Project name or ID (optional)" },
+        limit: { type: "number", description: "Max results (default 10)" }
+      },
+      required: ["query"]
+    },
+    handler: (args, store) => {
+      const projectId = args.project ? store.getProjectByName(args.project)?.id || args.project : "";
+      const results = store.search(projectId, args.query, args.limit || 10);
+      return { query: args.query, count: results.length, results };
+    }
+  },
+  {
+    name: "nexus_read_atom",
+    description: "Read an atom by ID or title. Returns atom details, blocks, children, and bonds.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Atom UUID" },
+        title: { type: "string", description: "Atom title (alternative to id)" },
+        project: { type: "string", description: "Project name (required if searching by title)" }
+      },
+      required: []
+    },
+    handler: (args, store) => {
+      let atom = args.id ? store.getAtom(args.id) : void 0;
+      if (!atom && args.title && args.project) {
+        const projectId = store.getProjectByName(args.project)?.id || args.project;
+        atom = store.getAtomsByProject(projectId).find((a) => a.title === args.title);
+      }
+      if (!atom) throw new Error("Atom not found");
+      const children = store.getAtomChildren(atom.id).map((a) => ({ id: a.id, title: a.title, type: a.metadata?.type || "text" }));
+      const blocks = store.getBlocksByAtom(atom.id);
+      const bonds = store.getBondsByAtom(atom.id);
+      return { atom, children, blocks, bonds };
+    }
+  },
+  {
+    name: "nexus_create_atom",
+    description: "Create a new atom in a project.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name or ID" },
+        title: { type: "string", description: "Atom title/path" },
+        type: { type: "string", description: "Atom type (text, memory, stream, thought, task)" },
+        parent_id: { type: "string", description: "Parent atom ID (optional)" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags (optional)" },
+        assistant_id: { type: "string", description: "Creator assistant ID" }
+      },
+      required: ["project", "title"]
+    },
+    handler: (args, store) => {
+      const project = store.getProjectByName(args.project) || store.getProject(args.project);
+      if (!project) throw new Error("Project not found");
+      const assistantId = args.assistant_id || "mcp-assistant";
+      const atom = store.createAtom(project.id, args.title, args.type || "text", assistantId, {
+        parentId: args.parent_id,
+        tags: args.tags
+      });
+      return { success: true, atom };
+    }
+  },
+  {
+    name: "nexus_update_atom",
+    description: "Update an atom's title or parent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "Atom UUID" },
+        title: { type: "string", description: "New title" },
+        parent_id: { type: ["string", "null"], description: "New parent ID or null for root" },
+        assistant_id: { type: "string", description: "Updater assistant ID" }
+      },
+      required: ["id"]
+    },
+    handler: (args, store) => {
+      const assistantId = args.assistant_id || "mcp-assistant";
+      if (args.parent_id !== void 0) {
+        const updated2 = store.updateAtomParent(args.id, args.parent_id, assistantId);
+        if (!updated2) throw new Error("Invalid parent or atom not found");
+      }
+      const updated = store.updateAtom(args.id, { title: args.title }, assistantId);
+      return { success: true, atom: updated || store.getAtom(args.id) };
+    }
+  },
+  {
+    name: "nexus_create_bond",
+    description: "Create a bond (graph connection) between two atoms.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        source_id: { type: "string", description: "Source atom ID" },
+        target_id: { type: "string", description: "Target atom ID" },
+        label: { type: "string", description: "Bond label (default: connects)" },
+        color: { type: "string", description: "Hex color (optional)" }
+      },
+      required: ["source_id", "target_id"]
+    },
+    handler: (args, store) => {
+      const bond = store.createBond(args.source_id, args.target_id, args.label || "connects", args.color);
+      return { success: true, bond };
+    }
+  },
+  {
+    name: "nexus_request_checkout",
+    description: "Request an exclusive checkout (lock) on an atom.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        atom_id: { type: "string", description: "Atom UUID" },
+        assistant_id: { type: "string", description: "Assistant requesting checkout" },
+        reason: { type: "string", description: "Reason for checkout" }
+      },
+      required: ["atom_id", "assistant_id"]
+    },
+    handler: (args, store) => {
+      const result = store.checkout(args.atom_id, args.assistant_id, "exclusive", args.reason || "");
+      return result;
+    }
+  },
+  {
+    name: "nexus_release_checkout",
+    description: "Release a checkout (unlock) on an atom.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        atom_id: { type: "string", description: "Atom UUID" },
+        assistant_id: { type: "string", description: "Assistant releasing checkout" }
+      },
+      required: ["atom_id", "assistant_id"]
+    },
+    handler: (args, store) => {
+      const success = store.releaseCheckout(args.atom_id, args.assistant_id);
+      return { success };
+    }
+  },
+  {
+    name: "nexus_subscribe_to_atom",
+    description: "Subscribe to real-time updates for an atom via WebSocket.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        atom_id: { type: "string", description: "Atom UUID to subscribe to" }
+      },
+      required: ["atom_id"]
+    },
+    handler: (args, _store) => {
+      return { success: true, wsEndpoint: "ws://localhost:7321/ws", atom_id: args.atom_id, message: "Connect via WebSocket and send { type: 'subscribe', atomId: '<id>' }" };
+    }
+  },
+  {
+    name: "nexus_batch",
+    description: "Execute multiple MCP tools in a single request. Reduces round-trip token waste.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operations: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              tool: { type: "string", description: "Tool name to call" },
+              params: { type: "object", description: "Parameters for the tool" }
+            },
+            required: ["tool"]
+          },
+          description: "Ordered list of tool calls"
+        },
+        stop_on_error: { type: "boolean", description: "If true, stop at first error. Default: false", default: false }
+      },
+      required: ["operations"]
+    },
+    handler: (args, store) => {
+      const operations = args.operations || [];
+      const stopOnError = args.stop_on_error ?? false;
+      const results = [];
+      const toolMap = /* @__PURE__ */ new Map();
+      for (const t of TOOLS) toolMap.set(t.name, t);
+      for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        const tool = toolMap.get(op.tool);
+        if (!tool) {
+          results.push({ index: i, tool: op.tool, error: `Tool not found: ${op.tool}` });
+          if (stopOnError) break;
+          continue;
+        }
+        try {
+          const result = tool.handler(op.params || {}, store);
+          results.push({ index: i, tool: op.tool, success: true, result });
+        } catch (err) {
+          results.push({ index: i, tool: op.tool, error: err.message });
+          if (stopOnError) break;
+        }
+      }
+      return { count: operations.length, completed: results.length, results };
+    }
+  }
+];
+
+// src/mcp/server.ts
+var McpServer = class {
+  store;
+  toolMap = /* @__PURE__ */ new Map();
+  constructor(store) {
+    this.store = store;
+    for (const t of TOOLS) this.toolMap.set(t.name, t);
+  }
+  /**
+   * Returns `null` for notifications (no response needed).
+   */
+  handleRequest(req) {
+    if (req.id === null || req.id === void 0) {
+      return null;
+    }
+    try {
+      switch (req.method) {
+        case "initialize":
+          return this.ok(req.id, {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {}, resources: {}, prompts: {} },
+            serverInfo: { name: "mnemosyne-mcp", version: "2.0.0" }
+          });
+        case "tools/list":
+          return this.ok(req.id, {
+            tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
+          });
+        case "tools/call": {
+          const { name, arguments: args } = req.params || {};
+          const tool = this.toolMap.get(name);
+          if (!tool) return this.err(req.id, -32601, `Tool not found: ${name}`);
+          const result = tool.handler(args || {}, this.store);
+          return this.ok(req.id, { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] });
+        }
+        case "resources/list":
+          return this.ok(req.id, { resources: [] });
+        case "prompts/list":
+          return this.ok(req.id, { prompts: [] });
+        default:
+          return this.err(req.id, -32601, `Method not found: ${req.method}`);
+      }
+    } catch (e) {
+      return this.err(req.id, -32603, e.message);
+    }
+  }
+  getManifest() {
+    return {
+      name: "Mnemosyne",
+      version: "2.0.0",
+      description: "Knowledge base MCP server for projects, atoms, blocks, and bonds.",
+      protocol: "mcp",
+      transport: ["stdio", "sse"],
+      endpoints: {
+        sse: "/mcp/sse",
+        messages: "/mcp/messages"
+      },
+      tools: TOOLS.map((t) => ({ name: t.name, description: t.description }))
+    };
+  }
+  ok(id, result) {
+    return { jsonrpc: "2.0", id, result };
+  }
+  err(id, code, message) {
+    return { jsonrpc: "2.0", id, error: { code, message } };
+  }
+};
+
+// src/mcp/sse.ts
+var McpSseTransport = class {
+  server;
+  sessions = /* @__PURE__ */ new Map();
+  sessionCounter = 0;
+  constructor(server) {
+    this.server = server;
+  }
+  handleSse(req, res) {
+    const id = `sess_${++this.sessionCounter}_${Date.now()}`;
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    });
+    this.sessions.set(id, { id, res });
+    this.sendSse(id, "endpoint", "/mcp/messages?session_id=" + id);
+    req.on("close", () => this.sessions.delete(id));
+  }
+  handleMessage(req, res, body) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const sessionId = url.searchParams.get("session_id") || "";
+    const request = body;
+    if (!request || request.jsonrpc !== "2.0") {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "invalid_jsonrpc" }));
+      return;
+    }
+    const response = this.server.handleRequest(request);
+    if (!response) {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end("{}");
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(response));
+    if (sessionId) this.sendSse(sessionId, "message", JSON.stringify(response));
+  }
+  sendSse(sessionId, event, data) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.res.write(`event: ${event}
+data: ${data}
+
+`);
+  }
+};
+
+// src/api/middleware.ts
+var RateLimiter = class {
+  rates = /* @__PURE__ */ new Map();
+  limit;
+  windowMs;
+  constructor(limit, windowMs) {
+    this.limit = limit;
+    this.windowMs = windowMs;
+    setInterval(() => this.cleanup(), 6e4);
+  }
+  check(token) {
+    const now = Date.now();
+    let window = this.rates.get(token);
+    if (!window || window.resetAt < now) {
+      window = { count: 0, resetAt: now + this.windowMs };
+      this.rates.set(token, window);
+    }
+    if (window.count >= this.limit) return false;
+    window.count++;
+    return true;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, window] of this.rates.entries()) {
+      if (window.resetAt < now) this.rates.delete(key);
+    }
+  }
+};
+function setCorsHeaders(res) {
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+  res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+  res.setHeader("Pragma", "no-cache");
+  res.setHeader("Expires", "0");
+}
+function authenticate(store, req) {
+  const token = req.headers.authorization?.replace("Bearer ", "");
+  return token ? store.getAssistant(token) : void 0;
+}
+
+// src/api/utils.ts
+function json(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function readBody(req) {
+  return new Promise((resolve4) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      try {
+        resolve4(JSON.parse(body));
+      } catch {
+        resolve4({});
+      }
+    });
+  });
+}
+function resolveProjectId(store, idOrName) {
+  if (!idOrName) return "";
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(idOrName)) return idOrName;
+  const p = store.getProjectByName(idOrName);
+  return p?.id || idOrName;
+}
+function serializeAtom(store, atom, compact = false) {
+  if (compact) {
+    return {
+      id: atom.id,
+      title: atom.title,
+      type: atom.metadata?.type || "memory",
+      status: atom.status
+    };
+  }
+  const blockCount = atom.block_count ?? store.getBlocksByAtom(atom.id).length;
+  return {
+    id: atom.id,
+    project_id: atom.project_id,
+    parent_id: atom.parent_id,
+    title: atom.title,
+    summary: atom.summary,
+    type: atom.metadata?.type || "memory",
+    icon: atom.icon,
+    color: atom.color,
+    metadata: atom.metadata,
+    auto_path: atom.auto_path,
+    path_overridden: atom.path_overridden,
+    status: atom.status,
+    status_updated_at: atom.status_updated_at,
+    block_count: atom.block_count,
+    bond_count: atom.bond_count,
+    template_id: atom.template_id,
+    embedding_status: atom.embedding_status,
+    state: {
+      lock: atom.locked_by ? { assistantId: atom.locked_by, reason: atom.locked_reason } : null,
+      queue: [],
+      blockCount,
+      lastActivity: atom.updated_at
+    }
+  };
+}
+function pickFields(obj, fields) {
+  const result = {};
+  for (const f of fields) {
+    if (f.includes(".")) {
+      const [head, ...tail] = f.split(".");
+      if (obj[head] != null) {
+        result[head] = result[head] || (Array.isArray(obj[head]) ? [] : {});
+        if (Array.isArray(obj[head])) {
+          result[head] = obj[head].map((item) => pickFields(item, [tail.join(".")]));
+        } else {
+          const nested = pickFields(obj[head], [tail.join(".")]);
+          Object.assign(result[head], nested);
+        }
+      }
+    } else if (obj[f] !== void 0) {
+      result[f] = obj[f];
+    }
+  }
+  return result;
+}
+function exportAtomMarkdown(store, atom) {
+  const blocks = store.getBlocksByAtom(atom.id).sort((a, b) => (a.order_index || 0) - (b.order_index || 0));
+  const bonds = store.getBondsByAtom(atom.id);
+  const parent = atom.parent_id ? store.getAtom(atom.parent_id) : null;
+  let md = `---
+`;
+  md += `title: "${atom.title}"
+`;
+  md += `type: ${atom.type || "memory"}
+`;
+  md += `status: ${atom.status || "draft"}
+`;
+  md += `path: ${atom.auto_path || "/"}
+`;
+  if (atom.summary) md += `summary: "${atom.summary}"
+`;
+  if (atom.metadata?.tags?.length) md += `tags: [${atom.metadata.tags.map((t) => `"${t}"`).join(", ")}]
+`;
+  if (parent) md += `parent: "${parent.title}"
+`;
+  md += `exported_at: ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  md += `---
+
+`;
+  md += `# ${atom.title}
+
+`;
+  if (atom.summary) md += `${atom.summary}
+
+`;
+  for (const b of blocks) {
+    const content = b.content || "";
+    if (b.type === "text") {
+      try {
+        const p = JSON.parse(content);
+        md += `${p.text || content}
+
+`;
+      } catch {
+        md += `${content}
+
+`;
+      }
+    } else if (b.type === "code") {
+      const lines = content.split("\n");
+      const first = lines[0]?.trim() || "";
+      let lang = "";
+      let code = content;
+      if (first.startsWith("```")) {
+        lang = first.replace(/```/g, "").trim();
+        code = lines.slice(1).join("\n").replace(/```$/, "").trim();
+      }
+      md += `\`\`\`${lang}
+${code}
+\`\`\`
+
+`;
+    } else if (b.type === "checklist") {
+      try {
+        const items = JSON.parse(content);
+        if (Array.isArray(items)) {
+          for (const item of items) md += `- [${item.checked ? "x" : " "}] ${item.text}
+`;
+          md += "\n";
+        }
+      } catch {
+        md += `${content}
+
+`;
+      }
+    } else if (b.type === "table") {
+      try {
+        const rows = JSON.parse(content);
+        if (Array.isArray(rows) && rows.length) {
+          const headers = Object.keys(rows[0]);
+          md += `| ${headers.join(" | ")} |
+`;
+          md += `| ${headers.map(() => "---").join(" | ")} |
+`;
+          for (const row of rows) md += `| ${headers.map((h) => String(row[h] ?? "")).join(" | ")} |
+`;
+          md += "\n";
+        }
+      } catch {
+        md += `${content}
+
+`;
+      }
+    } else if (b.type === "image" || b.type === "file") {
+      try {
+        const meta = JSON.parse(content);
+        if (b.type === "image") md += `![${meta.file_name || "image"}](${meta.hash})
+
+`;
+        else md += `[${meta.file_name || "file"}](${meta.hash})
+
+`;
+      } catch {
+        md += `${content}
+
+`;
+      }
+    } else if (b.type === "link") {
+      const url = content.trim().startsWith("http") ? content.trim() : "https://" + content.trim();
+      md += `[${content.trim()}](${url})
+
+`;
+    } else {
+      md += `${content}
+
+`;
+    }
+  }
+  const allBonds = [...bonds.outgoing || [], ...bonds.incoming || []];
+  if (allBonds.length) {
+    md += `---
+
+## Connections
+
+`;
+    for (const b of allBonds) {
+      const otherId = b.source_id === atom.id ? b.target_id : b.source_id;
+      const other = store.getAtom(otherId);
+      const dir = b.source_id === atom.id ? "\u2192" : "\u2190";
+      md += `- ${dir} [[${other ? other.title : otherId}]] (${b.label})
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+function exportMarkdown(store, projectId) {
+  const project = projectId ? store.getProject(projectId) : void 0;
+  const atoms = projectId ? store.getAtomsByProject(projectId) : [];
+  const bonds = projectId ? store.getGraph(projectId).bonds : [];
+  const blockMap = /* @__PURE__ */ new Map();
+  for (const atom of atoms) {
+    for (const b of store.getBlocksByAtom(atom.id)) {
+      blockMap.set(b.id, b);
+    }
+  }
+  let md = `# ${project ? project.name : "Mnemosyne Export"}
+
+`;
+  md += `*Exported on ${(/* @__PURE__ */ new Date()).toISOString()}*
+
+`;
+  const atomMap = new Map(atoms.map((a) => [a.id, a]));
+  const rootAtoms = atoms.filter((a) => !a.parent_id);
+  function renderAtom(atom, depth) {
+    const indent = "  ".repeat(depth);
+    md += `${indent}## ${atom.title}
+
+`;
+    if (atom.summary) md += `${indent}${atom.summary}
+
+`;
+    if (atom.metadata?.tags?.length) md += `${indent}*Tags: ${atom.metadata.tags.join(", ")}*
+
+`;
+    const atomBlocks = Array.from(blockMap.values()).filter((b) => b.atom_id === atom.id).sort((a, b) => a.order_index - b.order_index);
+    for (const b of atomBlocks) {
+      try {
+        const parsed = JSON.parse(b.content || "{}");
+        if (parsed.text) md += `${indent}${parsed.text}
+
+`;
+        else md += `${indent}\`\`\`json
+${indent}${JSON.stringify(parsed, null, 2).split("\n").join("\n" + indent)}
+${indent}\`\`\`
+
+`;
+      } catch {
+        md += `${indent}${b.content || ""}
+
+`;
+      }
+    }
+    const children = atoms.filter((a) => a.parent_id === atom.id);
+    for (const child of children) renderAtom(child, depth + 1);
+  }
+  for (const root of rootAtoms) renderAtom(root, 0);
+  if (bonds.length) {
+    md += `---
+
+## Bonds
+
+`;
+    for (const b of bonds) {
+      const src = atomMap.get(b.source_id);
+      const tgt = atomMap.get(b.target_id);
+      md += `- [[${src ? src.title : b.source_id}]] \u2014${b.label}\u2192 [[${tgt ? tgt.title : b.target_id}]]
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+
+// src/api/routes/assistants.ts
+function handleAssistants(store, pathname, method, res, body) {
+  if (pathname === "/api/v1/assistants/register" && method === "POST") {
+    const a = body;
+    const id = a.id || a.name || crypto.randomUUID();
+    const existing = store.getAssistant(id);
+    if (existing) {
+      json(res, 200, { success: true, token: existing.id, assistant: existing });
+      return true;
+    }
+    const newAssistant = store.registerAssistant({ id, name: a.name || id, role: a.role || "developer", capabilities: a.capabilities || [], description: a.description, provider: a.provider, instructions: a.instructions, config: a.config });
+    json(res, 200, { success: true, token: newAssistant.id, assistant: newAssistant });
+    return true;
+  }
+  if (pathname.startsWith("/api/v1/assistants/") && pathname.endsWith("/heartbeat") && method === "POST") {
+    const id = pathname.split("/")[4];
+    store.heartbeat(id);
+    json(res, 200, { success: true });
+    return true;
+  }
+  if (pathname === "/api/v1/assistants" && method === "GET") {
+    const compact = new URL(pathname, "http://localhost").searchParams.get("compact") === "true";
+    const assistants = store.getAllAssistants().map(
+      (a) => compact ? { id: a.id, name: a.name, role: a.role, status: a.status } : a
+    );
+    json(res, 200, { assistants });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/assistants\/[^\/]+$/) && method === "PATCH") {
+    const id = pathname.replace("/api/v1/assistants/", "");
+    const a = body;
+    const updated = store.updateAssistant(id, a);
+    if (!updated) {
+      json(res, 404, { error: "assistant_not_found" });
+      return true;
+    }
+    json(res, 200, { assistant: updated });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/assistants\/[^\/]+$/) && method === "DELETE") {
+    const id = pathname.replace("/api/v1/assistants/", "");
+    const ok = store.deleteAssistant(id);
+    json(res, ok ? 200 : 404, { success: ok });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/projects.ts
+function handleProjects(store, pathname, method, res, body, searchParams) {
+  if (pathname === "/api/v1/projects" && method === "GET") {
+    const compact = searchParams.get("compact") === "true";
+    const projects = store.getProjects().map(
+      (p) => compact ? { id: p.id, name: p.name, description: p.description } : p
+    );
+    json(res, 200, { projects });
+    return true;
+  }
+  if (pathname === "/api/v1/projects" && method === "POST") {
+    const { name, description } = body;
+    if (!name) {
+      json(res, 400, { error: "name_required" });
+      return true;
+    }
+    const project = store.createProject(name, description);
+    json(res, 200, { success: true, project });
+    return true;
+  }
+  const projectIndexMatch = pathname.match(/^\/api\/v1\/projects\/([^/]+)\/index$/);
+  if (projectIndexMatch && method === "GET") {
+    const projectId = resolveProjectId(store, projectIndexMatch[1]);
+    const indexAtom = store.getProjectIndexAtom(projectId);
+    if (!indexAtom) {
+      json(res, 404, { error: "index_not_found" });
+      return true;
+    }
+    const blocks = store.getBlocksByAtom(indexAtom.id);
+    const manifestBlock = blocks.find((b) => b.type === "text");
+    let manifest = {};
+    try {
+      if (manifestBlock) manifest = JSON.parse(manifestBlock.content || "{}");
+    } catch {
+    }
+    json(res, 200, {
+      project_id: projectId,
+      atom_id: indexAtom.id,
+      generated_at: indexAtom.updated_at,
+      manifest
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/atoms.ts
+function handleAtoms(store, pathname, method, res, body, searchParams, assistant) {
+  if (pathname === "/api/v1/atoms" && method === "POST") {
+    const { project_id, title, type, parent_id, tags, template, status, auto_path, path_overridden } = body;
+    if (!project_id || !title) {
+      json(res, 400, { error: "project_id_and_title_required" });
+      return true;
+    }
+    const resolvedProjectId = resolveProjectId(store, project_id);
+    if (!resolvedProjectId) {
+      json(res, 400, { error: "project_not_found" });
+      return true;
+    }
+    if (!assistant || !store.can(assistant.role, "create", void 0, assistant.id)) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const atom = store.createAtom(resolvedProjectId, title, type || "text", assistant.id, { parentId: parent_id, tags, template, status, auto_path, path_overridden });
+    json(res, 200, { atom: serializeAtom(store, atom) });
+    return true;
+  }
+  if (pathname === "/api/v1/atoms" && method === "GET") {
+    const projectId = resolveProjectId(store, searchParams.get("project_id") || "");
+    const compact = searchParams.get("compact") === "true";
+    const atoms = projectId ? store.getAtomsByProject(projectId).map((d) => serializeAtom(store, d, compact)) : [];
+    json(res, 200, { atoms });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+$/) && method === "GET" && !pathname.includes("/blocks") && !pathname.includes("/bonds") && !pathname.includes("/checkout") && !pathname.includes("/queue")) {
+    const atomId = pathname.replace("/api/v1/atoms/", "");
+    const atom = store.getAtom(atomId);
+    if (!atom) {
+      json(res, 404, { error: "atom_not_found" });
+      return true;
+    }
+    const fieldsParam = searchParams.get("fields");
+    const children = store.getAtomChildren(atomId).map((a) => ({ id: a.id, title: a.title, type: a.metadata?.type || "memory", blockCount: store.getBlocksByAtom(a.id).length }));
+    const full = {
+      atom: serializeAtom(store, atom),
+      children,
+      blocks: store.getBlocksByAtom(atomId),
+      bonds: store.getBondsByAtom(atomId)
+    };
+    const response = fieldsParam ? pickFields(full, fieldsParam.split(",")) : full;
+    json(res, 200, response);
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+$/) && (method === "PATCH" || method === "POST") && !pathname.includes("/blocks") && !pathname.includes("/bonds")) {
+    const atomId = pathname.replace("/api/v1/atoms/", "");
+    const { parent_id, title, summary, tags, status, auto_path, path_overridden } = body;
+    if (!assistant || !store.can(assistant.role, "update", atomId, assistant.id)) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    if (parent_id !== void 0) {
+      const updated = store.updateAtomParent(atomId, parent_id ?? null, assistant.id);
+      if (!updated) {
+        json(res, 400, { error: "invalid_parent" });
+        return true;
+      }
+      json(res, 200, { atom: serializeAtom(store, updated) });
+      return true;
+    }
+    try {
+      const updated = store.updateAtom(atomId, { title, summary, tags, status, auto_path, path_overridden }, assistant.id);
+      if (!updated) {
+        json(res, 404, { error: "atom_not_found" });
+        return true;
+      }
+      json(res, 200, { atom: serializeAtom(store, updated) });
+    } catch (err) {
+      json(res, 400, { error: err.message });
+    }
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+$/) && method === "DELETE" && !pathname.includes("/blocks") && !pathname.includes("/bonds") && !pathname.includes("/checkout")) {
+    const atomId = pathname.replace("/api/v1/atoms/", "");
+    if (!assistant || !store.can(assistant.role, "delete", atomId, assistant.id)) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const ok = store.deleteAtom(atomId, assistant.id);
+    json(res, ok ? 200 : 404, { success: ok });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/checkout$/) && method === "POST") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/checkout", "");
+    const { mode, reason } = body;
+    if (!assistant || !store.can(assistant.role, "lock", atomId, assistant.id)) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const result = store.checkout(atomId, assistant.id, mode || "exclusive", reason || "");
+    json(res, result.success ? 200 : 423, result);
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/checkout$/) && method === "DELETE") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/checkout", "");
+    if (!assistant) {
+      json(res, 403, { error: "unauthorized" });
+      return true;
+    }
+    const success = store.releaseCheckout(atomId, assistant.id);
+    json(res, success ? 200 : 400, { success });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/queue$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/queue", "");
+    const status = store.getQueueStatus(atomId);
+    json(res, status ? 200 : 404, status || { error: "atom_not_found" });
+    return true;
+  }
+  const queueGrantMatch = pathname.match(/^\/api\/v1\/atoms\/([^\/]+)\/queue\/([^\/]+)\/grant$/);
+  if (queueGrantMatch && method === "POST") {
+    const atomId = queueGrantMatch[1];
+    const queueId = queueGrantMatch[2];
+    const ok = store.grantQueueItem(atomId, queueId);
+    json(res, ok ? 200 : 400, { success: ok });
+    return true;
+  }
+  const queueRejectMatch = pathname.match(/^\/api\/v1\/atoms\/([^\/]+)\/queue\/([^\/]+)\/reject$/);
+  if (queueRejectMatch && method === "POST") {
+    const atomId = queueRejectMatch[1];
+    const queueId = queueRejectMatch[2];
+    const ok = store.rejectQueueItem(atomId, queueId);
+    json(res, ok ? 200 : 400, { success: ok });
+    return true;
+  }
+  const queueBumpMatch = pathname.match(/^\/api\/v1\/atoms\/([^\/]+)\/queue\/([^\/]+)\/bump$/);
+  if (queueBumpMatch && method === "POST") {
+    const atomId = queueBumpMatch[1];
+    const queueId = queueBumpMatch[2];
+    const ok = store.bumpQueueItem(atomId, queueId);
+    json(res, ok ? 200 : 400, { success: ok });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/permissions$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/permissions", "");
+    const perms = store.getAtomPermissions(atomId);
+    json(res, 200, { atom_id: atomId, permissions: perms });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/permissions$/) && method === "POST") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/permissions", "");
+    const { assistant_id, level } = body;
+    if (!assistant_id || !level) {
+      json(res, 400, { error: "assistant_id_and_level_required" });
+      return true;
+    }
+    store.setAtomPermission(atomId, assistant_id, level, assistant?.id);
+    json(res, 200, { success: true });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/permissions\/[^\/]+$/) && method === "DELETE") {
+    const parts = pathname.replace("/api/v1/atoms/", "").split("/");
+    const atomId = parts[0];
+    const assistantId = parts[2];
+    const ok = store.removeAtomPermission(atomId, assistantId);
+    json(res, ok ? 200 : 404, { success: ok });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/history$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/history", "");
+    const history = store.getAtomHistory(atomId);
+    json(res, 200, { atom_id: atomId, history });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/export$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/export", "");
+    const format = searchParams.get("format") || "markdown";
+    const atom = store.getAtom(atomId);
+    if (!atom) {
+      json(res, 404, { error: "atom_not_found" });
+      return true;
+    }
+    if (format === "markdown") {
+      const md = exportAtomMarkdown(store, atom);
+      const safeName = (atom.title || "memory").replace(/[^a-z0-9\-_]/gi, "_").toLowerCase();
+      res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Content-Disposition": `attachment; filename="${safeName}.md"` });
+      res.end(md);
+      return true;
+    }
+    json(res, 400, { error: "unsupported_format" });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/force-release$/) && method === "POST") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/force-release", "");
+    const atom = store.getAtom(atomId);
+    if (!atom) {
+      json(res, 404, { error: "atom_not_found" });
+      return true;
+    }
+    if (!atom.locked_by) {
+      json(res, 200, { success: true, note: "not_locked" });
+      return true;
+    }
+    const ok = store.forceRelease(atomId, assistant?.id || "system");
+    json(res, ok ? 200 : 400, { success: ok });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/bonds.ts
+function handleBonds(store, pathname, method, res, body) {
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/bonds$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/bonds", "");
+    json(res, 200, store.getBondsByAtom(atomId));
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/bonds$/) && method === "POST") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/bonds", "");
+    const { target_id, label, color } = body;
+    if (!target_id) {
+      json(res, 400, { error: "target_id_required" });
+      return true;
+    }
+    const bond = store.createBond(atomId, target_id, label || "connects", color);
+    json(res, 200, { bond });
+    return true;
+  }
+  if (pathname === "/api/v1/bonds" && method === "DELETE") {
+    const { bond_id } = body;
+    const ok = store.deleteBond(bond_id);
+    json(res, ok ? 200 : 404, { success: ok });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/bonds\/[^\/]+$/) && method === "DELETE") {
+    const bondId = pathname.replace("/api/v1/bonds/", "");
+    const ok = store.deleteBond(bondId);
+    json(res, ok ? 200 : 404, { success: ok });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/bonds\/[^\/]+$/) && method === "PATCH") {
+    const bondId = pathname.replace("/api/v1/bonds/", "");
+    const { label, color } = body;
+    const updated = store.updateBond(bondId, { label, color });
+    if (!updated) {
+      json(res, 404, { error: "bond_not_found" });
+      return true;
+    }
+    json(res, 200, { bond: updated });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/blocks.ts
+function handleBlocks(store, pathname, method, res, body, assistant) {
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/blocks$/) && method === "POST") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/blocks", "");
+    const { type, content, tags } = body;
+    const isSuggestion = type === "suggestion";
+    const requiredAction = isSuggestion ? "suggest" : "write";
+    if (!assistant || !store.can(assistant.role, requiredAction, atomId, assistant.id)) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const block = store.createBlock(atomId, type || "text", content || "", assistant.id, { tags });
+    if (type === "file" || type === "image") {
+      store.processFileBlock(atomId, content || "").catch(() => {
+      });
+    }
+    json(res, 200, { block });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/blocks\/[^\/]+$/) && method === "GET") {
+    const blockId = pathname.replace("/api/v1/blocks/", "");
+    const block = store.getBlock(blockId);
+    if (!block) {
+      json(res, 404, { error: "block_not_found" });
+      return true;
+    }
+    json(res, 200, { block });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/blocks\/[^\/]+$/) && method === "PATCH") {
+    const blockId = pathname.replace("/api/v1/blocks/", "");
+    const { content, type, metadata } = body;
+    const block = store.getBlock(blockId);
+    if (!block) {
+      json(res, 404, { error: "block_not_found" });
+      return true;
+    }
+    if (content !== void 0) {
+      store.updateBlock(blockId, content, assistant?.id || "system");
+    }
+    if (type !== void 0 || metadata !== void 0) {
+      const updates = [];
+      const vals = [];
+      if (type !== void 0) {
+        updates.push("type = ?");
+        vals.push(type);
+      }
+      if (metadata !== void 0) {
+        updates.push("metadata = ?");
+        vals.push(JSON.stringify(metadata));
+      }
+      vals.push(blockId);
+      store["stmt"](`UPDATE blocks SET ${updates.join(", ")} WHERE id = ?`).run(...vals);
+    }
+    json(res, 200, { block: store.getBlock(blockId) });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/blocks\/[^\/]+$/) && method === "DELETE") {
+    const blockId = pathname.replace("/api/v1/blocks/", "");
+    const block = store.getBlock(blockId);
+    if (!block) {
+      json(res, 404, { error: "block_not_found" });
+      return true;
+    }
+    const ok = store.deleteBlock(blockId, assistant?.id || "system");
+    json(res, ok ? 200 : 400, { success: ok });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/search.ts
+async function handleSearch(store, pathname, method, res, searchParams) {
+  if (pathname === "/api/v1/search" && method === "GET") {
+    const projectId = resolveProjectId(store, searchParams.get("project_id") || "");
+    const q = (searchParams.get("q") || "").toLowerCase();
+    const limit = parseInt(searchParams.get("limit") || "20", 10);
+    const semantic = searchParams.get("semantic") === "true";
+    if (!q) {
+      json(res, 200, { results: [], count: 0 });
+      return true;
+    }
+    let results = [];
+    if (semantic) {
+      const { embedText: embedText2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+      const queryEmbedding = await embedText2(q);
+      if (queryEmbedding) {
+        results = store.searchHybrid(projectId, q, queryEmbedding, limit);
+      } else {
+        results = store.search(projectId, q, limit);
+      }
+    } else {
+      results = store.search(projectId, q, limit);
+    }
+    json(res, 200, { query: q, semantic, count: results.length, results });
+    return true;
+  }
+  return false;
+}
+
+// src/server/files.ts
+var import_crypto = require("crypto");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+init_config();
+var FILES_DIR = (0, import_path2.resolve)(process.cwd(), CONFIG.storage.files_dir);
+function ensureDir(path) {
+  if (!(0, import_fs2.existsSync)(path)) (0, import_fs2.mkdirSync)(path, { recursive: true });
+}
+function hashPath(hash) {
+  return (0, import_path2.resolve)(FILES_DIR, hash.slice(0, 2), hash.slice(2));
+}
+function computeHash(buffer) {
+  return (0, import_crypto.createHash)("sha256").update(buffer).digest("hex");
+}
+function saveFile(buffer, _fileName) {
+  const hash = computeHash(buffer);
+  const dest = hashPath(hash);
+  if (!(0, import_fs2.existsSync)(dest)) {
+    ensureDir((0, import_path2.dirname)(dest));
+    (0, import_fs2.writeFileSync)(dest, buffer);
+  }
+  return { hash, size: buffer.length, path: dest };
+}
+function getFile(hash) {
+  try {
+    return (0, import_fs2.readFileSync)(hashPath(hash));
+  } catch {
+    return null;
+  }
+}
+
+// src/api/routes/files.ts
+function handleFiles(store, pathname, method, req, res, maxFileSizeMb) {
+  if (pathname === "/api/v1/files/upload" && method === "POST") {
+    const fileName = req.headers["x-file-name"] || "upload";
+    const mimeType = req.headers["content-type"] || "application/octet-stream";
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      const buffer = Buffer.concat(chunks);
+      const maxBytes = maxFileSizeMb * 1024 * 1024;
+      if (buffer.length > maxBytes) {
+        json(res, 413, { error: "file_too_large", max: `${maxFileSizeMb}MB` });
+        return;
+      }
+      const hash = computeHash(buffer);
+      const existing = store.getAttachmentByHash(hash);
+      if (existing) {
+        json(res, 200, { success: true, hash, file_name: existing.file_name, size: existing.file_size, mime_type: existing.mime_type, dedup: true });
+        return;
+      }
+      const saved = saveFile(buffer, fileName);
+      const attachment = store.createAttachment(hash, fileName, saved.size, mimeType);
+      json(res, 200, { success: true, hash, file_name: fileName, size: saved.size, mime_type: mimeType });
+    });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/files\/[^\/]+$/) && method === "GET") {
+    const hash = pathname.replace("/api/v1/files/", "");
+    const data = getFile(hash);
+    if (!data) {
+      json(res, 404, { error: "file_not_found" });
+      return true;
+    }
+    const attachment = store.getAttachmentByHash(hash);
+    const mime = attachment?.mime_type || "application/octet-stream";
+    res.writeHead(200, { "Content-Type": mime, "Content-Length": data.length });
+    res.end(data);
+    return true;
+  }
+  return false;
+}
+
+// src/server/export-format.ts
+var import_adm_zip = __toESM(require("adm-zip"));
+var import_crypto2 = require("crypto");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var DB_PATH = (0, import_path3.resolve)(process.cwd(), "data", "nexus.db");
+var FILES_DIR2 = (0, import_path3.resolve)(process.cwd(), "data", "files");
+function sha256File(path) {
+  return (0, import_crypto2.createHash)("sha256").update((0, import_fs3.readFileSync)(path)).digest("hex");
+}
+function sha256Dir(dir) {
+  const hash = (0, import_crypto2.createHash)("sha256");
+  function walk(p) {
+    const stat = (0, import_fs3.statSync)(p);
+    if (stat.isFile()) {
+      hash.update((0, import_fs3.readFileSync)(p));
+    } else if (stat.isDirectory()) {
+      for (const child of (0, import_fs3.readdirSync)(p).sort()) walk((0, import_path3.resolve)(p, child));
+    }
+  }
+  walk(dir);
+  return hash.digest("hex");
+}
+function buildMnemosyneExport(projectId, projectName) {
+  const zip = new import_adm_zip.default();
+  zip.addLocalFile(DB_PATH, "", "nexus.db");
+  if ((0, import_fs3.existsSync)(FILES_DIR2)) {
+    zip.addLocalFolder(FILES_DIR2, "files");
+  }
+  const dbChecksum = sha256File(DB_PATH);
+  const filesChecksum = (0, import_fs3.existsSync)(FILES_DIR2) ? sha256Dir(FILES_DIR2) : "";
+  const manifest = {
+    version: "1.1",
+    app: "Mnemosyne",
+    exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+    project: projectId ? { id: projectId, name: projectName || "" } : null,
+    checksums: { db: dbChecksum, files: filesChecksum }
+  };
+  zip.addFile("manifest.json", Buffer.from(JSON.stringify(manifest, null, 2)));
+  return zip.toBuffer();
+}
+function parseMnemosyneImport(zipBuffer) {
+  try {
+    const zip = new import_adm_zip.default(zipBuffer);
+    const manifestEntry = zip.getEntry("manifest.json");
+    if (!manifestEntry) return { valid: false, error: "Missing manifest.json" };
+    const manifest = JSON.parse(manifestEntry.getData().toString("utf-8"));
+    if (manifest.version !== "1.0" && manifest.version !== "1.1") return { valid: false, error: `Unsupported version: ${manifest.version}` };
+    if (!zip.getEntry("nexus.db")) return { valid: false, error: "Missing nexus.db" };
+    return { valid: true, manifest };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+// src/api/routes/export-import.ts
+function handleExportImport(store, pathname, method, req, res, body, searchParams, assistant) {
+  if (pathname === "/api/v1/export" && method === "GET") {
+    const format = searchParams.get("format") || "mnemosyne";
+    const projectId = resolveProjectId(store, searchParams.get("project_id") || "");
+    if (format === "markdown") {
+      const md = exportMarkdown(store, projectId);
+      res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Content-Disposition": "attachment; filename=mnemosyne-export.md" });
+      res.end(md);
+      return true;
+    }
+    if (format === "mnemosyne") {
+      const project = projectId ? store.getProject(projectId) : void 0;
+      const zipBuffer = buildMnemosyneExport(projectId, project?.name);
+      res.writeHead(200, {
+        "Content-Type": "application/zip",
+        "Content-Disposition": `attachment; filename="${project?.name || "mnemosyne"}.mnemosyne"`,
+        "Content-Length": zipBuffer.length
+      });
+      res.end(zipBuffer);
+      return true;
+    }
+    if (!assistant || !store.can(assistant.role, "export", "/system")) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const snapshot = store.exportSnapshot();
+    json(res, 200, snapshot);
+    return true;
+  }
+  if (pathname === "/api/v1/import" && method === "POST") {
+    if (!assistant || !store.can(assistant.role, "import", "/system")) {
+      json(res, 403, { error: "permission_denied" });
+      return true;
+    }
+    const format = searchParams.get("format") || "mnemosyne";
+    if (format === "mnemosyne") {
+      const contentType = req.headers["content-type"] || "";
+      if (contentType.includes("application/zip") || contentType.includes("multipart") || contentType.includes("application/octet-stream")) {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+          const buffer = Buffer.concat(chunks);
+          const parsed = parseMnemosyneImport(buffer);
+          if (!parsed.valid) {
+            json(res, 400, { success: false, error: parsed.error });
+            return;
+          }
+          const result = store.importMnemosyneZip(buffer, assistant.id);
+          if (result.success) {
+            json(res, 200, { success: true, atomsRestored: result.atomsRestored });
+          } else {
+            json(res, 400, { success: false, error: result.error });
+          }
+        });
+        return true;
+      }
+      json(res, 400, { success: false, error: "expected_zip_body" });
+      return true;
+    }
+    if (format === "markdown") {
+      const projectId = resolveProjectId(store, searchParams.get("project_id") || "");
+      if (!projectId) {
+        json(res, 400, { error: "project_id_required" });
+        return true;
+      }
+      const md = typeof body === "string" ? body : body.content || "";
+      const title = body.title || void 0;
+      const result = store.importMarkdown(md, projectId, assistant.id, { title });
+      if (result.success) {
+        json(res, 200, { success: true, atomId: result.atomId, bondsCreated: result.bondsCreated });
+      } else {
+        json(res, 400, { success: false, error: result.error });
+      }
+      return true;
+    }
+    json(res, 400, { success: false, error: "unsupported_import_format" });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/events.ts
+function handleEvents(store, pathname, method, res, searchParams) {
+  if (pathname === "/api/v1/events" && method === "GET") {
+    const since = parseInt(searchParams.get("since") || "0", 10);
+    const projectId = searchParams.get("project_id") || void 0;
+    const limit = parseInt(searchParams.get("limit") || "50", 10);
+    json(res, 200, { events: store.getEvents(since, projectId, limit) });
+    return true;
+  }
+  if (pathname.match(/^\/api\/v1\/atoms\/[^\/]+\/events$/) && method === "GET") {
+    const atomId = pathname.replace("/api/v1/atoms/", "").replace("/events", "");
+    const limit = parseInt(searchParams.get("limit") || "50", 10);
+    json(res, 200, { events: store.getEventsByAtom(atomId, limit) });
+    return true;
+  }
+  return false;
+}
+
+// src/api/routes/health.ts
+function handleHealth(store, pathname, method, res) {
+  if (pathname === "/health" && method === "GET") {
+    const stats = store.getStats();
+    json(res, 200, {
+      status: "ok",
+      version: "2.0.0",
+      storage: "sqlite",
+      database: store.config.database.path,
+      uptime: process.uptime(),
+      counts: stats
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/core/types.ts
+var TEMPLATES = {
+  blank: { name: "Blank", blocks: [] },
+  "meeting-notes": { name: "Meeting Notes", blocks: [
+    { type: "Attendees", content: "" },
+    { type: "Agenda", content: "" },
+    { type: "Notes", content: "" },
+    { type: "Action Items", content: "" }
+  ] },
+  "decision-record": { name: "Decision Record", blocks: [
+    { type: "Context", content: "" },
+    { type: "Options", content: "" },
+    { type: "Decision", content: "" },
+    { type: "Consequences", content: "" }
+  ] },
+  "bug-report": { name: "Bug Report", blocks: [
+    { type: "Repro Steps", content: "" },
+    { type: "Expected", content: "" },
+    { type: "Actual", content: "" },
+    { type: "Environment", content: "" }
+  ] },
+  "api-design": { name: "API Design", blocks: [
+    { type: "Endpoint", content: "" },
+    { type: "Request", content: "" },
+    { type: "Response", content: "" },
+    { type: "Auth", content: "" },
+    { type: "Errors", content: "" }
+  ] },
+  persona: { name: "Persona", blocks: [
+    { type: "Name", content: "" },
+    { type: "Role", content: "" },
+    { type: "Goals", content: "" },
+    { type: "Pain Points", content: "" },
+    { type: "Quotes", content: "" }
+  ] },
+  "project-spec": { name: "Project Spec", blocks: [
+    { type: "Overview", content: "" },
+    { type: "Goals", content: "" },
+    { type: "Non-Goals", content: "" },
+    { type: "Timeline", content: "" }
+  ] },
+  "daily-journal": { name: "Daily Journal", blocks: [
+    { type: "Date", content: "" },
+    { type: "Wins", content: "" },
+    { type: "Blockers", content: "" },
+    { type: "Tomorrow", content: "" }
+  ] }
+};
+
+// src/api/routes/tree.ts
+function handleTree(store, pathname, method, res, searchParams) {
+  if (pathname === "/api/v1/tree" && method === "GET") {
+    const projectId = resolveProjectId(store, searchParams.get("project_id") || "");
+    const graph = store.getGraph(projectId);
+    json(res, 200, { project_id: projectId, ...graph });
+    return true;
+  }
+  if (pathname === "/api/v1/templates" && method === "GET") {
+    const templates = Object.entries(TEMPLATES).map(([id, t]) => ({ id, name: t.name }));
+    json(res, 200, { templates });
+    return true;
+  }
+  return false;
+}
+
+// src/api/router.ts
+var ApiRouter = class {
+  store;
+  rateLimiter;
+  mcpServer;
+  mcpTransport;
+  constructor(store) {
+    this.store = store;
+    this.rateLimiter = new RateLimiter(
+      store.config.limits.rate_limit_requests,
+      store.config.limits.rate_limit_window_ms
+    );
+    this.mcpServer = new McpServer(store);
+    this.mcpTransport = new McpSseTransport(this.mcpServer);
+  }
+  async handle(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    const method = req.method || "GET";
+    setCorsHeaders(res);
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      const assistant = authenticate(this.store, req);
+      const token = req.headers.authorization?.replace("Bearer ", "");
+      if (token && !this.rateLimiter.check(token)) {
+        json(res, 429, { error: "rate_limit" });
+        return;
+      }
+      const filesResult = handleFiles(this.store, pathname, method, req, res, this.store.config.storage.max_file_size_mb);
+      if (filesResult === true) return;
+      const body = method !== "GET" && method !== "DELETE" ? await readBody(req) : {};
+      if (pathname === "/mcp/manifest" && method === "GET") {
+        json(res, 200, this.mcpServer.getManifest());
+        return;
+      }
+      if (pathname === "/mcp/sse" && method === "GET") {
+        this.mcpTransport.handleSse(req, res);
+        return;
+      }
+      if (pathname === "/mcp/messages" && method === "POST") {
+        this.mcpTransport.handleMessage(req, res, body);
+        return;
+      }
+      if (handleAssistants(this.store, pathname, method, res, body)) return;
+      if (handleProjects(this.store, pathname, method, res, body, url.searchParams)) return;
+      if (handleAtoms(this.store, pathname, method, res, body, url.searchParams, assistant)) return;
+      if (handleBonds(this.store, pathname, method, res, body)) return;
+      if (handleBlocks(this.store, pathname, method, res, body, assistant)) return;
+      if (await handleSearch(this.store, pathname, method, res, url.searchParams)) return;
+      if (handleExportImport(this.store, pathname, method, req, res, body, url.searchParams, assistant)) return;
+      if (handleEvents(this.store, pathname, method, res, url.searchParams)) return;
+      if (handleTree(this.store, pathname, method, res, url.searchParams)) return;
+      if (handleHealth(this.store, pathname, method, res)) return;
+      json(res, 404, { error: "not_found", path: pathname, method });
+    } catch (err) {
+      json(res, 500, { error: err.message });
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API
+});
+//# sourceMappingURL=api.js.map