claude-launchpad 0.6.1 → 0.7.1

package/dist/commands/memory/server.js

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+import {
+  RetrievalService,
+  getGitContext
+} from "../../chunk-JE3BZ5S4.js";
+import {
+  detectProject
+} from "../../chunk-NAW47BYA.js";
+import {
+  MemoryRepo,
+  RelationRepo,
+  SearchRepo
+} from "../../chunk-TALTTAMW.js";
+import {
+  closeDatabase,
+  createDatabase,
+  loadConfig,
+  migrate,
+  resolveDataDir
+} from "../../chunk-IILH26C7.js";
+import "../../chunk-2H7UOFLK.js";
+
+// src/commands/memory/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/commands/memory/tools/store.ts
+import { z as z2 } from "zod";
+
+// src/commands/memory/types.ts
+import { z } from "zod";
+var MEMORY_TYPES = ["working", "episodic", "semantic", "procedural", "pattern"];
+var MEMORY_SOURCES = ["manual", "session_end", "consolidation", "hook", "import"];
+var RELATION_TYPES = [
+  "relates_to",
+  "depends_on",
+  "contradicts",
+  "extends",
+  "implements",
+  "derived_from"
+];
+var StoreInputSchema = z.object({
+  type: z.enum(MEMORY_TYPES),
+  content: z.string().min(1).max(1e4),
+  title: z.string().max(200).optional(),
+  tags: z.array(z.string()).max(20).default([]),
+  importance: z.number().min(0).max(1).default(0.5),
+  context: z.string().optional(),
+  source: z.enum(MEMORY_SOURCES).default("manual"),
+  project: z.string().max(200).optional()
+});
+var SearchInputSchema = z.object({
+  query: z.string().min(1).max(500),
+  id: z.string().optional(),
+  type: z.enum(MEMORY_TYPES).optional(),
+  tags: z.array(z.string()).max(10).optional(),
+  limit: z.number().int().min(1).max(50).default(10),
+  min_importance: z.number().min(0).max(1).default(0),
+  project: z.string().max(200).optional()
+});
+var ForgetInputSchema = z.object({
+  id: z.string(),
+  hard_delete: z.boolean().default(false)
+});
+var RelateInputSchema = z.object({
+  source_id: z.string(),
+  target_id: z.string(),
+  relation_type: z.enum(RELATION_TYPES)
+});
+
+// src/commands/memory/utils/content-validation.ts
+var SOFT_LENGTH_LIMIT = 1500;
+var HARD_LENGTH_LIMIT = 5e3;
+var CODE_RATIO_THRESHOLD = 0.5;
+function validateMemoryContent(content) {
+  const warnings = [];
+  if (isGitLog(content)) {
+    return { valid: false, reason: "Content looks like raw git log output. Use git log directly \u2014 don't store it as memory.", warnings: [] };
+  }
+  if (isCodeHeavy(content)) {
+    return { valid: false, reason: "Content is >50% code blocks. Code belongs in files, not memory. Store the insight or decision instead.", warnings: [] };
+  }
+  if (content.length > HARD_LENGTH_LIMIT) {
+    return { valid: false, reason: `Content is ${content.length} chars (limit: ${HARD_LENGTH_LIMIT}). Break it into smaller, atomic memories.`, warnings: [] };
+  }
+  if (content.length > SOFT_LENGTH_LIMIT) {
+    warnings.push(`Content is ${content.length} chars. Shorter memories (<${SOFT_LENGTH_LIMIT} chars) are easier to retrieve and less likely to decay.`);
+  }
+  return { valid: true, warnings };
+}
+function isCodeHeavy(content) {
+  const fencedBlockPattern = /```[\s\S]*?```/g;
+  let codeChars = 0;
+  let match;
+  while ((match = fencedBlockPattern.exec(content)) !== null) {
+    codeChars += match[0].length;
+  }
+  return content.length > 0 && codeChars / content.length > CODE_RATIO_THRESHOLD;
+}
+function isGitLog(content) {
+  const lines = content.split("\n");
+  let gitLogLines = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^commit\s+[0-9a-f]{7,40}$/i.test(trimmed)) gitLogLines++;
+    else if (/^Author:\s+.+/i.test(trimmed)) gitLogLines++;
+    else if (/^Date:\s+.+/i.test(trimmed)) gitLogLines++;
+    else if (/^[0-9a-f]{7,12}\s+\S+/i.test(trimmed) && trimmed.length < 200) gitLogLines++;
+  }
+  const nonEmptyLines = lines.filter((l) => l.trim().length > 0).length;
+  return gitLogLines >= 3 && nonEmptyLines > 0 && gitLogLines / nonEmptyLines > 0.3;
+}
+
+// src/commands/memory/utils/contradiction.ts
+var NEGATION_PATTERNS = [
+  /\bnot\b/i,
+  /\bno longer\b/i,
+  /\binstead of\b/i,
+  /\breplaced\b/i,
+  /\bremoved\b/i,
+  /\bdon'?t\b/i,
+  /\bwon'?t\b/i,
+  /\bshouldn'?t\b/i,
+  /\bdeprecated\b/i,
+  /\bdisabled\b/i,
+  /\bstopped\b/i,
+  /\bavoid\b/i,
+  /\bnever\b/i,
+  /\bwithout\b/i
+];
+var KEYWORD_OVERLAP_THRESHOLD = 0.4;
+var MIN_KEYWORD_LENGTH = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "had",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "has",
+  "have",
+  "been",
+  "from",
+  "that",
+  "this",
+  "with",
+  "they",
+  "will",
+  "each",
+  "make",
+  "like",
+  "than",
+  "them",
+  "then",
+  "what",
+  "when",
+  "into",
+  "more",
+  "some",
+  "such",
+  "also",
+  "use",
+  "used",
+  "using",
+  "should",
+  "would",
+  "could",
+  "about",
+  "which",
+  "their",
+  "there",
+  "these",
+  "those",
+  "does",
+  "done",
+  "just",
+  "very"
+]);
+function extractKeywords(text) {
+  const words = text.toLowerCase().match(/[a-z][a-z0-9_-]+/g) ?? [];
+  return new Set(
+    words.filter((w) => w.length >= MIN_KEYWORD_LENGTH && !STOP_WORDS.has(w))
+  );
+}
+function checkContradiction(newContent, existingContent) {
+  const newKeywords = extractKeywords(newContent);
+  const existingKeywords = extractKeywords(existingContent);
+  if (newKeywords.size === 0 || existingKeywords.size === 0) return false;
+  let overlap = 0;
+  for (const kw of newKeywords) {
+    if (existingKeywords.has(kw)) overlap++;
+  }
+  const smallerSize = Math.min(newKeywords.size, existingKeywords.size);
+  const overlapRatio = overlap / smallerSize;
+  if (overlapRatio < KEYWORD_OVERLAP_THRESHOLD) return false;
+  return NEGATION_PATTERNS.some((pattern) => pattern.test(newContent));
+}
+
+// src/commands/memory/tools/store.ts
+var inputSchema = {
+  type: z2.enum(MEMORY_TYPES).describe("Memory type: working, episodic, semantic, procedural, or pattern"),
+  content: z2.string().min(1).max(1e4).describe("The memory content to store"),
+  title: z2.string().max(200).optional().describe("Short title for the memory"),
+  tags: z2.array(z2.string()).max(20).default([]).describe("Tags for categorization. Suggested: #bug, #decision, #gotcha, #howto, #pattern"),
+  importance: z2.number().min(0).max(1).default(0.5).describe("0-0.3 ephemeral, 0.3-0.6 reference, 0.6-0.8 important, 0.8-1.0 critical"),
+  context: z2.string().optional().describe('JSON: {"files": [...], "branch": "...", "intent": "..."}. Auto-detected from git if omitted.'),
+  source: z2.enum(MEMORY_SOURCES).default("manual").describe("How this memory was created"),
+  project: z2.string().max(200).optional().describe("Project scope (auto-detected from CWD if omitted)")
+};
+function registerStore(server, deps) {
+  server.registerTool(
+    "memory_store",
+    {
+      description: "Store a new memory. Use memory_search first to check for duplicates. Prefer updating existing semantic/procedural memories over creating new ones. Types: episodic (events), semantic (facts), procedural (how-to), pattern (recurring), working (temporary). Importance: 0-0.3 ephemeral, 0.3-0.6 reference, 0.6-0.8 important, 0.8-1.0 critical. Suggested tags: #bug, #decision, #gotcha, #howto, #pattern, #architecture. Context is auto-detected from git (branch, recent files) if omitted.",
+      inputSchema,
+      annotations: { idempotentHint: false }
+    },
+    async (args) => {
+      const validation = validateMemoryContent(args.content);
+      if (!validation.valid) {
+        return {
+          content: [{
+            type: "text",
+            text: `Rejected: ${validation.reason}`
+          }],
+          isError: true
+        };
+      }
+      const context = args.context ?? JSON.stringify(getGitContext());
+      const project = args.project ?? deps.project ?? void 0;
+      const contradictions = [];
+      try {
+        const existing = await deps.retrievalService.search({
+          query: args.content.slice(0, 200),
+          limit: 3,
+          min_importance: 0,
+          project
+        });
+        for (const result of existing) {
+          if (result.score > 0.6 && checkContradiction(args.content, result.memory.content)) {
+            contradictions.push({ id: result.memory.id, title: result.memory.title });
+          }
+        }
+      } catch {
+      }
+      const memory = deps.memoryRepo.create(
+        {
+          type: args.type,
+          content: args.content,
+          title: args.title,
+          tags: args.tags,
+          importance: args.importance,
+          context,
+          source: args.source,
+          project
+        },
+        null
+      );
+      for (const c of contradictions) {
+        try {
+          deps.relationRepo.create(memory.id, c.id, "contradicts");
+        } catch {
+        }
+      }
+      const parts = [
+        `Stored memory ${memory.id} (type: ${memory.type}, importance: ${memory.importance})`
+      ];
+      for (const warning of validation.warnings) {
+        parts.push(`Warning: ${warning}`);
+      }
+      for (const c of contradictions) {
+        parts.push(`Warning: potential contradiction with memory ${c.id}${c.title ? ` ("${c.title}")` : ""}. Linked with 'contradicts' relation.`);
+      }
+      return {
+        content: [{
+          type: "text",
+          text: parts.join("\n")
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/search.ts
+import { z as z3 } from "zod";
+var inputSchema2 = {
+  query: z3.string().min(1).max(500).describe("Search query (natural language or keywords)"),
+  id: z3.string().optional().describe("Direct lookup by memory ID (bypasses search)"),
+  type: z3.enum(MEMORY_TYPES).optional().describe("Filter by memory type"),
+  tags: z3.array(z3.string()).max(10).optional().describe("Filter to memories containing ALL of these tags"),
+  limit: z3.number().int().min(1).max(50).default(10).describe("Maximum results to return"),
+  min_importance: z3.number().min(0).max(1).default(0).describe("Minimum importance threshold")
+};
+function registerSearch(server, deps) {
+  server.registerTool(
+    "memory_search",
+    {
+      description: "Search memories by keyword match, context relevance, and relation graph. Returns up to `limit` results ranked by composite score (text match, importance, recency, access frequency, git context). Related memories are automatically surfaced via 1-hop graph expansion. Pass `id` for direct lookup. Use `type` and `tags` to filter.",
+      inputSchema: inputSchema2,
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (args) => {
+      const results = await deps.retrievalService.search({
+        query: args.query,
+        id: args.id,
+        type: args.type,
+        tags: args.tags,
+        limit: args.limit,
+        min_importance: args.min_importance,
+        project: deps.project ?? void 0
+      });
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: "No memories found matching your query." }]
+        };
+      }
+      const formatted = results.map((r, i) => ({
+        rank: i + 1,
+        id: r.memory.id,
+        type: r.memory.type,
+        title: r.memory.title,
+        content: r.memory.content.slice(0, 500),
+        score: Math.round(r.score * 100) / 100,
+        explanation: r.explanation,
+        importance: r.memory.importance,
+        tags: r.memory.tags,
+        accessCount: r.memory.accessCount,
+        createdAt: r.memory.createdAt
+      }));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(formatted, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/forget.ts
+import { z as z4 } from "zod";
+
+// src/commands/memory/utils/errors.ts
+function formatError(err) {
+  return `${err.what}
+Why: ${err.why}
+Fix: ${err.fix}`;
+}
+function formatMcpError(err) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: formatError(err) }]
+  };
+}
+function memoryNotFound(id) {
+  return {
+    what: `Memory "${id}" not found.`,
+    why: "The ID may be incorrect, or the memory was deleted or pruned.",
+    fix: "Use memory_search to find valid IDs."
+  };
+}
+
+// src/commands/memory/tools/forget.ts
+var inputSchema3 = {
+  id: z4.string().describe("ID of the memory to forget"),
+  hard_delete: z4.boolean().default(false).describe("true = permanent delete, false = set importance to 0 (soft delete)")
+};
+function registerForget(server, deps) {
+  server.registerTool(
+    "memory_forget",
+    {
+      description: "Forget a memory. By default, soft-deletes (sets importance to 0, allowing natural decay). Pass hard_delete=true to permanently remove. Use memory_search to find the ID first.",
+      inputSchema: inputSchema3,
+      annotations: { destructiveHint: true, idempotentHint: true }
+    },
+    async (args) => {
+      const memory = deps.memoryRepo.getById(args.id);
+      if (!memory) {
+        return formatMcpError(memoryNotFound(args.id));
+      }
+      if (deps.project && memory.project !== null && memory.project !== deps.project) {
+        return formatMcpError({
+          what: `Memory ${args.id} belongs to project "${memory.project}".`,
+          why: `Current project is "${deps.project}". Cross-project deletion is not allowed.`,
+          fix: "Switch to the correct project or use a global context."
+        });
+      }
+      if (args.hard_delete) {
+        deps.memoryRepo.hardDelete(args.id);
+        return {
+          content: [{
+            type: "text",
+            text: `Permanently deleted memory ${args.id} ("${memory.title ?? memory.content.slice(0, 50)}")`
+          }]
+        };
+      }
+      deps.memoryRepo.softDelete(args.id);
+      return {
+        content: [{
+          type: "text",
+          text: `Soft-deleted memory ${args.id} (importance set to 0, will decay naturally)`
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/relate.ts
+import { z as z5 } from "zod";
+var inputSchema4 = {
+  source_id: z5.string().describe("ID of the source memory"),
+  target_id: z5.string().describe("ID of the target memory"),
+  relation_type: z5.enum(RELATION_TYPES).describe(
+    "Type of relation: relates_to, depends_on, contradicts, extends, implements, derived_from"
+  )
+};
+function registerRelate(server, deps) {
+  server.registerTool(
+    "memory_relate",
+    {
+      description: "Create a typed relation between two memories. Relations affect retrieval ranking (connected memories decay slower). Types: relates_to, depends_on, contradicts, extends, implements, derived_from.",
+      inputSchema: inputSchema4,
+      annotations: { idempotentHint: true }
+    },
+    async (args) => {
+      if (args.source_id === args.target_id) {
+        return formatMcpError({
+          what: "Cannot create self-relation.",
+          why: "source_id and target_id are the same memory.",
+          fix: "Provide two different memory IDs."
+        });
+      }
+      const source = deps.memoryRepo.getById(args.source_id);
+      if (!source) {
+        return formatMcpError(memoryNotFound(args.source_id));
+      }
+      const target = deps.memoryRepo.getById(args.target_id);
+      if (!target) {
+        return formatMcpError(memoryNotFound(args.target_id));
+      }
+      if (deps.project) {
+        for (const mem of [source, target]) {
+          if (mem.project !== null && mem.project !== deps.project) {
+            return formatMcpError({
+              what: `Memory ${mem.id} belongs to project "${mem.project}".`,
+              why: `Current project is "${deps.project}". Cross-project relations are not allowed.`,
+              fix: "Both memories must belong to the same project."
+            });
+          }
+        }
+      }
+      const created = deps.relationRepo.create(args.source_id, args.target_id, args.relation_type);
+      if (!created) {
+        return {
+          content: [{
+            type: "text",
+            text: `Relation already exists: ${args.source_id} --[${args.relation_type}]--> ${args.target_id}`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Created relation: "${source.title ?? source.content.slice(0, 40)}" --[${args.relation_type}]--> "${target.title ?? target.content.slice(0, 40)}"`
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/stats.ts
+import { statSync } from "fs";
+import { join } from "path";
+function registerStats(server, deps) {
+  server.registerTool(
+    "memory_stats",
+    {
+      description: "Show memory dashboard: total count, breakdown by type, storage size, and most-injected memories. No arguments needed.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      const countByType = deps.memoryRepo.countByType();
+      const total = deps.memoryRepo.count();
+      const topInjected = deps.memoryRepo.topInjected(5);
+      const totalRelations = deps.relationRepo.count();
+      let dbSizeBytes = 0;
+      try {
+        const dbPath = join(deps.dataDir, "memory.db");
+        dbSizeBytes = statSync(dbPath).size;
+      } catch {
+      }
+      const { oldest, newest } = deps.memoryRepo.dateRange();
+      const stats = {
+        totalMemories: total,
+        byType: Object.fromEntries(
+          MEMORY_TYPES.map((t) => [t, countByType[t] ?? 0])
+        ),
+        totalRelations,
+        dbSizeBytes,
+        oldestMemory: oldest,
+        newestMemory: newest,
+        topInjected
+      };
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(stats, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/recent.ts
+import { z as z6 } from "zod";
+var inputSchema5 = {
+  limit: z6.number().int().min(1).max(50).default(10).describe("Maximum memories to return"),
+  type: z6.enum(MEMORY_TYPES).optional().describe("Filter by memory type")
+};
+function registerRecent(server, deps) {
+  server.registerTool(
+    "memory_recent",
+    {
+      description: "Load session context: returns context-matched, recent, and related memories. Call this at the start of every session to load context from previous work. Results are grouped into sections: contextMatched (matching current branch/files), recent (most recent), and related (connected via relations).",
+      inputSchema: inputSchema5,
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async (args) => {
+      const results = deps.retrievalService.loadSessionContext({
+        limit: args.limit,
+        project: deps.project ?? void 0,
+        type: args.type
+      });
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: "No memories found for this project." }]
+        };
+      }
+      const formatEntry = (entry, rank) => ({
+        rank,
+        section: entry.section,
+        id: entry.result.memory.id,
+        type: entry.result.memory.type,
+        title: entry.result.memory.title,
+        content: entry.result.memory.content.slice(0, 500),
+        importance: entry.result.memory.importance,
+        tags: entry.result.memory.tags,
+        score: Math.round(entry.result.score * 100) / 100,
+        explanation: entry.result.explanation,
+        createdAt: entry.result.memory.createdAt
+      });
+      const contextMatched = results.filter((r) => r.section === "context").map((r, i) => formatEntry(r, i + 1));
+      const recent = results.filter((r) => r.section === "recent").map((r, i) => formatEntry(r, i + 1));
+      const related = results.filter((r) => r.section === "related").map((r, i) => formatEntry(r, i + 1));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ contextMatched, recent, related }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/update.ts
+import { z as z7 } from "zod";
+var inputSchema6 = {
+  id: z7.string().describe("Memory ID to update (use memory_search to find it)"),
+  title: z7.string().max(200).optional().describe("Updated title"),
+  content: z7.string().min(1).max(1e4).optional().describe("Updated content"),
+  tags: z7.array(z7.string()).max(20).optional().describe("Updated tags"),
+  importance: z7.number().min(0).max(1).optional().describe("Updated importance (0-1)"),
+  context: z7.string().optional().describe("Updated context JSON")
+};
+function registerUpdate(server, deps) {
+  server.registerTool(
+    "memory_update",
+    {
+      description: "Update an existing memory in-place. Preserves access count, injection count, and creation date. Use memory_search to find the ID first. At least one field must be provided.",
+      inputSchema: inputSchema6,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      const hasUpdate = args.title !== void 0 || args.content !== void 0 || args.tags !== void 0 || args.importance !== void 0 || args.context !== void 0;
+      if (!hasUpdate) {
+        return {
+          content: [{ type: "text", text: "No fields to update. Provide at least one of: title, content, tags, importance, context." }],
+          isError: true
+        };
+      }
+      const existing = deps.memoryRepo.getById(args.id);
+      if (!existing) {
+        return {
+          content: [{ type: "text", text: `Memory ${args.id} not found.` }],
+          isError: true
+        };
+      }
+      const updated = deps.memoryRepo.updateContent(args.id, {
+        title: args.title,
+        content: args.content,
+        tags: args.tags,
+        importance: args.importance,
+        context: args.context
+      });
+      if (!updated) {
+        return {
+          content: [{ type: "text", text: `Failed to update memory ${args.id}.` }],
+          isError: true
+        };
+      }
+      const fields = [
+        args.title !== void 0 && "title",
+        args.content !== void 0 && "content",
+        args.tags !== void 0 && "tags",
+        args.importance !== void 0 && "importance",
+        args.context !== void 0 && "context"
+      ].filter(Boolean).join(", ");
+      return {
+        content: [{ type: "text", text: `Updated memory ${args.id} (fields: ${fields})` }]
+      };
+    }
+  );
+}
+
+// src/commands/memory/tools/register.ts
+function registerTools(server, deps) {
+  registerStore(server, deps);
+  registerSearch(server, deps);
+  registerRecent(server, deps);
+  registerForget(server, deps);
+  registerRelate(server, deps);
+  registerStats(server, deps);
+  registerUpdate(server, deps);
+}
+
+// src/commands/memory/server.ts
+async function startServer(deps) {
+  const config = deps?.config ?? loadConfig();
+  const dataDir = resolveDataDir(config.dataDir);
+  const db = createDatabase({ dataDir });
+  migrate(db);
+  const memoryRepo = new MemoryRepo(db);
+  const relationRepo = new RelationRepo(db);
+  const searchRepo = new SearchRepo(db);
+  const retrievalService = new RetrievalService({
+    memoryRepo,
+    relationRepo,
+    searchRepo
+  });
+  const server = new McpServer(
+    { name: "agentic-memory", version: "0.1.0" },
+    {
+      instructions: "Use memory_search before memory_store to check for duplicates. Use memory_update to modify existing memories instead of creating duplicates - it preserves access history. Store memories at the semantic level - capture WHY, not just WHAT happened. Only store knowledge worth remembering across sessions. Memory context is automatically injected at session start via hook - no need to call memory_recent manually."
+    }
+  );
+  const project = detectProject(process.cwd());
+  registerTools(server, { memoryRepo, relationRepo, retrievalService, dataDir, project });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  const shutdown = async () => {
+    await server.close();
+    closeDatabase(db);
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+}
+startServer().catch((err) => {
+  process.stderr.write(`[agentic-memory] ${err}
+`);
+  process.exit(1);
+});
+export {
+  startServer
+};
+//# sourceMappingURL=server.js.map