@gilangjavier/chrona 0.1.0 → 0.1.1

package/dist/chunk-4QI4QC33.js

@@ -0,0 +1,814 @@
+// src/types.ts
+var memoryTypes = ["decision", "preference", "fact", "incident", "constraint"];
+var memoryScopes = ["user", "project", "org", "shared"];
+var sourceKinds = ["tool", "session", "repo"];
+
+// src/utils.ts
+import { randomUUID } from "crypto";
+function toIsoString(value) {
+  const date = value instanceof Date ? value : value ? new Date(value) : /* @__PURE__ */ new Date();
+  const iso = date.toISOString();
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid date: ${String(value)}`);
+  }
+  return iso;
+}
+function uniqueSorted(values) {
+  return [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function normalizeConfidence(value) {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new Error("confidence must be between 0 and 1");
+  }
+  return Number(value.toFixed(6));
+}
+function parseJsonObject(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error("metadata must be an object or JSON object string");
+  }
+  const parsed = JSON.parse(value);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("metadata must be a JSON object");
+  }
+  return parsed;
+}
+function parseCsv(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function ensureId(value) {
+  return value?.trim() || randomUUID();
+}
+function serializeJson(value) {
+  return JSON.stringify(value ?? {});
+}
+
+// src/validate.ts
+function includesValue(values, value, label) {
+  if (!values.includes(value)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return value;
+}
+function parseMemoryType(value) {
+  return includesValue(memoryTypes, value, "type");
+}
+function parseMemoryScope(value) {
+  return includesValue(memoryScopes, value, "scope");
+}
+function parseSourceKind(value) {
+  return includesValue(sourceKinds, value, "source kind");
+}
+function normalizeEntry(input) {
+  if (!input.text.trim()) {
+    throw new Error("text is required");
+  }
+  if (!input.source?.value?.trim()) {
+    throw new Error("source.value is required");
+  }
+  return {
+    id: ensureId(input.id),
+    type: parseMemoryType(input.type),
+    text: input.text.trim(),
+    createdAt: toIsoString(input.createdAt),
+    source: {
+      kind: parseSourceKind(input.source.kind),
+      value: input.source.value.trim()
+    },
+    confidence: normalizeConfidence(input.confidence),
+    scope: parseMemoryScope(input.scope),
+    tags: uniqueSorted(input.tags),
+    expiresAt: input.expiresAt ? toIsoString(input.expiresAt) : void 0,
+    links: uniqueSorted(input.links),
+    metadata: parseJsonObject(input.metadata)
+  };
+}
+
+// src/store.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+var ChromaStore = class {
+  path;
+  db;
+  constructor(path = resolve(process.cwd(), ".chrona/chrona.db")) {
+    this.path = resolve(path);
+    mkdirSync(dirname(this.path), { recursive: true });
+    this.db = new Database(this.path);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.pragma("busy_timeout = 5000");
+  }
+  init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        text TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        source_kind TEXT NOT NULL,
+        source_value TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        scope TEXT NOT NULL,
+        tags_json TEXT NOT NULL,
+        expires_at TEXT,
+        links_json TEXT NOT NULL,
+        metadata_json TEXT NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
+      CREATE INDEX IF NOT EXISTS idx_memories_scope ON memories(scope);
+      CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type);
+      CREATE INDEX IF NOT EXISTS idx_memories_expires_at ON memories(expires_at);
+      CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source_kind, source_value);
+    `);
+  }
+  close() {
+    this.db.close();
+  }
+  add(input) {
+    const entry = normalizeEntry(input);
+    this.init();
+    this.db.prepare(`
+      INSERT INTO memories (
+        id,
+        type,
+        text,
+        created_at,
+        source_kind,
+        source_value,
+        confidence,
+        scope,
+        tags_json,
+        expires_at,
+        links_json,
+        metadata_json
+      ) VALUES (
+        @id,
+        @type,
+        @text,
+        @created_at,
+        @source_kind,
+        @source_value,
+        @confidence,
+        @scope,
+        @tags_json,
+        @expires_at,
+        @links_json,
+        @metadata_json
+      )
+    `).run(this.toRow(entry));
+    return entry;
+  }
+  get(id) {
+    this.init();
+    const row = this.db.prepare("SELECT * FROM memories WHERE id = ?").get(id);
+    return row ? this.fromRow(row) : null;
+  }
+  search(options) {
+    this.init();
+    const { sql, params } = this.buildQuery(
+      options,
+      [
+        "(",
+        "lower(text) LIKE @query",
+        "OR lower(tags_json) LIKE @query",
+        "OR lower(source_kind || ':' || source_value) LIKE @query",
+        "OR lower(metadata_json) LIKE @query",
+        ")"
+      ].join(" "),
+      { query: `%${options.query.toLowerCase()}%` },
+      "ORDER BY created_at DESC, confidence DESC, id ASC"
+    );
+    return this.db.prepare(sql).all(params).map((row) => this.fromRow(row));
+  }
+  timeline(options = {}) {
+    this.init();
+    const direction = options.order === "desc" ? "DESC" : "ASC";
+    const { sql, params } = this.buildQuery(options, void 0, {}, `ORDER BY created_at ${direction}, id ASC`);
+    return this.db.prepare(sql).all(params).map((row) => this.fromRow(row));
+  }
+  exportJsonl(options = {}) {
+    return this.timeline(options).map((entry) => JSON.stringify(entry)).join("\n");
+  }
+  importJsonl(input) {
+    this.init();
+    const lines = input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const ids = [];
+    let imported = 0;
+    let updated = 0;
+    const statement = this.db.prepare(`
+      INSERT INTO memories (
+        id,
+        type,
+        text,
+        created_at,
+        source_kind,
+        source_value,
+        confidence,
+        scope,
+        tags_json,
+        expires_at,
+        links_json,
+        metadata_json
+      ) VALUES (
+        @id,
+        @type,
+        @text,
+        @created_at,
+        @source_kind,
+        @source_value,
+        @confidence,
+        @scope,
+        @tags_json,
+        @expires_at,
+        @links_json,
+        @metadata_json
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        type = excluded.type,
+        text = excluded.text,
+        created_at = excluded.created_at,
+        source_kind = excluded.source_kind,
+        source_value = excluded.source_value,
+        confidence = excluded.confidence,
+        scope = excluded.scope,
+        tags_json = excluded.tags_json,
+        expires_at = excluded.expires_at,
+        links_json = excluded.links_json,
+        metadata_json = excluded.metadata_json
+    `);
+    const transaction = this.db.transaction(() => {
+      for (const line of lines) {
+        const entry = normalizeEntry(JSON.parse(line));
+        const exists = this.get(entry.id);
+        statement.run(this.toRow(entry));
+        ids.push(entry.id);
+        if (exists) {
+          updated += 1;
+        } else {
+          imported += 1;
+        }
+      }
+    });
+    transaction();
+    return {
+      imported,
+      updated,
+      ids: [...ids].sort((a, b) => a.localeCompare(b))
+    };
+  }
+  gc(now) {
+    this.init();
+    const nowIso = toIsoString(now);
+    const rows = this.db.prepare(
+      "SELECT id FROM memories WHERE expires_at IS NOT NULL AND expires_at <= ? ORDER BY expires_at ASC, id ASC"
+    ).all(nowIso);
+    const ids = rows.map((row) => row.id);
+    if (ids.length > 0) {
+      this.db.prepare("DELETE FROM memories WHERE expires_at IS NOT NULL AND expires_at <= ?").run(nowIso);
+    }
+    return {
+      deleted: ids.length,
+      ids,
+      now: nowIso
+    };
+  }
+  buildQuery(options, extraWhere, extraParams = {}, orderBy = "ORDER BY created_at ASC, id ASC") {
+    const where = [];
+    const params = { ...extraParams };
+    if (!options.includeExpired) {
+      where.push("(expires_at IS NULL OR expires_at > @now)");
+      params.now = toIsoString();
+    }
+    if (options.scopes?.length) {
+      const placeholders = options.scopes.map((_, index) => `@scope${index}`);
+      where.push(`scope IN (${placeholders.join(", ")})`);
+      for (const [index, scope] of options.scopes.entries()) {
+        params[`scope${index}`] = scope;
+      }
+    }
+    if (options.types?.length) {
+      const placeholders = options.types.map((_, index) => `@type${index}`);
+      where.push(`type IN (${placeholders.join(", ")})`);
+      for (const [index, type] of options.types.entries()) {
+        params[`type${index}`] = type;
+      }
+    }
+    if (options.tags?.length) {
+      const tagParts = [];
+      for (const [index, tag] of options.tags.entries()) {
+        const key = `tag${index}`;
+        tagParts.push(`lower(tags_json) LIKE @${key}`);
+        params[key] = `%${tag.toLowerCase()}%`;
+      }
+      where.push(`(${tagParts.join(" OR ")})`);
+    }
+    if (options.sourceKind) {
+      where.push("source_kind = @sourceKind");
+      params.sourceKind = options.sourceKind;
+    }
+    if (options.sourceValue) {
+      where.push("source_value = @sourceValue");
+      params.sourceValue = options.sourceValue;
+    }
+    if (options.before) {
+      where.push("created_at <= @before");
+      params.before = toIsoString(options.before);
+    }
+    if (options.after) {
+      where.push("created_at >= @after");
+      params.after = toIsoString(options.after);
+    }
+    if (extraWhere) {
+      where.push(extraWhere);
+    }
+    const limit = Math.max(1, Math.min(options.limit ?? 50, 1e3));
+    params.limit = limit;
+    const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+    return {
+      sql: `SELECT * FROM memories ${whereSql} ${orderBy} LIMIT @limit`,
+      params
+    };
+  }
+  toRow(entry) {
+    return {
+      id: entry.id,
+      type: entry.type,
+      text: entry.text,
+      created_at: entry.createdAt,
+      source_kind: entry.source.kind,
+      source_value: entry.source.value,
+      confidence: entry.confidence,
+      scope: entry.scope,
+      tags_json: serializeJson(entry.tags),
+      expires_at: entry.expiresAt ?? null,
+      links_json: serializeJson(entry.links ?? []),
+      metadata_json: serializeJson(entry.metadata ?? {})
+    };
+  }
+  fromRow(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      text: row.text,
+      createdAt: row.created_at,
+      source: {
+        kind: row.source_kind,
+        value: row.source_value
+      },
+      confidence: row.confidence,
+      scope: row.scope,
+      tags: JSON.parse(row.tags_json),
+      expiresAt: row.expires_at ?? void 0,
+      links: JSON.parse(row.links_json),
+      metadata: JSON.parse(row.metadata_json)
+    };
+  }
+};
+
+// src/mcp.ts
+import { createServer } from "http";
+import { resolve as resolve2 } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import * as z from "zod/v4";
+var memoryTypeSchema = z.enum(memoryTypes);
+var memoryScopeSchema = z.enum(memoryScopes);
+var sourceKindSchema = z.enum(sourceKinds);
+var jsonValueSchema = z.json();
+var jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+var sourceSchema = z.object({
+  kind: sourceKindSchema,
+  value: z.string().trim().min(1)
+});
+var memoryEntrySchema = z.object({
+  id: z.string(),
+  type: memoryTypeSchema,
+  text: z.string(),
+  createdAt: z.string(),
+  source: sourceSchema,
+  confidence: z.number(),
+  scope: memoryScopeSchema,
+  tags: z.array(z.string()),
+  expiresAt: z.string().optional(),
+  links: z.array(z.string()),
+  metadata: jsonObjectSchema
+});
+var queryOptionsSchema = z.object({
+  scopes: z.array(memoryScopeSchema).optional(),
+  types: z.array(memoryTypeSchema).optional(),
+  tags: z.array(z.string()).optional(),
+  sourceKind: sourceKindSchema.optional(),
+  sourceValue: z.string().trim().min(1).optional(),
+  before: z.string().optional(),
+  after: z.string().optional(),
+  includeExpired: z.boolean().default(false)
+});
+var chronaAddInputSchema = z.object({
+  id: z.string().trim().min(1).optional(),
+  type: memoryTypeSchema,
+  text: z.string().trim().min(1),
+  createdAt: z.string().optional(),
+  source: sourceSchema,
+  confidence: z.number().min(0).max(1),
+  scope: memoryScopeSchema,
+  tags: z.array(z.string()).default([]),
+  expiresAt: z.string().optional(),
+  links: z.array(z.string()).default([]),
+  metadata: jsonObjectSchema.default({})
+});
+var chronaAddResultSchema = z.object({
+  entry: memoryEntrySchema
+});
+var chronaGetInputSchema = z.object({
+  id: z.string().trim().min(1)
+});
+var chronaGetResultSchema = z.object({
+  entry: memoryEntrySchema.nullable()
+});
+var chronaSearchInputSchema = queryOptionsSchema.extend({
+  query: z.string().trim().min(1),
+  limit: z.number().int().min(1).max(1e3).default(50)
+});
+var chronaSearchResultSchema = z.object({
+  count: z.number().int().min(0),
+  items: z.array(memoryEntrySchema)
+});
+var chronaTimelineInputSchema = queryOptionsSchema.extend({
+  order: z.enum(["asc", "desc"]).default("asc"),
+  limit: z.number().int().min(1).max(1e3).default(50)
+});
+var chronaTimelineResultSchema = z.object({
+  count: z.number().int().min(0),
+  items: z.array(memoryEntrySchema)
+});
+var chronaExportInputSchema = queryOptionsSchema.extend({
+  order: z.enum(["asc", "desc"]).default("asc"),
+  limit: z.number().int().min(1).max(1e3).default(1e3)
+});
+var chronaExportResultSchema = z.object({
+  count: z.number().int().min(0),
+  jsonl: z.string()
+});
+var chronaImportInputSchema = z.object({
+  jsonl: z.string()
+});
+var chronaImportResultSchema = z.object({
+  imported: z.number().int().min(0),
+  updated: z.number().int().min(0),
+  ids: z.array(z.string())
+});
+var chronaGcInputSchema = z.object({
+  now: z.string().optional()
+});
+var chronaGcResultSchema = z.object({
+  deleted: z.number().int().min(0),
+  ids: z.array(z.string()),
+  now: z.string()
+});
+function withStore(dbPath, run) {
+  const store = new ChromaStore(dbPath);
+  try {
+    return run(store);
+  } finally {
+    store.close();
+  }
+}
+function toQueryOptions(input) {
+  return {
+    scopes: input.scopes,
+    types: input.types,
+    tags: input.tags,
+    sourceKind: input.sourceKind,
+    sourceValue: input.sourceValue,
+    before: input.before,
+    after: input.after,
+    includeExpired: input.includeExpired,
+    limit: input.limit
+  };
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJsonValue);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, innerValue]) => [key, sortJsonValue(innerValue)])
+    );
+  }
+  return value;
+}
+function toOutputEntry(entry) {
+  const base = {
+    id: entry.id,
+    type: entry.type,
+    text: entry.text,
+    createdAt: entry.createdAt,
+    source: {
+      kind: entry.source.kind,
+      value: entry.source.value
+    },
+    confidence: entry.confidence,
+    scope: entry.scope,
+    tags: [...entry.tags],
+    links: [...entry.links ?? []],
+    metadata: sortJsonValue(entry.metadata ?? {})
+  };
+  if (entry.expiresAt) {
+    return {
+      ...base,
+      expiresAt: entry.expiresAt
+    };
+  }
+  return base;
+}
+function toToolResult(value) {
+  const stableValue = sortJsonValue(value);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(stableValue, null, 2)
+      }
+    ],
+    structuredContent: stableValue
+  };
+}
+function lineCount(value) {
+  return value === "" ? 0 : value.split("\n").length;
+}
+function createChronaMcpHandlers(dbPath) {
+  const resolvedDbPath = resolve2(dbPath);
+  return {
+    add(input) {
+      const args = chronaAddInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => {
+        const entry = store.add({
+          id: args.id,
+          type: args.type,
+          text: args.text,
+          createdAt: args.createdAt,
+          source: args.source,
+          confidence: args.confidence,
+          scope: args.scope,
+          tags: args.tags,
+          expiresAt: args.expiresAt,
+          links: args.links,
+          metadata: args.metadata
+        });
+        return {
+          entry: toOutputEntry(entry)
+        };
+      });
+    },
+    get(input) {
+      const args = chronaGetInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => {
+        const entry = store.get(args.id);
+        return {
+          entry: entry ? toOutputEntry(entry) : null
+        };
+      });
+    },
+    search(input) {
+      const args = chronaSearchInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => {
+        const items = store.search({
+          ...toQueryOptions(args),
+          query: args.query
+        }).map(toOutputEntry);
+        return {
+          count: items.length,
+          items
+        };
+      });
+    },
+    timeline(input) {
+      const args = chronaTimelineInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => {
+        const items = store.timeline({
+          ...toQueryOptions(args),
+          order: args.order
+        }).map(toOutputEntry);
+        return {
+          count: items.length,
+          items
+        };
+      });
+    },
+    export(input) {
+      const args = chronaExportInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => {
+        const jsonl = store.exportJsonl({
+          ...toQueryOptions(args),
+          order: args.order
+        });
+        return {
+          count: lineCount(jsonl),
+          jsonl
+        };
+      });
+    },
+    import(input) {
+      const args = chronaImportInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => store.importJsonl(args.jsonl));
+    },
+    gc(input = {}) {
+      const args = chronaGcInputSchema.parse(input);
+      return withStore(resolvedDbPath, (store) => store.gc(args.now));
+    }
+  };
+}
+function createChronaMcpServer(dbPath) {
+  const handlers = createChronaMcpHandlers(dbPath);
+  const server = new McpServer({
+    name: "chrona",
+    version: "0.1.1"
+  });
+  server.registerTool(
+    "chrona_add",
+    {
+      description: "Add a memory entry to Chrona.",
+      inputSchema: chronaAddInputSchema,
+      outputSchema: chronaAddResultSchema
+    },
+    async (input) => toToolResult(handlers.add(input))
+  );
+  server.registerTool(
+    "chrona_get",
+    {
+      description: "Get a memory entry by id.",
+      inputSchema: chronaGetInputSchema,
+      outputSchema: chronaGetResultSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (input) => toToolResult(handlers.get(input))
+  );
+  server.registerTool(
+    "chrona_search",
+    {
+      description: "Search memory entries with deterministic ordering.",
+      inputSchema: chronaSearchInputSchema,
+      outputSchema: chronaSearchResultSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (input) => toToolResult(handlers.search(input))
+  );
+  server.registerTool(
+    "chrona_timeline",
+    {
+      description: "List memory entries in time order.",
+      inputSchema: chronaTimelineInputSchema,
+      outputSchema: chronaTimelineResultSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (input) => toToolResult(handlers.timeline(input))
+  );
+  server.registerTool(
+    "chrona_export",
+    {
+      description: "Export matching entries as deterministic JSONL.",
+      inputSchema: chronaExportInputSchema,
+      outputSchema: chronaExportResultSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (input) => toToolResult(handlers.export(input))
+  );
+  server.registerTool(
+    "chrona_import",
+    {
+      description: "Import entries from JSONL.",
+      inputSchema: chronaImportInputSchema,
+      outputSchema: chronaImportResultSchema
+    },
+    async (input) => toToolResult(handlers.import(input))
+  );
+  server.registerTool(
+    "chrona_gc",
+    {
+      description: "Delete expired memory entries.",
+      inputSchema: chronaGcInputSchema,
+      outputSchema: chronaGcResultSchema
+    },
+    async (input) => toToolResult(handlers.gc(input))
+  );
+  return server;
+}
+async function readRequestBody(request) {
+  const chunks = [];
+  for await (const chunk of request) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const body = Buffer.concat(chunks).toString("utf8").trim();
+  return body === "" ? void 0 : JSON.parse(body);
+}
+function sendHttpJson(response, statusCode, payload) {
+  response.statusCode = statusCode;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(payload));
+}
+function createChronaMcpHttpServer(dbPath, port) {
+  return createServer(async (request, response) => {
+    const requestUrl = new URL(request.url ?? "/", `http://${request.headers.host ?? `127.0.0.1:${port}`}`);
+    if (requestUrl.pathname !== "/mcp") {
+      sendHttpJson(response, 404, {
+        error: {
+          code: 404,
+          message: "Not found"
+        }
+      });
+      return;
+    }
+    if (request.method !== "POST") {
+      sendHttpJson(response, 405, {
+        error: {
+          code: 405,
+          message: "Method not allowed"
+        }
+      });
+      return;
+    }
+    const server = createChronaMcpServer(dbPath);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: void 0
+    });
+    response.on("close", () => {
+      transport.close().catch(() => void 0);
+      server.close().catch(() => void 0);
+    });
+    try {
+      const parsedBody = await readRequestBody(request);
+      await server.connect(transport);
+      await transport.handleRequest(request, response, parsedBody);
+    } catch (error) {
+      if (!response.headersSent) {
+        sendHttpJson(response, 500, {
+          error: {
+            code: 500,
+            message: error instanceof Error ? error.message : String(error)
+          }
+        });
+      }
+    }
+  });
+}
+async function startChronaMcpServer(options) {
+  const resolvedDbPath = resolve2(options.dbPath);
+  if (options.port !== void 0) {
+    const server2 = createChronaMcpHttpServer(resolvedDbPath, options.port);
+    await new Promise((resolvePromise, reject) => {
+      server2.once("error", reject);
+      server2.listen(options.port, "127.0.0.1", () => {
+        server2.off("error", reject);
+        console.error(`Chrona MCP server listening on http://127.0.0.1:${options.port}/mcp`);
+        resolvePromise();
+      });
+    });
+    return;
+  }
+  const server = createChronaMcpServer(resolvedDbPath);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export {
+  memoryTypes,
+  memoryScopes,
+  sourceKinds,
+  toIsoString,
+  parseJsonObject,
+  parseCsv,
+  parseMemoryType,
+  parseMemoryScope,
+  parseSourceKind,
+  normalizeEntry,
+  ChromaStore,
+  chronaAddInputSchema,
+  chronaAddResultSchema,
+  chronaGetInputSchema,
+  chronaGetResultSchema,
+  chronaSearchInputSchema,
+  chronaSearchResultSchema,
+  chronaTimelineInputSchema,
+  chronaTimelineResultSchema,
+  chronaExportInputSchema,
+  chronaExportResultSchema,
+  chronaImportInputSchema,
+  chronaImportResultSchema,
+  chronaGcInputSchema,
+  chronaGcResultSchema,
+  createChronaMcpHandlers,
+  createChronaMcpServer,
+  startChronaMcpServer
+};
+//# sourceMappingURL=chunk-4QI4QC33.js.map