codemem 0.1.0 → 0.20.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1076 @@
+#!/usr/bin/env node
+import { MemoryStore, ObserverClient, RawEventSweeper, VERSION, buildRawEventEnvelopeFromHook, connect, ensureDeviceIdentity, exportMemories, getRawEventStatus, importMemories, initDatabase, loadSqliteVec, rawEventsGate, readCodememConfigFile, readImportPayload, resolveDbPath, resolveProject, retryRawEventFailures, runSyncDaemon, schema, stripJsonComments, stripPrivateObj, stripTrailingCommas, vacuumDatabase, writeCodememConfigFile } from "@codemem/core";
+import { Command } from "commander";
+import omelette from "omelette";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { styleText } from "node:util";
+import * as p from "@clack/prompts";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { desc } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+//#region src/help-style.ts
+/**
+* Shared Commander help style configuration.
+*
+* Applied to every Command instance so subcommand --help
+* output gets the same colors as the root.
+*/
+var helpStyle = {
+	styleTitle: (str) => styleText("bold", str),
+	styleCommandText: (str) => styleText("cyan", str),
+	styleCommandDescription: (str) => str,
+	styleDescriptionText: (str) => styleText("dim", str),
+	styleOptionText: (str) => styleText("green", str),
+	styleOptionTerm: (str) => styleText("green", str),
+	styleSubcommandText: (str) => styleText("cyan", str),
+	styleArgumentText: (str) => styleText("yellow", str)
+};
+//#endregion
+//#region src/commands/claude-hook-ingest.ts
+/**
+* codemem claude-hook-ingest — read a single Claude Code hook payload
+* from stdin and enqueue it for processing.
+*
+* Ports codemem/commands/claude_hook_runtime_cmds.py with an HTTP-first
+* strategy: try POST /api/claude-hooks (viewer must be running), then
+* fall back to direct raw-event enqueue via the local store.
+*
+* Usage (from Claude hooks config):
+*   echo '{"hook_event_name":"Stop","session_id":"...","last_assistant_message":"..."}' \
+*     | codemem claude-hook-ingest
+*/
+/** Try to POST the hook payload to the running viewer server. */
+async function tryHttpIngest(payload, host, port) {
+	const url = `http://${host}:${port}/api/claude-hooks`;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 5e3);
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: controller.signal
+		});
+		if (!res.ok) return {
+			ok: false,
+			inserted: 0,
+			skipped: 0
+		};
+		const body = await res.json();
+		return {
+			ok: true,
+			inserted: Number(body.inserted ?? 0),
+			skipped: Number(body.skipped ?? 0)
+		};
+	} catch {
+		return {
+			ok: false,
+			inserted: 0,
+			skipped: 0
+		};
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+/** Fall back to direct raw-event enqueue via the local SQLite store. */
+function directEnqueue(payload, dbPath) {
+	const envelope = buildRawEventEnvelopeFromHook(payload);
+	if (!envelope) return {
+		inserted: 0,
+		skipped: 1
+	};
+	const db = connect(dbPath);
+	try {
+		try {
+			loadSqliteVec(db);
+		} catch {}
+		const strippedPayload = stripPrivateObj(envelope.payload);
+		if (db.prepare("SELECT 1 FROM raw_events WHERE source = ? AND stream_id = ? AND event_id = ? LIMIT 1").get(envelope.source, envelope.session_stream_id, envelope.event_id)) return {
+			inserted: 0,
+			skipped: 0
+		};
+		db.prepare(`INSERT INTO raw_events(
+				source, stream_id, opencode_session_id, event_id, event_seq,
+				event_type, ts_wall_ms, payload_json, created_at
+			) VALUES (?, ?, ?, ?, (
+				SELECT COALESCE(MAX(event_seq), 0) + 1
+				FROM raw_events WHERE source = ? AND stream_id = ?
+			), ?, ?, ?, datetime('now'))`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.event_id, envelope.source, envelope.session_stream_id, "claude.hook", envelope.ts_wall_ms, JSON.stringify(strippedPayload));
+		const currentMaxSeq = db.prepare("SELECT COALESCE(MAX(event_seq), 0) AS max_seq FROM raw_events WHERE source = ? AND stream_id = ?").get(envelope.source, envelope.session_stream_id).max_seq;
+		db.prepare(`INSERT INTO raw_event_sessions(
+				source, stream_id, opencode_session_id, cwd, project, started_at,
+				last_seen_ts_wall_ms, last_received_event_seq, last_flushed_event_seq, updated_at
+			) VALUES (?, ?, ?, ?, ?, ?, ?, ?, -1, datetime('now'))
+			ON CONFLICT(source, stream_id) DO UPDATE SET
+				cwd = COALESCE(excluded.cwd, cwd),
+				project = COALESCE(excluded.project, project),
+				started_at = COALESCE(excluded.started_at, started_at),
+				last_seen_ts_wall_ms = MAX(COALESCE(excluded.last_seen_ts_wall_ms, 0), COALESCE(last_seen_ts_wall_ms, 0)),
+				last_received_event_seq = MAX(excluded.last_received_event_seq, last_received_event_seq),
+				updated_at = datetime('now')`).run(envelope.source, envelope.session_stream_id, envelope.opencode_session_id, envelope.cwd, envelope.project, envelope.started_at, envelope.ts_wall_ms, currentMaxSeq);
+		return {
+			inserted: 1,
+			skipped: 0
+		};
+	} finally {
+		db.close();
+	}
+}
+var claudeHookIngestCommand = new Command("claude-hook-ingest").configureHelp(helpStyle).description("Ingest a Claude Code hook payload from stdin").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--host <host>", "viewer server host", "127.0.0.1").option("--port <port>", "viewer server port", "38888").action(async (opts) => {
+	let raw;
+	try {
+		raw = readFileSync(0, "utf8").trim();
+	} catch {
+		process.exitCode = 1;
+		return;
+	}
+	if (!raw) {
+		process.exitCode = 1;
+		return;
+	}
+	let payload;
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+			process.exitCode = 1;
+			return;
+		}
+		payload = parsed;
+	} catch {
+		process.exitCode = 1;
+		return;
+	}
+	const port = Number.parseInt(opts.port, 10);
+	const host = opts.host;
+	const httpResult = await tryHttpIngest(payload, host, port);
+	if (httpResult.ok) {
+		console.log(JSON.stringify({
+			inserted: httpResult.inserted,
+			skipped: httpResult.skipped,
+			via: "http"
+		}));
+		return;
+	}
+	try {
+		const dbPath = resolveDbPath(opts.db);
+		const directResult = directEnqueue(payload, dbPath);
+		console.log(JSON.stringify({
+			...directResult,
+			via: "direct"
+		}));
+	} catch {
+		process.exitCode = 1;
+	}
+});
+//#endregion
+//#region src/commands/db.ts
+var dbCommand = new Command("db").configureHelp(helpStyle).description("Database maintenance");
+dbCommand.addCommand(new Command("init").configureHelp(helpStyle).description("Verify the SQLite database is present and schema-ready").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").action((opts) => {
+	const result = initDatabase(opts.db);
+	p.intro("codemem db init");
+	p.log.success(`Database ready: ${result.path}`);
+	p.outro(`Size: ${result.sizeBytes.toLocaleString()} bytes`);
+})).addCommand(new Command("vacuum").configureHelp(helpStyle).description("Run VACUUM on the SQLite database").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").action((opts) => {
+	const result = vacuumDatabase(opts.db);
+	p.intro("codemem db vacuum");
+	p.log.success(`Vacuumed: ${result.path}`);
+	p.outro(`Size: ${result.sizeBytes.toLocaleString()} bytes`);
+})).addCommand(new Command("raw-events-status").configureHelp(helpStyle).description("Show pending raw-event backlog by source stream").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("-n, --limit <n>", "max rows to show", "25").option("--json", "output as JSON").action((opts) => {
+	const result = getRawEventStatus(opts.db, Number.parseInt(opts.limit, 10) || 25);
+	if (opts.json) {
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+	p.intro("codemem db raw-events-status");
+	p.log.info(`Totals: ${result.totals.pending.toLocaleString()} pending across ${result.totals.sessions.toLocaleString()} session(s)`);
+	if (result.items.length === 0) {
+		p.outro("No pending raw events");
+		return;
+	}
+	for (const item of result.items) p.log.message(`${item.source}:${item.stream_id} pending=${Math.max(0, item.last_received_event_seq - item.last_flushed_event_seq)} received=${item.last_received_event_seq} flushed=${item.last_flushed_event_seq} project=${item.project ?? ""}`);
+	p.outro("done");
+})).addCommand(new Command("raw-events-retry").configureHelp(helpStyle).description("Requeue failed raw-event flush batches").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("-n, --limit <n>", "max failed batches to requeue", "25").action((opts) => {
+	const result = retryRawEventFailures(opts.db, Number.parseInt(opts.limit, 10) || 25);
+	p.intro("codemem db raw-events-retry");
+	p.outro(`Requeued ${result.retried.toLocaleString()} failed batch(es)`);
+})).addCommand(new Command("raw-events-gate").configureHelp(helpStyle).description("Validate raw-event reliability thresholds (non-zero exit on failure)").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--min-flush-success-rate <rate>", "minimum flush success rate", "0.95").option("--max-dropped-event-rate <rate>", "maximum dropped event rate", "0.05").option("--min-session-boundary-accuracy <rate>", "minimum session boundary accuracy", "0.9").option("--window-hours <hours>", "lookback window in hours", "24").option("--json", "output as JSON").action((opts) => {
+	const result = rawEventsGate(opts.db, {
+		minFlushSuccessRate: Number.parseFloat(opts.minFlushSuccessRate),
+		maxDroppedEventRate: Number.parseFloat(opts.maxDroppedEventRate),
+		minSessionBoundaryAccuracy: Number.parseFloat(opts.minSessionBoundaryAccuracy),
+		windowHours: Number.parseFloat(opts.windowHours)
+	});
+	if (opts.json) {
+		console.log(JSON.stringify(result, null, 2));
+		if (!result.passed) process.exitCode = 1;
+		return;
+	}
+	p.intro("codemem db raw-events-gate");
+	p.log.info([
+		`flush_success_rate:          ${result.metrics.rates.flush_success_rate.toFixed(4)}`,
+		`dropped_event_rate:          ${result.metrics.rates.dropped_event_rate.toFixed(4)}`,
+		`session_boundary_accuracy:   ${result.metrics.rates.session_boundary_accuracy.toFixed(4)}`,
+		`window_hours:                ${result.metrics.window_hours ?? "all"}`
+	].join("\n"));
+	if (result.passed) p.outro("reliability gate passed");
+	else {
+		for (const f of result.failures) p.log.error(f);
+		p.outro("reliability gate FAILED");
+		process.exitCode = 1;
+	}
+}));
+//#endregion
+//#region src/commands/enqueue-raw-event.ts
+var SESSION_ID_KEYS = [
+	"session_stream_id",
+	"session_id",
+	"stream_id",
+	"opencode_session_id"
+];
+function resolveSessionStreamId(payload) {
+	const values = /* @__PURE__ */ new Map();
+	for (const key of SESSION_ID_KEYS) {
+		const value = payload[key];
+		if (typeof value !== "string") continue;
+		const text = value.trim();
+		if (text) values.set(key, text);
+	}
+	if (values.size === 0) return null;
+	if (new Set(values.values()).size > 1) throw new Error("conflicting session id fields");
+	for (const key of SESSION_ID_KEYS) {
+		const value = values.get(key);
+		if (value) return value;
+	}
+	return null;
+}
+async function readStdinJson() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+	const raw = Buffer.concat(chunks).toString("utf-8").trim();
+	if (!raw) throw new Error("stdin JSON required");
+	const parsed = JSON.parse(raw);
+	if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("payload must be an object");
+	return parsed;
+}
+var enqueueRawEventCommand = new Command("enqueue-raw-event").configureHelp(helpStyle).description("Enqueue one raw event from stdin into the durable queue").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").action(async (opts) => {
+	const payload = await readStdinJson();
+	const sessionId = resolveSessionStreamId(payload);
+	if (!sessionId) throw new Error("session id required");
+	if (sessionId.startsWith("msg_")) throw new Error("invalid session id");
+	const eventType = typeof payload.event_type === "string" ? payload.event_type.trim() : "";
+	if (!eventType) throw new Error("event_type required");
+	const cwd = typeof payload.cwd === "string" ? payload.cwd : null;
+	const project = typeof payload.project === "string" ? payload.project : null;
+	const startedAt = typeof payload.started_at === "string" ? payload.started_at : null;
+	const tsWallMs = Number.isFinite(Number(payload.ts_wall_ms)) ? Math.floor(Number(payload.ts_wall_ms)) : null;
+	const tsMonoMs = Number.isFinite(Number(payload.ts_mono_ms)) ? Number(payload.ts_mono_ms) : null;
+	const eventId = typeof payload.event_id === "string" ? payload.event_id.trim() : "";
+	const eventPayload = payload.payload && typeof payload.payload === "object" && !Array.isArray(payload.payload) ? stripPrivateObj(payload.payload) : {};
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		store.updateRawEventSessionMeta({
+			opencodeSessionId: sessionId,
+			source: "opencode",
+			cwd,
+			project,
+			startedAt,
+			lastSeenTsWallMs: tsWallMs
+		});
+		store.recordRawEventsBatch(sessionId, [{
+			event_id: eventId,
+			event_type: eventType,
+			payload: eventPayload,
+			ts_wall_ms: tsWallMs,
+			ts_mono_ms: tsMonoMs
+		}]);
+	} finally {
+		store.close();
+	}
+});
+//#endregion
+//#region src/commands/export-memories.ts
+function expandUserPath(value) {
+	return value.startsWith("~/") ? join(homedir(), value.slice(2)) : value;
+}
+var exportMemoriesCommand = new Command("export-memories").configureHelp(helpStyle).description("Export memories to a JSON file for sharing or backup").argument("<output>", "output file path (use '-' for stdout)").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--project <project>", "filter by project (defaults to git repo root)").option("--all-projects", "export all projects").option("--include-inactive", "include deactivated memories").option("--since <iso>", "only export memories created after this ISO timestamp").action((output, opts) => {
+	const payload = exportMemories({
+		dbPath: resolveDbPath(opts.db),
+		project: opts.project,
+		allProjects: opts.allProjects,
+		includeInactive: opts.includeInactive,
+		since: opts.since
+	});
+	const text = `${JSON.stringify(payload, null, 2)}\n`;
+	if (output === "-") {
+		process.stdout.write(text);
+		return;
+	}
+	const outputPath = expandUserPath(output);
+	writeFileSync(outputPath, text, "utf8");
+	p.intro("codemem export-memories");
+	p.log.success([
+		`Output:    ${outputPath}`,
+		`Sessions:  ${payload.sessions.length.toLocaleString()}`,
+		`Memories:  ${payload.memory_items.length.toLocaleString()}`,
+		`Summaries: ${payload.session_summaries.length.toLocaleString()}`,
+		`Prompts:   ${payload.user_prompts.length.toLocaleString()}`
+	].join("\n"));
+	p.outro("done");
+});
+//#endregion
+//#region src/commands/import-memories.ts
+var importMemoriesCommand = new Command("import-memories").configureHelp(helpStyle).description("Import memories from an exported JSON file").argument("<inputFile>", "input JSON file (use '-' for stdin)").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--remap-project <path>", "remap all projects to this path on import").option("--dry-run", "preview import without writing").action((inputFile, opts) => {
+	let payload;
+	try {
+		payload = readImportPayload(inputFile);
+	} catch (error) {
+		p.log.error(error instanceof Error ? error.message : "Invalid import file");
+		process.exitCode = 1;
+		return;
+	}
+	p.intro("codemem import-memories");
+	p.log.info([
+		`Export version: ${payload.version}`,
+		`Exported at:    ${payload.exported_at}`,
+		`Sessions:       ${payload.sessions.length.toLocaleString()}`,
+		`Memories:       ${payload.memory_items.length.toLocaleString()}`,
+		`Summaries:      ${payload.session_summaries.length.toLocaleString()}`,
+		`Prompts:        ${payload.user_prompts.length.toLocaleString()}`
+	].join("\n"));
+	const result = importMemories(payload, {
+		dbPath: resolveDbPath(opts.db),
+		remapProject: opts.remapProject,
+		dryRun: opts.dryRun
+	});
+	if (result.dryRun) {
+		p.outro("dry run complete");
+		return;
+	}
+	p.log.success([
+		`Imported sessions:  ${result.sessions.toLocaleString()}`,
+		`Imported prompts:   ${result.user_prompts.toLocaleString()}`,
+		`Imported memories:  ${result.memory_items.toLocaleString()}`,
+		`Imported summaries: ${result.session_summaries.toLocaleString()}`
+	].join("\n"));
+	p.outro("done");
+});
+//#endregion
+//#region src/commands/mcp.ts
+var mcpCommand = new Command("mcp").configureHelp(helpStyle).description("Start the MCP stdio server").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").action(async (opts) => {
+	if (opts.db) process.env.CODEMEM_DB = opts.db;
+	await import("@codemem/mcp-server");
+});
+//#endregion
+//#region src/commands/memory.ts
+/**
+* Memory management CLI commands — show, forget, remember.
+*
+* Ports codemem/commands/memory_cmds.py (show_cmd, forget_cmd, remember_cmd).
+* Compact and inject are deferred — compact requires the summarizer pipeline,
+* and inject is just pack_text output which the existing pack command covers.
+*/
+/** Parse a strict positive integer, rejecting prefixes like "12abc". */
+function parseStrictPositiveId(value) {
+	if (!/^\d+$/.test(value.trim())) return null;
+	const n = Number(value.trim());
+	return Number.isFinite(n) && n >= 1 && Number.isInteger(n) ? n : null;
+}
+var memoryCommand = new Command("memory").configureHelp(helpStyle).description("Memory item management");
+memoryCommand.addCommand(new Command("show").configureHelp(helpStyle).description("Print a memory item as JSON").argument("<id>", "memory ID").option("--db <path>", "database path").action((idStr, opts) => {
+	const memoryId = parseStrictPositiveId(idStr);
+	if (memoryId === null) {
+		p.log.error(`Invalid memory ID: ${idStr}`);
+		process.exitCode = 1;
+		return;
+	}
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const item = store.get(memoryId);
+		if (!item) {
+			p.log.error(`Memory ${memoryId} not found`);
+			process.exitCode = 1;
+			return;
+		}
+		console.log(JSON.stringify(item, null, 2));
+	} finally {
+		store.close();
+	}
+}));
+memoryCommand.addCommand(new Command("forget").configureHelp(helpStyle).description("Deactivate a memory item").argument("<id>", "memory ID").option("--db <path>", "database path").action((idStr, opts) => {
+	const memoryId = parseStrictPositiveId(idStr);
+	if (memoryId === null) {
+		p.log.error(`Invalid memory ID: ${idStr}`);
+		process.exitCode = 1;
+		return;
+	}
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		store.forget(memoryId);
+		p.log.success(`Memory ${memoryId} marked inactive`);
+	} finally {
+		store.close();
+	}
+}));
+memoryCommand.addCommand(new Command("remember").configureHelp(helpStyle).description("Manually add a memory item").requiredOption("-k, --kind <kind>", "memory kind (discovery, decision, feature, bugfix, etc.)").requiredOption("-t, --title <title>", "memory title").requiredOption("-b, --body <body>", "memory body text").option("--tags <tags...>", "tags (space-separated)").option("--project <project>", "project name (defaults to git repo root)").option("--db <path>", "database path").action((opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	let sessionId = null;
+	try {
+		const project = resolveProject(process.cwd(), opts.project ?? null);
+		sessionId = store.startSession({
+			cwd: process.cwd(),
+			project,
+			user: process.env.USER ?? "unknown",
+			toolVersion: "manual",
+			metadata: { manual: true }
+		});
+		const memId = store.remember(sessionId, opts.kind, opts.title, opts.body, .5, opts.tags);
+		store.endSession(sessionId, { manual: true });
+		p.log.success(`Stored memory ${memId}`);
+	} catch (err) {
+		if (sessionId !== null) try {
+			store.endSession(sessionId, {
+				manual: true,
+				error: true
+			});
+		} catch {}
+		throw err;
+	} finally {
+		store.close();
+	}
+}));
+//#endregion
+//#region src/commands/pack.ts
+var packCommand = new Command("pack").configureHelp(helpStyle).description("Build a context-aware memory pack").argument("<context>", "context string to search for").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("-n, --limit <n>", "max items", "10").option("--budget <tokens>", "token budget").option("--json", "output as JSON").action((context, opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const limit = Number.parseInt(opts.limit, 10) || 10;
+		const budget = opts.budget ? Number.parseInt(opts.budget, 10) : void 0;
+		const result = store.buildMemoryPack(context, limit, budget);
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		p.intro(`Memory pack for "${context}"`);
+		if (result.items.length === 0) {
+			p.log.warn("No relevant memories found.");
+			p.outro("done");
+			return;
+		}
+		const m = result.metrics;
+		p.log.info(`${m.total_items} items, ~${m.pack_tokens} tokens` + (m.fallback_used ? " (fallback)" : "") + `  [fts:${m.sources.fts} sem:${m.sources.semantic} fuzzy:${m.sources.fuzzy}]`);
+		for (const item of result.items) p.log.step(`#${item.id}  ${item.kind}  ${item.title}`);
+		p.note(result.pack_text, "pack_text");
+		p.outro("done");
+	} finally {
+		store.close();
+	}
+});
+//#endregion
+//#region src/commands/recent.ts
+var recentCommand = new Command("recent").configureHelp(helpStyle).description("Show recent memories").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--limit <n>", "max results", "5").option("--kind <kind>", "filter by memory kind").action((opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const limit = Math.max(1, Number.parseInt(opts.limit, 10) || 5);
+		const filters = opts.kind ? { kind: opts.kind } : void 0;
+		const items = store.recent(limit, filters);
+		for (const item of items) console.log(`#${item.id} [${item.kind}] ${item.title}`);
+	} finally {
+		store.close();
+	}
+});
+//#endregion
+//#region src/commands/search.ts
+var searchCommand = new Command("search").configureHelp(helpStyle).description("Search memories by query").argument("<query>", "search query").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("-n, --limit <n>", "max results", "10").option("--kind <kind>", "filter by memory kind").option("--json", "output as JSON").action((query, opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const limit = Number.parseInt(opts.limit, 10) || 10;
+		const filters = opts.kind ? { kind: opts.kind } : void 0;
+		const results = store.search(query, limit, filters);
+		if (opts.json) {
+			console.log(JSON.stringify(results, null, 2));
+			return;
+		}
+		if (results.length === 0) {
+			p.log.warn("No results found.");
+			return;
+		}
+		p.intro(`${results.length} result(s) for "${query}"`);
+		for (const item of results) {
+			const score = item.score.toFixed(3);
+			const age = timeSince(item.created_at);
+			const preview = item.body_text.length > 120 ? `${item.body_text.slice(0, 120)}…` : item.body_text;
+			p.log.message([
+				`#${item.id}  ${item.kind}  ${age}  [${score}]`,
+				item.title,
+				preview
+			].join("\n"));
+		}
+		p.outro("done");
+	} finally {
+		store.close();
+	}
+});
+function timeSince(isoDate) {
+	const ms = Date.now() - new Date(isoDate).getTime();
+	const days = Math.floor(ms / 864e5);
+	if (days === 0) return "today";
+	if (days === 1) return "1d ago";
+	if (days < 30) return `${days}d ago`;
+	return `${Math.floor(days / 30)}mo ago`;
+}
+//#endregion
+//#region src/commands/serve.ts
+function pidFilePath(dbPath) {
+	return join(dirname(dbPath), "viewer.pid");
+}
+function readViewerPidRecord(dbPath) {
+	const pidPath = pidFilePath(dbPath);
+	if (!existsSync(pidPath)) return null;
+	const raw = readFileSync(pidPath, "utf-8").trim();
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed.pid === "number" && typeof parsed.host === "string" && typeof parsed.port === "number") return {
+			pid: parsed.pid,
+			host: parsed.host,
+			port: parsed.port
+		};
+	} catch {
+		const pid = Number.parseInt(raw, 10);
+		if (Number.isFinite(pid) && pid > 0) return {
+			pid,
+			host: "127.0.0.1",
+			port: 38888
+		};
+	}
+	return null;
+}
+async function respondsLikeCodememViewer(record) {
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), 1e3);
+		const res = await fetch(`http://${record.host}:${record.port}/api/stats`, { signal: controller.signal });
+		clearTimeout(timer);
+		return res.ok;
+	} catch {
+		return false;
+	}
+}
+async function waitForProcessExit(pid, timeoutMs = 5e3) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) try {
+		process.kill(pid, 0);
+		await new Promise((resolve) => setTimeout(resolve, 100));
+	} catch {
+		return;
+	}
+}
+async function stopExistingViewer(dbPath) {
+	const pidPath = pidFilePath(dbPath);
+	const record = readViewerPidRecord(dbPath);
+	if (!record) return;
+	if (await respondsLikeCodememViewer(record)) try {
+		process.kill(record.pid, "SIGTERM");
+		await waitForProcessExit(record.pid);
+	} catch {}
+	try {
+		rmSync(pidPath);
+	} catch {}
+}
+var serveCommand = new Command("serve").configureHelp(helpStyle).description("Start the viewer server").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--host <host>", "bind host", "127.0.0.1").option("--port <port>", "bind port", "38888").option("--background", "run under a caller-managed background process").option("--stop", "stop an existing viewer process").option("--restart", "restart an existing viewer process").action(async (opts) => {
+	const { createApp, closeStore, getStore } = await import("@codemem/viewer-server");
+	const { serve } = await import("@hono/node-server");
+	const dbPath = resolveDbPath(opts.db);
+	if (opts.stop || opts.restart) {
+		await stopExistingViewer(dbPath);
+		if (opts.stop && !opts.restart) return;
+	}
+	process.env.CODEMEM_DB = dbPath;
+	const port = Number.parseInt(opts.port, 10);
+	const observer = new ObserverClient();
+	const sweeper = new RawEventSweeper(getStore(), { observer });
+	sweeper.start();
+	const syncAbort = new AbortController();
+	let syncRunning = false;
+	const config = readCodememConfigFile();
+	if (config.sync_enabled === true || process.env.CODEMEM_SYNC_ENABLED?.toLowerCase() === "true" || process.env.CODEMEM_SYNC_ENABLED === "1") {
+		syncRunning = true;
+		runSyncDaemon({
+			dbPath,
+			intervalS: typeof config.sync_interval_s === "number" ? config.sync_interval_s : 120,
+			host: opts.host,
+			port,
+			signal: syncAbort.signal
+		}).catch((err) => {
+			const msg = err instanceof Error ? err.message : String(err);
+			p.log.error(`Sync daemon failed: ${msg}`);
+		}).finally(() => {
+			syncRunning = false;
+		});
+	}
+	const app = createApp({
+		storeFactory: getStore,
+		sweeper
+	});
+	const pidPath = pidFilePath(dbPath);
+	const server = serve({
+		fetch: app.fetch,
+		hostname: opts.host,
+		port
+	}, (info) => {
+		writeFileSync(pidPath, JSON.stringify({
+			pid: process.pid,
+			host: opts.host,
+			port
+		}), "utf-8");
+		p.intro("codemem viewer");
+		p.log.success(`Listening on http://${info.address}:${info.port}`);
+		p.log.info(`Database: ${dbPath}`);
+		p.log.step("Raw event sweeper started");
+		if (syncRunning) p.log.step("Sync daemon started");
+	});
+	const shutdown = async () => {
+		p.outro("shutting down");
+		syncAbort.abort();
+		await sweeper.stop();
+		server.close(() => {
+			try {
+				rmSync(pidPath);
+			} catch {}
+			closeStore();
+			process.exit(0);
+		});
+		setTimeout(() => {
+			try {
+				rmSync(pidPath);
+			} catch {}
+			closeStore();
+			process.exit(1);
+		}, 5e3).unref();
+	};
+	process.on("SIGINT", () => {
+		shutdown();
+	});
+	process.on("SIGTERM", () => {
+		shutdown();
+	});
+});
+//#endregion
+//#region src/commands/setup.ts
+/**
+* codemem setup — one-command installation for OpenCode plugin + MCP config.
+*
+* Replaces Python's install_plugin_cmd + install_mcp_cmd.
+*
+* What it does:
+* 1. Copies the plugin file to ~/.config/opencode/plugin/codemem.js
+* 2. Adds/updates the MCP entry in ~/.config/opencode/opencode.json
+* 3. Copies the compat lib to ~/.config/opencode/lib/compat.js
+*
+* Designed to be safe to run repeatedly (idempotent unless --force).
+*/
+function opencodeConfigDir() {
+	return join(homedir(), ".config", "opencode");
+}
+function claudeConfigDir() {
+	return join(homedir(), ".claude");
+}
+/**
+* Find the plugin source file — walk up from this module's location
+* to find the .opencode/plugin/codemem.js in the package tree.
+*/
+function findPluginSource() {
+	let dir = dirname(import.meta.url.replace("file://", ""));
+	for (let i = 0; i < 6; i++) {
+		const candidate = join(dir, ".opencode", "plugin", "codemem.js");
+		if (existsSync(candidate)) return candidate;
+		const nmCandidate = join(dir, "node_modules", "codemem", ".opencode", "plugin", "codemem.js");
+		if (existsSync(nmCandidate)) return nmCandidate;
+		const legacyCandidate = join(dir, "node_modules", "@kunickiaj", "codemem", ".opencode", "plugin", "codemem.js");
+		if (existsSync(legacyCandidate)) return legacyCandidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function findCompatSource() {
+	let dir = dirname(import.meta.url.replace("file://", ""));
+	for (let i = 0; i < 6; i++) {
+		const candidate = join(dir, ".opencode", "lib", "compat.js");
+		if (existsSync(candidate)) return candidate;
+		const nmCandidate = join(dir, "node_modules", "codemem", ".opencode", "lib", "compat.js");
+		if (existsSync(nmCandidate)) return nmCandidate;
+		const legacyCandidate = join(dir, "node_modules", "@kunickiaj", "codemem", ".opencode", "lib", "compat.js");
+		if (existsSync(legacyCandidate)) return legacyCandidate;
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return null;
+}
+function loadJsoncConfig(path) {
+	if (!existsSync(path)) return {};
+	const raw = readFileSync(path, "utf-8");
+	try {
+		return JSON.parse(raw);
+	} catch {
+		const cleaned = stripTrailingCommas(stripJsonComments(raw));
+		return JSON.parse(cleaned);
+	}
+}
+function writeJsonConfig(path, data) {
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+function installPlugin(force) {
+	const source = findPluginSource();
+	if (!source) {
+		p.log.error("Plugin file not found in package tree");
+		return false;
+	}
+	const destDir = join(opencodeConfigDir(), "plugin");
+	const dest = join(destDir, "codemem.js");
+	if (existsSync(dest) && !force) p.log.info(`Plugin already installed at ${dest}`);
+	else {
+		mkdirSync(destDir, { recursive: true });
+		copyFileSync(source, dest);
+		p.log.success(`Plugin installed: ${dest}`);
+	}
+	const compatSource = findCompatSource();
+	if (compatSource) {
+		const compatDir = join(opencodeConfigDir(), "lib");
+		mkdirSync(compatDir, { recursive: true });
+		copyFileSync(compatSource, join(compatDir, "compat.js"));
+	}
+	return true;
+}
+function installMcp(force) {
+	const configPath = join(opencodeConfigDir(), "opencode.json");
+	let config;
+	try {
+		config = loadJsoncConfig(configPath);
+	} catch (err) {
+		p.log.error(`Failed to parse ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	let mcpConfig = config.mcp;
+	if (mcpConfig == null || typeof mcpConfig !== "object" || Array.isArray(mcpConfig)) mcpConfig = {};
+	if ("codemem" in mcpConfig && !force) {
+		p.log.info(`MCP entry already exists in ${configPath}`);
+		return true;
+	}
+	mcpConfig.codemem = {
+		type: "local",
+		command: [
+			"npx",
+			"codemem",
+			"mcp"
+		],
+		enabled: true
+	};
+	config.mcp = mcpConfig;
+	try {
+		writeJsonConfig(configPath, config);
+		p.log.success(`MCP entry installed: ${configPath}`);
+	} catch (err) {
+		p.log.error(`Failed to write ${configPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return true;
+}
+function installClaudeMcp(force) {
+	const settingsPath = join(claudeConfigDir(), "settings.json");
+	let settings;
+	try {
+		settings = loadJsoncConfig(settingsPath);
+	} catch {
+		settings = {};
+	}
+	let mcpServers = settings.mcpServers;
+	if (mcpServers == null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) mcpServers = {};
+	if ("codemem" in mcpServers && !force) {
+		p.log.info(`Claude MCP entry already exists in ${settingsPath}`);
+		return true;
+	}
+	mcpServers.codemem = {
+		command: "npx",
+		args: ["codemem", "mcp"]
+	};
+	settings.mcpServers = mcpServers;
+	try {
+		writeJsonConfig(settingsPath, settings);
+		p.log.success(`Claude MCP entry installed: ${settingsPath}`);
+	} catch (err) {
+		p.log.error(`Failed to write ${settingsPath}: ${err instanceof Error ? err.message : String(err)}`);
+		return false;
+	}
+	return true;
+}
+var setupCommand = new Command("setup").configureHelp(helpStyle).description("Install codemem plugin + MCP config for OpenCode and Claude Code").option("--force", "overwrite existing installations").option("--opencode-only", "only install for OpenCode").option("--claude-only", "only install for Claude Code").action((opts) => {
+	p.intro(`codemem setup v${VERSION}`);
+	const force = opts.force ?? false;
+	let ok = true;
+	if (!opts.claudeOnly) {
+		p.log.step("Installing OpenCode plugin...");
+		ok = installPlugin(force) && ok;
+		p.log.step("Installing OpenCode MCP config...");
+		ok = installMcp(force) && ok;
+	}
+	if (!opts.opencodeOnly) {
+		p.log.step("Installing Claude Code MCP config...");
+		ok = installClaudeMcp(force) && ok;
+	}
+	if (ok) p.outro("Setup complete — restart your editor to load the plugin");
+	else {
+		p.outro("Setup completed with warnings");
+		process.exitCode = 1;
+	}
+});
+//#endregion
+//#region src/commands/stats.ts
+function fmtPct(n) {
+	return `${Math.round(n * 100)}%`;
+}
+function fmtTokens(n) {
+	if (n >= 1e9) return `~${(n / 1e9).toFixed(1)}B`;
+	if (n >= 1e6) return `~${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `~${(n / 1e3).toFixed(0)}K`;
+	return `${n}`;
+}
+var statsCommand = new Command("stats").configureHelp(helpStyle).description("Show database statistics").option("--db <path>", "database path (default: $CODEMEM_DB or ~/.codemem/mem.sqlite)").option("--json", "output as JSON").action((opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const result = store.stats();
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+		const db = result.database;
+		const sizeMb = (db.size_bytes / 1048576).toFixed(1);
+		p.intro("codemem stats");
+		p.log.info([`Path:        ${db.path}`, `Size:        ${sizeMb} MB`].join("\n"));
+		p.log.success([
+			`Sessions:    ${db.sessions.toLocaleString()}`,
+			`Memories:    ${db.active_memory_items.toLocaleString()} active / ${db.memory_items.toLocaleString()} total`,
+			`Tags:        ${db.tags_filled.toLocaleString()} filled (${fmtPct(db.tags_coverage)} of active)`,
+			`Artifacts:   ${db.artifacts.toLocaleString()}`,
+			`Vectors:     ${db.vector_rows.toLocaleString()} (${fmtPct(db.vector_coverage)} coverage)`,
+			`Raw events:  ${db.raw_events.toLocaleString()}`
+		].join("\n"));
+		if (result.usage.events.length > 0) {
+			const lines = result.usage.events.map((e) => {
+				const parts = [`${e.event}: ${e.count.toLocaleString()}`];
+				if (e.tokens_read > 0) parts.push(`read ${fmtTokens(e.tokens_read)} tokens`);
+				if (e.tokens_saved > 0) parts.push(`est. saved ${fmtTokens(e.tokens_saved)} tokens`);
+				return `  ${parts.join(", ")}`;
+			});
+			const t = result.usage.totals;
+			lines.push("");
+			lines.push(`  Total: ${t.events.toLocaleString()} events, read ${fmtTokens(t.tokens_read)} tokens, est. saved ${fmtTokens(t.tokens_saved)} tokens`);
+			p.log.step(`Usage\n${lines.join("\n")}`);
+		}
+		p.outro("done");
+	} finally {
+		store.close();
+	}
+});
+//#endregion
+//#region src/commands/sync.ts
+/**
+* Sync CLI commands — enable/disable/status/peers/connect.
+*/
+var syncCommand = new Command("sync").configureHelp(helpStyle).description("Sync configuration and peer management");
+syncCommand.addCommand(new Command("status").configureHelp(helpStyle).description("Show sync configuration and peer summary").option("--db <path>", "database path").option("--json", "output as JSON").action((opts) => {
+	const config = readCodememConfigFile();
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const d = drizzle(store.db, { schema });
+		const deviceRow = d.select({
+			device_id: schema.syncDevice.device_id,
+			fingerprint: schema.syncDevice.fingerprint
+		}).from(schema.syncDevice).limit(1).get();
+		const peers = d.select({
+			peer_device_id: schema.syncPeers.peer_device_id,
+			name: schema.syncPeers.name,
+			last_sync_at: schema.syncPeers.last_sync_at,
+			last_error: schema.syncPeers.last_error
+		}).from(schema.syncPeers).all();
+		if (opts.json) {
+			console.log(JSON.stringify({
+				enabled: config.sync_enabled === true,
+				host: config.sync_host ?? "0.0.0.0",
+				port: config.sync_port ?? 7337,
+				interval_s: config.sync_interval_s ?? 120,
+				device_id: deviceRow?.device_id ?? null,
+				fingerprint: deviceRow?.fingerprint ?? null,
+				coordinator_url: config.sync_coordinator_url ?? null,
+				peers: peers.map((peer) => ({
+					device_id: peer.peer_device_id,
+					name: peer.name,
+					last_sync: peer.last_sync_at,
+					status: peer.last_error ?? "ok"
+				}))
+			}, null, 2));
+			return;
+		}
+		p.intro("codemem sync status");
+		p.log.info([
+			`Enabled:    ${config.sync_enabled === true ? "yes" : "no"}`,
+			`Host:       ${config.sync_host ?? "0.0.0.0"}`,
+			`Port:       ${config.sync_port ?? 7337}`,
+			`Interval:   ${config.sync_interval_s ?? 120}s`,
+			`Coordinator: ${config.sync_coordinator_url ?? "(not configured)"}`
+		].join("\n"));
+		if (deviceRow) p.log.info(`Device ID:   ${deviceRow.device_id}\nFingerprint: ${deviceRow.fingerprint}`);
+		else p.log.warn("Device identity not initialized (run `codemem sync enable`)");
+		if (peers.length === 0) p.log.info("Peers: none");
+		else for (const peer of peers) {
+			const label = peer.name || peer.peer_device_id;
+			p.log.message(`  ${label}: last_sync=${peer.last_sync_at ?? "never"}, status=${peer.last_error ?? "ok"}`);
+		}
+		p.outro(`${peers.length} peer(s)`);
+	} finally {
+		store.close();
+	}
+}));
+syncCommand.addCommand(new Command("enable").configureHelp(helpStyle).description("Enable sync and initialize device identity").option("--db <path>", "database path").option("--host <host>", "sync listen host").option("--port <port>", "sync listen port").option("--interval <seconds>", "sync interval in seconds").action((opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const [deviceId, fingerprint] = ensureDeviceIdentity(store.db);
+		const config = readCodememConfigFile();
+		config.sync_enabled = true;
+		if (opts.host) config.sync_host = opts.host;
+		if (opts.port) config.sync_port = Number.parseInt(opts.port, 10);
+		if (opts.interval) config.sync_interval_s = Number.parseInt(opts.interval, 10);
+		writeCodememConfigFile(config);
+		p.intro("codemem sync enable");
+		p.log.success([
+			`Device ID:   ${deviceId}`,
+			`Fingerprint: ${fingerprint}`,
+			`Host:        ${config.sync_host ?? "0.0.0.0"}`,
+			`Port:        ${config.sync_port ?? 7337}`,
+			`Interval:    ${config.sync_interval_s ?? 120}s`
+		].join("\n"));
+		p.outro("Sync enabled — restart `codemem serve` to activate");
+	} finally {
+		store.close();
+	}
+}));
+syncCommand.addCommand(new Command("disable").configureHelp(helpStyle).description("Disable sync without deleting keys or peers").action(() => {
+	const config = readCodememConfigFile();
+	config.sync_enabled = false;
+	writeCodememConfigFile(config);
+	p.intro("codemem sync disable");
+	p.outro("Sync disabled — restart `codemem serve` to take effect");
+}));
+syncCommand.addCommand(new Command("peers").configureHelp(helpStyle).description("List known sync peers").option("--db <path>", "database path").option("--json", "output as JSON").action((opts) => {
+	const store = new MemoryStore(resolveDbPath(opts.db));
+	try {
+		const peers = drizzle(store.db, { schema }).select({
+			peer_device_id: schema.syncPeers.peer_device_id,
+			name: schema.syncPeers.name,
+			addresses: schema.syncPeers.addresses_json,
+			last_sync_at: schema.syncPeers.last_sync_at,
+			last_error: schema.syncPeers.last_error
+		}).from(schema.syncPeers).orderBy(desc(schema.syncPeers.last_sync_at)).all();
+		if (opts.json) {
+			console.log(JSON.stringify(peers, null, 2));
+			return;
+		}
+		p.intro("codemem sync peers");
+		if (peers.length === 0) {
+			p.outro("No peers configured");
+			return;
+		}
+		for (const peer of peers) {
+			const label = peer.name || peer.peer_device_id;
+			const addrs = peer.addresses || "(no addresses)";
+			p.log.message(`${label}\n  addresses: ${addrs}\n  last_sync: ${peer.last_sync_at ?? "never"}\n  status: ${peer.last_error ?? "ok"}`);
+		}
+		p.outro(`${peers.length} peer(s)`);
+	} finally {
+		store.close();
+	}
+}));
+syncCommand.addCommand(new Command("connect").configureHelp(helpStyle).description("Configure coordinator URL for cloud sync").argument("<url>", "coordinator URL (e.g. https://coordinator.example.com)").option("--group <group>", "sync group ID").action((url, opts) => {
+	const config = readCodememConfigFile();
+	config.sync_coordinator_url = url.trim();
+	if (opts.group) config.sync_coordinator_group = opts.group.trim();
+	writeCodememConfigFile(config);
+	p.intro("codemem sync connect");
+	p.log.success(`Coordinator: ${url.trim()}`);
+	if (opts.group) p.log.info(`Group: ${opts.group.trim()}`);
+	p.outro("Restart `codemem serve` to activate coordinator sync");
+}));
+//#endregion
+//#region src/commands/version.ts
+var versionCommand = new Command("version").configureHelp(helpStyle).description("Print codemem version").action(() => {
+	console.log(VERSION);
+});
+//#endregion
+//#region src/index.ts
+/**
+* @codemem/cli — CLI entry point.
+*
+* Commands:
+*   codemem stats   → database statistics
+*   codemem search  → FTS5 memory search
+*   codemem pack    → context-aware memory pack
+*   codemem serve   → viewer server
+*   codemem mcp     → MCP stdio server
+*/
+var completion = omelette("codemem <command>");
+completion.on("command", ({ reply }) => {
+	reply([
+		"claude-hook-ingest",
+		"db",
+		"export-memories",
+		"memory",
+		"import-memories",
+		"setup",
+		"sync",
+		"stats",
+		"recent",
+		"search",
+		"pack",
+		"serve",
+		"mcp",
+		"enqueue-raw-event",
+		"version",
+		"help",
+		"--help",
+		"--version"
+	]);
+});
+completion.init();
+if (process.argv.includes("--setup-completion")) {
+	completion.setupShellInitFile();
+	process.exit(0);
+}
+if (process.argv.includes("--cleanup-completion")) {
+	completion.cleanupShellInitFile();
+	process.exit(0);
+}
+var program = new Command();
+program.name("codemem").description("codemem — persistent memory for AI coding agents").version(VERSION).configureHelp(helpStyle);
+program.addCommand(serveCommand);
+program.addCommand(mcpCommand);
+program.addCommand(claudeHookIngestCommand);
+program.addCommand(dbCommand);
+program.addCommand(exportMemoriesCommand);
+program.addCommand(importMemoriesCommand);
+program.addCommand(statsCommand);
+program.addCommand(recentCommand);
+program.addCommand(searchCommand);
+program.addCommand(packCommand);
+program.addCommand(memoryCommand);
+program.addCommand(syncCommand);
+program.addCommand(setupCommand);
+program.addCommand(enqueueRawEventCommand);
+program.addCommand(versionCommand);
+program.parse();
+//#endregion
+export {};
+
+//# sourceMappingURL=index.js.map