@colbymchenry/cmem 0.2.20

package/dist/cli.js

@@ -0,0 +1,3197 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  installCommand: () => installCommand,
+  statusCommand: () => statusCommand,
+  uninstallCommand: () => uninstallCommand
+});
+import chalk9 from "chalk";
+import { writeFileSync, unlinkSync, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join5, dirname as dirname4 } from "path";
+import { execSync as execSync2 } from "child_process";
+function getCmemPath() {
+  try {
+    const result = execSync2("which cmem", { encoding: "utf-8" }).trim();
+    return result;
+  } catch {
+    return "/usr/local/bin/cmem";
+  }
+}
+function getNodeBinDir() {
+  try {
+    const nodePath = execSync2("which node", { encoding: "utf-8" }).trim();
+    return dirname4(nodePath);
+  } catch {
+    return "/usr/local/bin";
+  }
+}
+function generatePlist(cmemPath) {
+  const nodeBinDir = getNodeBinDir();
+  const pathValue = `${nodeBinDir}:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.cmem.watch</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${cmemPath}</string>
+        <string>watch</string>
+    </array>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>${homedir2()}/.cmem/watch.log</string>
+
+    <key>StandardErrorPath</key>
+    <string>${homedir2()}/.cmem/watch.error.log</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${pathValue}</string>
+    </dict>
+</dict>
+</plist>`;
+}
+async function installCommand() {
+  const platform = process.platform;
+  if (platform !== "darwin") {
+    console.log(chalk9.yellow("Auto-install is currently only supported on macOS."));
+    console.log(chalk9.dim("\nFor Linux, create a systemd service:"));
+    console.log(chalk9.dim("  ~/.config/systemd/user/cmem-watch.service"));
+    console.log(chalk9.dim("\nFor manual background run:"));
+    console.log(chalk9.dim("  nohup cmem watch > ~/.cmem/watch.log 2>&1 &"));
+    return;
+  }
+  console.log(chalk9.cyan("Installing cmem watch daemon...\n"));
+  if (!existsSync8(LAUNCH_AGENTS_DIR)) {
+    mkdirSync2(LAUNCH_AGENTS_DIR, { recursive: true });
+  }
+  const cmemDir = join5(homedir2(), ".cmem");
+  if (!existsSync8(cmemDir)) {
+    mkdirSync2(cmemDir, { recursive: true });
+  }
+  const cmemPath = getCmemPath();
+  console.log(chalk9.dim(`Using cmem at: ${cmemPath}`));
+  if (existsSync8(PLIST_PATH)) {
+    console.log(chalk9.yellow("LaunchAgent already exists. Unloading first..."));
+    try {
+      execSync2(`launchctl unload "${PLIST_PATH}"`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  const plistContent = generatePlist(cmemPath);
+  writeFileSync(PLIST_PATH, plistContent);
+  console.log(chalk9.green(`\u2713 Created ${PLIST_PATH}`));
+  try {
+    execSync2(`launchctl load "${PLIST_PATH}"`);
+    console.log(chalk9.green("\u2713 LaunchAgent loaded"));
+  } catch (err) {
+    console.log(chalk9.red("Failed to load LaunchAgent:"), err);
+    return;
+  }
+  console.log(chalk9.green("\n\u2713 cmem watch daemon installed and running!"));
+  console.log(chalk9.dim("\nThe daemon will:"));
+  console.log(chalk9.dim("  \u2022 Start automatically on login"));
+  console.log(chalk9.dim("  \u2022 Restart if it crashes"));
+  console.log(chalk9.dim(`  \u2022 Log to ~/.cmem/watch.log`));
+  console.log(chalk9.dim("\nCommands:"));
+  console.log(chalk9.dim("  cmem uninstall     Stop and remove the daemon"));
+  console.log(chalk9.dim("  cmem status        Check daemon status"));
+}
+async function uninstallCommand() {
+  const platform = process.platform;
+  if (platform !== "darwin") {
+    console.log(chalk9.yellow("Auto-uninstall is currently only supported on macOS."));
+    return;
+  }
+  console.log(chalk9.cyan("Uninstalling cmem watch daemon...\n"));
+  if (!existsSync8(PLIST_PATH)) {
+    console.log(chalk9.yellow("LaunchAgent not found. Nothing to uninstall."));
+    return;
+  }
+  try {
+    execSync2(`launchctl unload "${PLIST_PATH}"`);
+    console.log(chalk9.green("\u2713 LaunchAgent unloaded"));
+  } catch {
+    console.log(chalk9.yellow("LaunchAgent was not loaded"));
+  }
+  try {
+    unlinkSync(PLIST_PATH);
+    console.log(chalk9.green(`\u2713 Removed ${PLIST_PATH}`));
+  } catch (err) {
+    console.log(chalk9.red("Failed to remove plist:"), err);
+    return;
+  }
+  console.log(chalk9.green("\n\u2713 cmem watch daemon uninstalled"));
+}
+async function statusCommand() {
+  const platform = process.platform;
+  if (platform !== "darwin") {
+    console.log(chalk9.yellow("Status check is currently only supported on macOS."));
+    return;
+  }
+  console.log(chalk9.cyan("cmem watch daemon status\n"));
+  if (!existsSync8(PLIST_PATH)) {
+    console.log(chalk9.yellow("Status: Not installed"));
+    console.log(chalk9.dim("Run: cmem install"));
+    return;
+  }
+  try {
+    const result = execSync2(`launchctl list | grep com.cmem.watch`, {
+      encoding: "utf-8"
+    });
+    const parts = result.trim().split(/\s+/);
+    const pid = parts[0];
+    const exitCode = parts[1];
+    if (pid && pid !== "-") {
+      console.log(chalk9.green(`Status: Running (PID ${pid})`));
+    } else if (exitCode === "0") {
+      console.log(chalk9.yellow("Status: Stopped (exit code 0)"));
+    } else {
+      console.log(chalk9.red(`Status: Crashed (exit code ${exitCode})`));
+      console.log(chalk9.dim("Check ~/.cmem/watch.error.log for details"));
+    }
+  } catch {
+    console.log(chalk9.yellow("Status: Not running"));
+    console.log(chalk9.dim("The daemon is installed but not currently running."));
+    console.log(chalk9.dim("It will start on next login, or run: launchctl load ~/Library/LaunchAgents/com.cmem.watch.plist"));
+  }
+  console.log(chalk9.dim(`
+Plist: ${PLIST_PATH}`));
+  console.log(chalk9.dim("Logs:  ~/.cmem/watch.log"));
+}
+var LAUNCH_AGENTS_DIR, PLIST_NAME, PLIST_PATH;
+var init_install = __esm({
+  "src/commands/install.ts"() {
+    "use strict";
+    LAUNCH_AGENTS_DIR = join5(homedir2(), "Library", "LaunchAgents");
+    PLIST_NAME = "com.cmem.watch.plist";
+    PLIST_PATH = join5(LAUNCH_AGENTS_DIR, PLIST_NAME);
+  }
+});
+
+// src/cli.ts
+import { program } from "commander";
+import { render } from "ink";
+import React2 from "react";
+import { existsSync as existsSync10, readFileSync as readFileSync4 } from "fs";
+import { join as join7, dirname as dirname6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { spawn as spawn2 } from "child_process";
+
+// src/ui/App.tsx
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+import { Box as Box5, Text as Text5, useInput, useApp } from "ink";
+import TextInput2 from "ink-text-input";
+import Spinner from "ink-spinner";
+import { basename as basename4, dirname as dirname2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/ui/components/Header.tsx
+import { Box, Text } from "ink";
+import { basename } from "path";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Header = ({ embeddingsReady, projectFilter }) => {
+  return /* @__PURE__ */ jsxs(Box, { marginBottom: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "cmem" }),
+      projectFilter && /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+        " \u{1F4C1} ",
+        basename(projectFilter)
+      ] }),
+      !embeddingsReady && /* @__PURE__ */ jsx(Text, { color: "yellow", dimColor: true, children: " (loading model...)" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "[q] quit" })
+  ] });
+};
+
+// src/ui/components/SearchInput.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import TextInput from "ink-text-input";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SearchInput = ({
+  value,
+  onChange,
+  isFocused
+}) => {
+  return /* @__PURE__ */ jsxs2(Box2, { marginBottom: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { children: "Search: " }),
+    isFocused ? /* @__PURE__ */ jsx2(
+      TextInput,
+      {
+        value,
+        onChange,
+        placeholder: "type to search...",
+        focus: true
+      }
+    ) : /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: value || "press / to search" })
+  ] });
+};
+
+// src/ui/components/SessionList.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { basename as basename2 } from "path";
+
+// src/utils/format.ts
+function formatTimeAgo(timestamp) {
+  const date = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffSecs = Math.floor(diffMs / 1e3);
+  const diffMins = Math.floor(diffSecs / 60);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+  const diffWeeks = Math.floor(diffDays / 7);
+  const diffMonths = Math.floor(diffDays / 30);
+  if (diffSecs < 60) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  if (diffWeeks < 4) return `${diffWeeks}w ago`;
+  return `${diffMonths}mo ago`;
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function shortId(id) {
+  return id.slice(0, 8);
+}
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function generateTitle(content) {
+  const firstLine = content.split("\n")[0].trim();
+  const title = truncate(firstLine, 50);
+  return title || "Untitled Session";
+}
+
+// src/ui/components/SessionList.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var SessionList = ({
+  sessions,
+  selectedIndex
+}) => {
+  if (sessions.length === 0) {
+    return /* @__PURE__ */ jsxs3(
+      Box3,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: "gray",
+        paddingX: 1,
+        paddingY: 0,
+        children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Sessions" }),
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "No sessions found" }),
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Run: cmem save --latest" })
+        ]
+      }
+    );
+  }
+  const visibleCount = 8;
+  let startIndex = Math.max(0, selectedIndex - Math.floor(visibleCount / 2));
+  const endIndex = Math.min(sessions.length, startIndex + visibleCount);
+  if (endIndex - startIndex < visibleCount) {
+    startIndex = Math.max(0, endIndex - visibleCount);
+  }
+  const visibleSessions = sessions.slice(startIndex, endIndex);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      paddingY: 0,
+      children: [
+        /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+          "Sessions (",
+          sessions.length,
+          ")"
+        ] }),
+        visibleSessions.map((session, i) => {
+          const actualIndex = startIndex + i;
+          const isSelected = actualIndex === selectedIndex;
+          return /* @__PURE__ */ jsx3(
+            SessionItem,
+            {
+              session,
+              isSelected
+            },
+            session.id
+          );
+        }),
+        sessions.length > visibleCount && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          startIndex > 0 ? "\u2191 more above" : "",
+          startIndex > 0 && endIndex < sessions.length ? " | " : "",
+          endIndex < sessions.length ? "\u2193 more below" : ""
+        ] })
+      ]
+    }
+  );
+};
+var SessionItem = ({ session, isSelected }) => {
+  const hasCustomTitle = !!session.customTitle;
+  const displayTitle = truncate(session.customTitle || session.title, 40);
+  const folderName = session.projectPath ? truncate(basename2(session.projectPath), 40) : "";
+  const msgs = String(session.messageCount).padStart(3);
+  const updated = formatTimeAgo(session.updatedAt);
+  const getTitleColor = () => {
+    if (isSelected) return "cyan";
+    if (hasCustomTitle) return "magenta";
+    return void 0;
+  };
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { color: isSelected ? "cyan" : void 0, children: isSelected ? "\u25B8 " : "  " }),
+    /* @__PURE__ */ jsx3(Text3, { bold: isSelected, color: getTitleColor(), wrap: "truncate", children: displayTitle.padEnd(40) }),
+    /* @__PURE__ */ jsxs3(Text3, { color: "blue", children: [
+      " ",
+      folderName.padEnd(40)
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " ",
+      msgs,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: updated.padStart(8) })
+  ] });
+};
+
+// src/ui/components/Preview.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var Preview = ({ session }) => {
+  if (!session) {
+    return null;
+  }
+  const summary = session.summary ? truncate(session.summary, 200) : "No summary available";
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "gray",
+      paddingX: 1,
+      paddingY: 0,
+      marginTop: 1,
+      children: [
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Preview" }),
+          session.projectPath && /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "blue", children: [
+            "  \u{1F4C1} ",
+            session.projectPath
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: summary }),
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          "Messages: ",
+          session.messageCount
+        ] })
+      ]
+    }
+  );
+};
+
+// src/ui/hooks/useSessions.ts
+import { useState, useEffect, useCallback } from "react";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { existsSync as existsSync3 } from "fs";
+
+// src/utils/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+var CMEM_DIR = join(homedir(), ".cmem");
+var DB_PATH = join(CMEM_DIR, "sessions.db");
+var MODELS_DIR = join(CMEM_DIR, "models");
+var CLAUDE_DIR = join(homedir(), ".claude");
+var CLAUDE_PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+var CLAUDE_SESSIONS_DIR = join(CLAUDE_DIR, "sessions");
+var EMBEDDING_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+var EMBEDDING_DIMENSIONS = 768;
+var MAX_EMBEDDING_CHARS = 8e3;
+var MAX_MESSAGE_PREVIEW_CHARS = 500;
+var MAX_MESSAGES_FOR_CONTEXT = 20;
+function ensureCmemDir() {
+  if (!existsSync(CMEM_DIR)) {
+    mkdirSync(CMEM_DIR, { recursive: true });
+  }
+}
+function ensureModelsDir() {
+  ensureCmemDir();
+  if (!existsSync(MODELS_DIR)) {
+    mkdirSync(MODELS_DIR, { recursive: true });
+  }
+}
+
+// src/parser/index.ts
+import { readFileSync, readdirSync, existsSync as existsSync2, statSync } from "fs";
+import { join as join2 } from "path";
+function extractSessionMetadata(filepath) {
+  const content = readFileSync(filepath, "utf-8");
+  const metadata = {
+    isSidechain: false,
+    isMeta: false
+  };
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed.type === "user" && parsed.message) {
+        if (parsed.isSidechain === true) {
+          metadata.isSidechain = true;
+        }
+        if (parsed.agentId) {
+          metadata.isSidechain = true;
+        }
+        if (parsed.isMeta === true) {
+          metadata.isMeta = true;
+        }
+        break;
+      }
+    } catch {
+    }
+  }
+  return metadata;
+}
+function parseSessionFile(filepath) {
+  const content = readFileSync(filepath, "utf-8");
+  const messages = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if ((parsed.type === "user" || parsed.type === "assistant") && parsed.message) {
+        const msg = parsed.message;
+        if (msg.role && msg.content) {
+          const content2 = Array.isArray(msg.content) ? msg.content.filter((c) => c.type === "text").map((c) => c.text).join("\n") : typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+          if (content2) {
+            messages.push({
+              role: msg.role,
+              content: content2,
+              timestamp: parsed.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+      } else if (parsed.type === "message" && parsed.role && parsed.content) {
+        messages.push({
+          role: parsed.role,
+          content: typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content),
+          timestamp: parsed.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else if (parsed.role && parsed.content && !parsed.type) {
+        messages.push({
+          role: parsed.role,
+          content: typeof parsed.content === "string" ? parsed.content : JSON.stringify(parsed.content),
+          timestamp: parsed.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } catch {
+    }
+  }
+  return messages;
+}
+function findSessionFiles() {
+  const sessions = [];
+  if (existsSync2(CLAUDE_PROJECTS_DIR)) {
+    const projectDirs = readdirSync(CLAUDE_PROJECTS_DIR);
+    for (const projectDir of projectDirs) {
+      const projectDirPath = join2(CLAUDE_PROJECTS_DIR, projectDir);
+      const stat = statSync(projectDirPath);
+      if (!stat.isDirectory()) continue;
+      const indexPath = join2(projectDirPath, "sessions-index.json");
+      const sessionIndex = loadSessionIndex(indexPath);
+      const indexedSessions = /* @__PURE__ */ new Map();
+      if (sessionIndex) {
+        for (const entry of sessionIndex.entries) {
+          indexedSessions.set(entry.sessionId, entry);
+        }
+      }
+      const entries = readdirSync(projectDirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+        const filePath = join2(projectDirPath, entry.name);
+        const sessionId = entry.name.replace(".jsonl", "");
+        try {
+          const session = loadSession(filePath);
+          if (session) {
+            const indexEntry = indexedSessions.get(sessionId);
+            if (indexEntry) {
+              session.projectPath = indexEntry.projectPath;
+            }
+            const agentMessages = loadSubagentMessages(projectDirPath, sessionId);
+            if (agentMessages.length > 0) {
+              session.agentMessages = agentMessages;
+            }
+            sessions.push(session);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  if (existsSync2(CLAUDE_SESSIONS_DIR)) {
+    const sessionFiles = readdirSync(CLAUDE_SESSIONS_DIR).filter((f) => f.endsWith(".jsonl"));
+    for (const sessionFile of sessionFiles) {
+      const filePath = join2(CLAUDE_SESSIONS_DIR, sessionFile);
+      try {
+        const session = loadSession(filePath);
+        if (session) {
+          sessions.push(session);
+        }
+      } catch {
+      }
+    }
+  }
+  sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
+  return sessions;
+}
+function loadSessionIndex(indexPath) {
+  if (!existsSync2(indexPath)) return null;
+  try {
+    const content = readFileSync(indexPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function loadSubagentMessages(projectDirPath, parentSessionId) {
+  const subagentsDir = join2(projectDirPath, parentSessionId, "subagents");
+  if (!existsSync2(subagentsDir)) return [];
+  const messages = [];
+  try {
+    const agentFiles = readdirSync(subagentsDir).filter((f) => f.endsWith(".jsonl"));
+    for (const agentFile of agentFiles) {
+      const agentPath = join2(subagentsDir, agentFile);
+      const agentMessages = parseSessionFile(agentPath);
+      messages.push(...agentMessages);
+    }
+  } catch {
+  }
+  return messages;
+}
+function loadSession(filePath) {
+  const rawData = readFileSync(filePath, "utf-8");
+  const messages = parseSessionFile(filePath);
+  if (messages.length === 0) {
+    return null;
+  }
+  const stats = statSync(filePath);
+  return {
+    filePath,
+    projectPath: null,
+    messages,
+    rawData,
+    modifiedAt: stats.mtime
+  };
+}
+function getMostRecentSession() {
+  const sessions = findSessionFiles();
+  return sessions.length > 0 ? sessions[0] : null;
+}
+function generateSummary(messages) {
+  const firstUserMessage = messages.find((m) => m.role === "user");
+  if (!firstUserMessage) {
+    return "No user messages found";
+  }
+  const summary = firstUserMessage.content.slice(0, 300);
+  return summary.length < firstUserMessage.content.length ? summary + "..." : summary;
+}
+
+// src/db/index.ts
+var db = null;
+function getDatabase() {
+  if (db) return db;
+  ensureCmemDir();
+  db = new Database(DB_PATH);
+  db.pragma("journal_mode = WAL");
+  sqliteVec.load(db);
+  initSchema(db);
+  return db;
+}
+function initSchema(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      name TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      summary TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      message_count INTEGER DEFAULT 0,
+      project_path TEXT,
+      source_file TEXT,
+      raw_data TEXT NOT NULL
+    );
+  `);
+  try {
+    database.exec(`ALTER TABLE sessions ADD COLUMN source_file TEXT`);
+  } catch {
+  }
+  try {
+    database.exec(`ALTER TABLE sessions ADD COLUMN is_sidechain INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    database.exec(`ALTER TABLE sessions ADD COLUMN is_automated INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    database.exec(`ALTER TABLE sessions ADD COLUMN custom_title TEXT`);
+  } catch {
+  }
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
+      content TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS embedding_state (
+      session_id TEXT PRIMARY KEY,
+      content_length INTEGER NOT NULL,
+      file_mtime TEXT,
+      last_embedded_at TEXT NOT NULL,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+  `);
+  database.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_embeddings USING vec0(
+      session_id TEXT PRIMARY KEY,
+      embedding FLOAT[${EMBEDDING_DIMENSIONS}]
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_sessions_updated ON sessions(updated_at DESC);
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_sessions_source ON sessions(source_file);
+  `);
+  runMigrations(database);
+}
+function runMigrations(database) {
+  const migrationName = "populate_session_metadata_v1";
+  const existing = database.prepare(
+    "SELECT 1 FROM migrations WHERE name = ?"
+  ).get(migrationName);
+  if (existing) return;
+  const sessions = database.prepare(`
+    SELECT id, source_file FROM sessions WHERE source_file IS NOT NULL
+  `).all();
+  const updateStmt = database.prepare(`
+    UPDATE sessions SET is_sidechain = ?, is_automated = ? WHERE id = ?
+  `);
+  const transaction = database.transaction(() => {
+    for (const session of sessions) {
+      if (!existsSync3(session.source_file)) continue;
+      try {
+        const metadata = extractSessionMetadata(session.source_file);
+        const isAutomated = metadata.isSidechain || metadata.isMeta;
+        updateStmt.run(
+          metadata.isSidechain ? 1 : 0,
+          isAutomated ? 1 : 0,
+          session.id
+        );
+      } catch {
+      }
+    }
+    database.prepare(
+      "INSERT INTO migrations (name, applied_at) VALUES (?, ?)"
+    ).run(migrationName, (/* @__PURE__ */ new Date()).toISOString());
+  });
+  transaction();
+}
+
+// src/db/sessions.ts
+import { randomUUID } from "crypto";
+function createSession(input) {
+  const db2 = getDatabase();
+  const id = randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const insertSession = db2.prepare(`
+    INSERT INTO sessions (id, title, summary, created_at, updated_at, message_count, project_path, source_file, raw_data, is_sidechain, is_automated)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+  const insertMessage = db2.prepare(`
+    INSERT INTO messages (session_id, role, content, timestamp)
+    VALUES (?, ?, ?, ?)
+  `);
+  const transaction = db2.transaction(() => {
+    insertSession.run(
+      id,
+      input.title,
+      input.summary || null,
+      now,
+      now,
+      input.messages.length,
+      input.projectPath || null,
+      input.sourceFile || null,
+      input.rawData,
+      input.isSidechain ? 1 : 0,
+      input.isAutomated ? 1 : 0
+    );
+    for (const msg of input.messages) {
+      insertMessage.run(id, msg.role, msg.content, msg.timestamp);
+    }
+  });
+  transaction();
+  return id;
+}
+function updateSession(id, input) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updates = ["updated_at = ?"];
+  const values = [now];
+  if (input.title !== void 0) {
+    updates.push("title = ?");
+    values.push(input.title);
+  }
+  if (input.summary !== void 0) {
+    updates.push("summary = ?");
+    values.push(input.summary);
+  }
+  if (input.rawData !== void 0) {
+    updates.push("raw_data = ?");
+    values.push(input.rawData);
+  }
+  if (input.messages !== void 0) {
+    updates.push("message_count = ?");
+    values.push(input.messages.length);
+  }
+  if (input.isSidechain !== void 0) {
+    updates.push("is_sidechain = ?");
+    values.push(input.isSidechain ? 1 : 0);
+  }
+  if (input.isAutomated !== void 0) {
+    updates.push("is_automated = ?");
+    values.push(input.isAutomated ? 1 : 0);
+  }
+  values.push(id);
+  const transaction = db2.transaction(() => {
+    db2.prepare(`UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+    if (input.messages !== void 0) {
+      db2.prepare("DELETE FROM messages WHERE session_id = ?").run(id);
+      const insertMessage = db2.prepare(`
+        INSERT INTO messages (session_id, role, content, timestamp)
+        VALUES (?, ?, ?, ?)
+      `);
+      for (const msg of input.messages) {
+        insertMessage.run(id, msg.role, msg.content, msg.timestamp);
+      }
+    }
+  });
+  transaction();
+}
+function getSession(id) {
+  const db2 = getDatabase();
+  const row = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions WHERE id = ?
+  `).get(id);
+  if (!row) return null;
+  return mapSessionRow(row);
+}
+function getSessionByIdPrefix(idPrefix) {
+  const db2 = getDatabase();
+  const row = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions WHERE id LIKE ? || '%'
+    LIMIT 1
+  `).get(idPrefix);
+  if (!row) return null;
+  return mapSessionRow(row);
+}
+function getSessionBySourceFile(sourceFile) {
+  const db2 = getDatabase();
+  const row = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions WHERE source_file = ?
+  `).get(sourceFile);
+  if (!row) return null;
+  return mapSessionRow(row);
+}
+function getSessionMessages(sessionId) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT id, session_id as sessionId, role, content, timestamp
+    FROM messages WHERE session_id = ?
+    ORDER BY timestamp ASC
+  `).all(sessionId);
+  return rows;
+}
+function mapSessionRow(row) {
+  return {
+    ...row,
+    customTitle: row.customTitle,
+    isSidechain: row.isSidechain === 1,
+    isAutomated: row.isAutomated === 1
+  };
+}
+function listSessions(limit = 100) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(limit);
+  return rows.map(mapSessionRow);
+}
+function listHumanSessions(limit = 100) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions
+    WHERE is_sidechain = 0 AND is_automated = 0
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(limit);
+  return rows.map(mapSessionRow);
+}
+function listHumanSessionsByProject(projectPath, limit = 100) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(`
+    SELECT id, title, custom_title as customTitle, summary,
+           created_at as createdAt, updated_at as updatedAt,
+           message_count as messageCount, project_path as projectPath,
+           source_file as sourceFile, raw_data as rawData,
+           is_sidechain as isSidechain, is_automated as isAutomated
+    FROM sessions
+    WHERE is_sidechain = 0 AND is_automated = 0
+      AND project_path LIKE ? || '%'
+    ORDER BY updated_at DESC
+    LIMIT ?
+  `).all(projectPath, limit);
+  return rows.map(mapSessionRow);
+}
+function deleteSession(id) {
+  const db2 = getDatabase();
+  const transaction = db2.transaction(() => {
+    db2.prepare("DELETE FROM session_embeddings WHERE session_id = ?").run(id);
+    db2.prepare("DELETE FROM embedding_state WHERE session_id = ?").run(id);
+    db2.prepare("DELETE FROM messages WHERE session_id = ?").run(id);
+    const result = db2.prepare("DELETE FROM sessions WHERE id = ?").run(id);
+    return result.changes > 0;
+  });
+  return transaction();
+}
+function renameSession(id, customTitle) {
+  const db2 = getDatabase();
+  db2.prepare(`
+    UPDATE sessions SET custom_title = ?, updated_at = ? WHERE id = ?
+  `).run(customTitle, (/* @__PURE__ */ new Date()).toISOString(), id);
+}
+function getStats() {
+  const db2 = getDatabase();
+  const sessionCount = db2.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+  const messageCount = db2.prepare("SELECT COUNT(*) as count FROM messages").get().count;
+  const embeddingCount = db2.prepare("SELECT COUNT(*) as count FROM session_embeddings").get().count;
+  return { sessionCount, messageCount, embeddingCount };
+}
+function sessionExists(rawData) {
+  const db2 = getDatabase();
+  const row = db2.prepare("SELECT 1 FROM sessions WHERE raw_data = ? LIMIT 1").get(rawData);
+  return !!row;
+}
+function getEmbeddingState(sessionId) {
+  const db2 = getDatabase();
+  const row = db2.prepare(`
+    SELECT session_id as sessionId, content_length as contentLength,
+           file_mtime as fileMtime, last_embedded_at as lastEmbeddedAt
+    FROM embedding_state WHERE session_id = ?
+  `).get(sessionId);
+  return row || null;
+}
+function updateEmbeddingState(sessionId, contentLength, fileMtime) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db2.prepare(`
+    INSERT OR REPLACE INTO embedding_state (session_id, content_length, file_mtime, last_embedded_at)
+    VALUES (?, ?, ?, ?)
+  `).run(sessionId, contentLength, fileMtime || null, now);
+}
+function needsReembedding(sessionId, currentContentLength, threshold = 500) {
+  const state = getEmbeddingState(sessionId);
+  if (!state) return true;
+  return currentContentLength - state.contentLength >= threshold;
+}
+
+// src/db/vectors.ts
+function storeEmbedding(sessionId, embedding) {
+  const db2 = getDatabase();
+  const embeddingJson = JSON.stringify(embedding);
+  db2.prepare(`
+    INSERT OR REPLACE INTO session_embeddings (session_id, embedding)
+    VALUES (?, ?)
+  `).run(sessionId, embeddingJson);
+}
+function searchSessions(queryEmbedding, limit = 10) {
+  const db2 = getDatabase();
+  const embeddingJson = JSON.stringify(queryEmbedding);
+  const rows = db2.prepare(`
+    SELECT s.id, s.title, s.summary, s.created_at as createdAt, s.updated_at as updatedAt,
+           s.message_count as messageCount, s.project_path as projectPath, s.raw_data as rawData,
+           vec_distance_L2(e.embedding, ?) as distance
+    FROM session_embeddings e
+    JOIN sessions s ON e.session_id = s.id
+    ORDER BY distance ASC
+    LIMIT ?
+  `).all(embeddingJson, limit);
+  return rows;
+}
+
+// src/embeddings/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+var transformersModule = null;
+var pipeline = null;
+var initialized = false;
+async function getTransformers() {
+  if (!transformersModule) {
+    transformersModule = await import("@xenova/transformers");
+  }
+  return transformersModule;
+}
+function isModelCached() {
+  const modelCachePath = join3(MODELS_DIR, EMBEDDING_MODEL);
+  return existsSync4(modelCachePath);
+}
+async function initializeEmbeddings(onProgress) {
+  if (initialized && pipeline) {
+    return;
+  }
+  ensureModelsDir();
+  const { pipeline: createPipeline, env } = await getTransformers();
+  env.cacheDir = MODELS_DIR;
+  const cached = isModelCached();
+  if (cached) {
+    env.allowRemoteModels = false;
+    onProgress?.({ status: "loading" });
+  } else {
+    onProgress?.({ status: "downloading" });
+  }
+  pipeline = await createPipeline("feature-extraction", EMBEDDING_MODEL, {
+    progress_callback: onProgress ? (progress) => {
+      if (progress.status === "progress" && progress.file && progress.progress !== void 0) {
+        onProgress({
+          status: "downloading",
+          file: progress.file,
+          progress: progress.progress
+        });
+      }
+    } : void 0
+  });
+  initialized = true;
+  onProgress?.({ status: "ready" });
+}
+function isReady() {
+  return initialized && pipeline !== null;
+}
+async function getEmbedding(text) {
+  if (!initialized) {
+    await initializeEmbeddings();
+  }
+  const truncated = text.slice(0, MAX_EMBEDDING_CHARS);
+  const output = await pipeline(truncated, {
+    pooling: "mean",
+    normalize: true
+  });
+  return Array.from(output.data);
+}
+function createEmbeddingText(title, summary, messages) {
+  const parts = [];
+  parts.push(`Title: ${title}`);
+  if (summary) {
+    parts.push(`Summary: ${summary}`);
+  }
+  const userMessages = messages.filter((m) => m.role === "user").slice(0, 5).map((m) => m.content.slice(0, MAX_MESSAGE_PREVIEW_CHARS));
+  if (userMessages.length > 0) {
+    parts.push("User messages:");
+    parts.push(...userMessages);
+  }
+  const assistantMessages = messages.filter((m) => m.role === "assistant").slice(0, 3).map((m) => m.content.slice(0, MAX_MESSAGE_PREVIEW_CHARS));
+  if (assistantMessages.length > 0) {
+    parts.push("Assistant responses:");
+    parts.push(...assistantMessages);
+  }
+  return parts.join("\n\n");
+}
+
+// src/ui/hooks/useSessions.ts
+function useSessions(options = {}) {
+  const [sessions, setSessions] = useState([]);
+  const [allSessions, setAllSessions] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [embeddingsReady, setEmbeddingsReady] = useState(false);
+  const [isSearching, setIsSearching] = useState(false);
+  const [projectFilter, setProjectFilter] = useState(options.projectFilter ?? null);
+  const loadSessions = useCallback(() => {
+    try {
+      const loaded = projectFilter ? listHumanSessionsByProject(projectFilter) : listHumanSessions();
+      setAllSessions(loaded);
+      setSessions(loaded);
+      setError(null);
+    } catch (err) {
+      setError(String(err));
+    } finally {
+      setLoading(false);
+    }
+  }, [projectFilter]);
+  const initEmbeddings = useCallback(async () => {
+    if (isReady()) {
+      setEmbeddingsReady(true);
+      return;
+    }
+    try {
+      await initializeEmbeddings();
+      setEmbeddingsReady(true);
+    } catch {
+      setEmbeddingsReady(false);
+    }
+  }, []);
+  useEffect(() => {
+    loadSessions();
+    initEmbeddings();
+  }, [loadSessions, initEmbeddings]);
+  useEffect(() => {
+    loadSessions();
+  }, [projectFilter, loadSessions]);
+  const search = useCallback(async (query) => {
+    if (!query.trim()) {
+      setSessions(allSessions);
+      setIsSearching(false);
+      return;
+    }
+    if (!embeddingsReady) {
+      const filtered = allSessions.filter(
+        (s) => s.title.toLowerCase().includes(query.toLowerCase()) || s.summary && s.summary.toLowerCase().includes(query.toLowerCase())
+      );
+      setSessions(filtered);
+      setIsSearching(true);
+      return;
+    }
+    try {
+      setLoading(true);
+      const queryEmbedding = await getEmbedding(query);
+      const results = searchSessions(queryEmbedding, 20);
+      setSessions(results);
+      setIsSearching(true);
+    } catch (err) {
+      setError(String(err));
+      const filtered = allSessions.filter(
+        (s) => s.title.toLowerCase().includes(query.toLowerCase()) || s.summary && s.summary.toLowerCase().includes(query.toLowerCase())
+      );
+      setSessions(filtered);
+    } finally {
+      setLoading(false);
+    }
+  }, [allSessions, embeddingsReady]);
+  const clearSearch = useCallback(() => {
+    setSessions(allSessions);
+    setIsSearching(false);
+  }, [allSessions]);
+  const deleteSessionHandler = useCallback((id) => {
+    const deleted = deleteSession(id);
+    if (deleted) {
+      setAllSessions((prev) => prev.filter((s) => s.id !== id));
+      setSessions((prev) => prev.filter((s) => s.id !== id));
+    }
+  }, []);
+  const getSessionById = useCallback((id) => {
+    return getSession(id);
+  }, []);
+  return {
+    sessions,
+    loading,
+    error,
+    embeddingsReady,
+    projectFilter,
+    setProjectFilter,
+    refresh: loadSessions,
+    search,
+    clearSearch,
+    deleteSession: deleteSessionHandler,
+    getSessionById
+  };
+}
+
+// src/ui/App.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var App = ({ onResume, projectFilter: initialProjectFilter }) => {
+  const { exit } = useApp();
+  const {
+    sessions,
+    loading,
+    embeddingsReady,
+    projectFilter,
+    setProjectFilter,
+    search,
+    clearSearch,
+    deleteSession: deleteSession2,
+    refresh
+  } = useSessions({ projectFilter: initialProjectFilter });
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [mode, setMode] = useState2("list");
+  const [statusMessage, setStatusMessage] = useState2(null);
+  const [renameValue, setRenameValue] = useState2("");
+  useEffect2(() => {
+    if (selectedIndex >= sessions.length) {
+      setSelectedIndex(Math.max(0, sessions.length - 1));
+    }
+  }, [sessions, selectedIndex]);
+  useEffect2(() => {
+    if (mode === "search" && searchQuery.length > 2) {
+      const timer = setTimeout(() => {
+        search(searchQuery);
+      }, 300);
+      return () => clearTimeout(timer);
+    } else if (mode === "search" && searchQuery.length === 0) {
+      clearSearch();
+    }
+  }, [searchQuery, mode, search, clearSearch]);
+  useEffect2(() => {
+    if (statusMessage) {
+      const timer = setTimeout(() => setStatusMessage(null), 3e3);
+      return () => clearTimeout(timer);
+    }
+  }, [statusMessage]);
+  const handleRestore = useCallback2(() => {
+    const session = sessions[selectedIndex];
+    if (!session) return;
+    if (session.sourceFile) {
+      const filename = basename4(session.sourceFile);
+      const claudeSessionId = filename.replace(".jsonl", "");
+      const projectDirName = basename4(dirname2(session.sourceFile));
+      let projectPath = null;
+      if (projectDirName.startsWith("-")) {
+        const segments = projectDirName.substring(1).split("-");
+        let currentPath = "";
+        let remainingSegments = [...segments];
+        while (remainingSegments.length > 0) {
+          let found = false;
+          for (let i = remainingSegments.length; i > 0; i--) {
+            const testSegment = remainingSegments.slice(0, i).join("-");
+            const testPath = currentPath + "/" + testSegment;
+            if (existsSync5(testPath)) {
+              currentPath = testPath;
+              remainingSegments = remainingSegments.slice(i);
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            currentPath = currentPath + "/" + remainingSegments.join("-");
+            break;
+          }
+        }
+        if (currentPath && existsSync5(currentPath)) {
+          projectPath = currentPath;
+        }
+      }
+      if (onResume) {
+        onResume(claudeSessionId, projectPath);
+        exit();
+      }
+    } else {
+      setStatusMessage("No source file - cannot resume this session");
+    }
+  }, [sessions, selectedIndex, onResume, exit]);
+  const handleDelete = useCallback2(() => {
+    const session = sessions[selectedIndex];
+    if (session) {
+      deleteSession2(session.id);
+      setStatusMessage(`Deleted: ${session.customTitle || session.title}`);
+      setMode("list");
+    }
+  }, [sessions, selectedIndex, deleteSession2]);
+  const handleRename = useCallback2(() => {
+    const session = sessions[selectedIndex];
+    if (session && renameValue.trim()) {
+      renameSession(session.id, renameValue.trim());
+      setStatusMessage(`Renamed to: ${renameValue.trim()}`);
+      refresh();
+    }
+    setMode("list");
+    setRenameValue("");
+  }, [sessions, selectedIndex, renameValue, refresh]);
+  const handleClearRename = useCallback2(() => {
+    const session = sessions[selectedIndex];
+    if (session && session.customTitle) {
+      renameSession(session.id, null);
+      setStatusMessage(`Cleared custom name`);
+      refresh();
+    }
+    setMode("list");
+  }, [sessions, selectedIndex, refresh]);
+  useInput((input, key) => {
+    if (input === "q" && mode !== "search" && mode !== "rename") {
+      exit();
+      return;
+    }
+    if (mode === "confirm-delete") {
+      if (input === "y" || input === "Y") {
+        handleDelete();
+      } else {
+        setMode("list");
+      }
+      return;
+    }
+    if (mode === "rename") {
+      if (key.escape) {
+        setMode("list");
+        setRenameValue("");
+        return;
+      }
+      if (key.return) {
+        handleRename();
+        return;
+      }
+      return;
+    }
+    if (mode === "search") {
+      if (key.escape) {
+        setMode("list");
+        setSearchQuery("");
+        clearSearch();
+        return;
+      }
+      if (key.return) {
+        setMode("list");
+        return;
+      }
+      return;
+    }
+    if (input === "/") {
+      setMode("search");
+      return;
+    }
+    if (input === "r") {
+      if (sessions.length > 0) {
+        const session = sessions[selectedIndex];
+        setRenameValue(session?.customTitle || "");
+        setMode("rename");
+      }
+      return;
+    }
+    if (input === "R") {
+      handleClearRename();
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((prev) => Math.min(sessions.length - 1, prev + 1));
+      return;
+    }
+    if (key.return) {
+      handleRestore();
+      return;
+    }
+    if (input === "d") {
+      if (sessions.length > 0) {
+        setMode("confirm-delete");
+      }
+      return;
+    }
+    if (input === "f") {
+      if (projectFilter) {
+        setProjectFilter(null);
+        setStatusMessage("Filter cleared - showing all sessions");
+      } else {
+        const session = sessions[selectedIndex];
+        if (session?.projectPath) {
+          setProjectFilter(session.projectPath);
+          setStatusMessage(`Filtering to: ${basename4(session.projectPath)}`);
+        } else {
+          setStatusMessage("No folder for this session");
+        }
+      }
+      setSelectedIndex(0);
+      return;
+    }
+  });
+  const handleSearchChange = useCallback2((value) => {
+    setSearchQuery(value);
+    setSelectedIndex(0);
+  }, []);
+  if (loading && sessions.length === 0) {
+    return /* @__PURE__ */ jsxs5(Box5, { padding: 1, children: [
+      /* @__PURE__ */ jsx5(Spinner, { type: "dots" }),
+      /* @__PURE__ */ jsx5(Text5, { children: " Loading sessions..." })
+    ] });
+  }
+  const selectedSession = sessions[selectedIndex] || null;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx5(Header, { embeddingsReady, projectFilter }),
+    /* @__PURE__ */ jsx5(
+      SearchInput,
+      {
+        value: searchQuery,
+        onChange: handleSearchChange,
+        isFocused: mode === "search"
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      SessionList,
+      {
+        sessions,
+        selectedIndex,
+        onSelect: setSelectedIndex
+      }
+    ),
+    /* @__PURE__ */ jsx5(Preview, { session: selectedSession }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: mode === "confirm-delete" ? /* @__PURE__ */ jsxs5(Text5, { color: "yellow", children: [
+      'Delete "',
+      selectedSession?.customTitle || selectedSession?.title,
+      '"? [y/n]'
+    ] }) : mode === "rename" ? /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: "magenta", children: "Rename: " }),
+      /* @__PURE__ */ jsx5(
+        TextInput2,
+        {
+          value: renameValue,
+          onChange: setRenameValue,
+          placeholder: "Enter new name..."
+        }
+      ),
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "  [Enter] Save  [Esc] Cancel" })
+    ] }) : statusMessage ? /* @__PURE__ */ jsx5(Text5, { color: "green", children: statusMessage }) : /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "[\u2191\u2193/jk] Navigate  [Enter] Resume  [f] Filter folder  [r] Rename  [d] Delete  [/] Search  [q] Quit" }) })
+  ] });
+};
+
+// src/commands/save.ts
+import chalk from "chalk";
+async function saveCommand(options) {
+  console.log(chalk.cyan("Scanning for Claude Code sessions..."));
+  let embeddingsReady = isReady();
+  if (!embeddingsReady) {
+    console.log(chalk.dim("Initializing embedding model..."));
+    try {
+      await initializeEmbeddings();
+      embeddingsReady = true;
+    } catch (err) {
+      console.log(chalk.yellow("Warning: Could not initialize embeddings."));
+      console.log(chalk.yellow("Semantic search will not be available."));
+    }
+  }
+  const sessions = findSessionFiles();
+  if (sessions.length === 0) {
+    console.log(chalk.red("No Claude Code sessions found."));
+    console.log(chalk.dim("Looking in:"));
+    console.log(chalk.dim("  ~/.claude/projects/"));
+    console.log(chalk.dim("  ~/.claude/sessions/"));
+    console.log(chalk.dim("\nUse Claude Code first, then run: cmem save --latest"));
+    return;
+  }
+  console.log(chalk.green(`Found ${sessions.length} session(s)`));
+  let sessionToSave = options.latest ? getMostRecentSession() : sessions[0];
+  if (!sessionToSave) {
+    console.log(chalk.red("No valid session found."));
+    return;
+  }
+  if (sessionExists(sessionToSave.rawData)) {
+    console.log(chalk.yellow("This session has already been saved."));
+    return;
+  }
+  const firstUserMsg = sessionToSave.messages.find((m) => m.role === "user");
+  const title = options.title || (firstUserMsg ? generateTitle(firstUserMsg.content) : "Untitled Session");
+  const summary = generateSummary(sessionToSave.messages);
+  console.log(chalk.dim(`Title: ${title}`));
+  console.log(chalk.dim(`Messages: ${sessionToSave.messages.length}`));
+  console.log(chalk.dim(`Project: ${sessionToSave.projectPath || "Unknown"}`));
+  const sessionId = createSession({
+    title,
+    summary,
+    projectPath: sessionToSave.projectPath || void 0,
+    rawData: sessionToSave.rawData,
+    messages: sessionToSave.messages
+  });
+  console.log(chalk.green(`Session saved with ID: ${sessionId.slice(0, 8)}`));
+  if (embeddingsReady) {
+    console.log(chalk.dim("Generating embedding..."));
+    try {
+      const embeddingText = createEmbeddingText(title, summary, sessionToSave.messages);
+      const embedding = await getEmbedding(embeddingText);
+      storeEmbedding(sessionId, embedding);
+      console.log(chalk.green("Embedding stored for semantic search."));
+    } catch (err) {
+      console.log(chalk.yellow("Failed to generate embedding. Semantic search may not work for this session."));
+    }
+  }
+  console.log(chalk.green("\nSession saved successfully!"));
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+async function listCommand(options = {}) {
+  const sessions = options.all ? listSessions() : listHumanSessions();
+  if (sessions.length === 0) {
+    console.log(chalk2.yellow("No saved sessions."));
+    console.log(chalk2.dim("Run: cmem save --latest"));
+    return;
+  }
+  console.log(chalk2.cyan(`Saved Sessions (${sessions.length})
+`));
+  console.log(
+    chalk2.dim(
+      "ID".padEnd(10) + "Title".padEnd(40) + "Msgs".padEnd(6) + "Updated".padEnd(10) + "Project"
+    )
+  );
+  console.log(chalk2.dim("\u2500".repeat(90)));
+  for (const session of sessions) {
+    const id = shortId(session.id);
+    const title = truncate(session.title, 38);
+    const msgs = String(session.messageCount).padStart(4);
+    const updated = formatTimeAgo(session.updatedAt);
+    const project = session.projectPath ? truncate(session.projectPath, 25) : chalk2.dim("\u2014");
+    console.log(
+      chalk2.white(id.padEnd(10)) + title.padEnd(40) + chalk2.dim(msgs.padEnd(6)) + chalk2.dim(updated.padEnd(10)) + chalk2.dim(project)
+    );
+  }
+  console.log(chalk2.dim("\n\u2500".repeat(90)));
+  console.log(chalk2.dim("Use: cmem restore <id> to restore a session"));
+}
+
+// src/commands/search.ts
+import chalk3 from "chalk";
+async function searchCommand(query) {
+  console.log(chalk3.cyan(`Searching for: "${query}"...
+`));
+  if (!isReady()) {
+    console.log(chalk3.dim("Initializing embedding model..."));
+    try {
+      await initializeEmbeddings((progress) => {
+        if (progress.status === "downloading" && progress.progress !== void 0) {
+          process.stdout.write(`\r${chalk3.dim(`Downloading model... ${Math.round(progress.progress)}%`)}`);
+        }
+      });
+      console.log(chalk3.green("\r\u2713 Model ready                    \n"));
+    } catch (err) {
+      console.log(chalk3.red("Failed to initialize embedding model."));
+      console.log(chalk3.dim(String(err)));
+      return;
+    }
+  }
+  try {
+    const queryEmbedding = await getEmbedding(query);
+    const results = searchSessions(queryEmbedding, 10);
+    if (results.length === 0) {
+      console.log(chalk3.yellow("No matching sessions found."));
+      console.log(chalk3.dim("Try a different search query or save more sessions."));
+      return;
+    }
+    console.log(chalk3.green(`Found ${results.length} matching session(s)
+`));
+    console.log(
+      chalk3.dim(
+        "ID".padEnd(10) + "Title".padEnd(40) + "Msgs".padEnd(6) + "Updated"
+      )
+    );
+    console.log(chalk3.dim("\u2500".repeat(70)));
+    for (const session of results) {
+      const id = shortId(session.id);
+      const title = truncate(session.title, 38);
+      const msgs = String(session.messageCount).padStart(4);
+      const updated = formatTimeAgo(session.updatedAt);
+      console.log(
+        chalk3.white(id.padEnd(10)) + title.padEnd(40) + chalk3.dim(msgs.padEnd(6)) + chalk3.dim(updated)
+      );
+      if (session.summary) {
+        console.log(chalk3.dim("  " + truncate(session.summary, 65)));
+      }
+    }
+    console.log(chalk3.dim("\n\u2500".repeat(70)));
+    console.log(chalk3.dim("Use: cmem restore <id> to restore a session"));
+  } catch (err) {
+    console.log(chalk3.red("Search failed."));
+    console.log(chalk3.dim(String(err)));
+  }
+}
+
+// src/commands/restore.ts
+import chalk4 from "chalk";
+
+// src/utils/clipboard.ts
+import clipboard from "clipboardy";
+async function copyToClipboard(text) {
+  await clipboard.write(text);
+}
+
+// src/commands/restore.ts
+async function restoreCommand(id, options) {
+  let session = getSession(id);
+  if (!session) {
+    const sessions = listSessions();
+    const match = sessions.find((s) => s.id.startsWith(id));
+    if (match) {
+      session = match;
+    }
+  }
+  if (!session) {
+    console.log(chalk4.red(`Session not found: ${id}`));
+    console.log(chalk4.dim("Run: cmem list to see available sessions"));
+    return;
+  }
+  const messages = getSessionMessages(session.id);
+  const format = options.format || "context";
+  let output;
+  switch (format) {
+    case "json":
+      output = formatAsJson(session, messages);
+      break;
+    case "markdown":
+      output = formatAsMarkdown(session, messages);
+      break;
+    case "context":
+    default:
+      output = formatAsContext(session, messages);
+      break;
+  }
+  if (options.copy) {
+    await copyToClipboard(output);
+    console.log(chalk4.green("Session context copied to clipboard!"));
+    console.log(chalk4.dim(`Session: ${session.title}`));
+    console.log(chalk4.dim(`Messages: ${messages.length}`));
+  } else {
+    console.log(output);
+  }
+}
+function formatAsContext(session, messages) {
+  const lines = [];
+  lines.push("# Previous Session Context");
+  lines.push("");
+  lines.push(`**Session:** ${session.title}`);
+  if (session.projectPath) {
+    lines.push(`**Project:** ${session.projectPath}`);
+  }
+  lines.push(`**Messages:** ${messages.length} total (showing last ${Math.min(messages.length, MAX_MESSAGES_FOR_CONTEXT)})`);
+  lines.push("");
+  lines.push("---");
+  lines.push("");
+  lines.push("## Conversation History");
+  lines.push("");
+  const recentMessages = messages.slice(-MAX_MESSAGES_FOR_CONTEXT);
+  for (const msg of recentMessages) {
+    const roleLabel = msg.role === "user" ? "**User:**" : "**Claude:**";
+    lines.push(roleLabel);
+    lines.push(msg.content);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("*Continue this conversation in Claude Code*");
+  return lines.join("\n");
+}
+function formatAsMarkdown(session, messages) {
+  const lines = [];
+  lines.push(`# ${session.title}`);
+  lines.push("");
+  if (session.projectPath) {
+    lines.push(`**Project:** ${session.projectPath}`);
+    lines.push("");
+  }
+  if (session.summary) {
+    lines.push("## Summary");
+    lines.push(session.summary);
+    lines.push("");
+  }
+  lines.push("## Conversation");
+  lines.push("");
+  for (const msg of messages) {
+    lines.push(`### ${msg.role === "user" ? "User" : "Claude"}`);
+    lines.push(`*${msg.timestamp}*`);
+    lines.push("");
+    lines.push(msg.content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatAsJson(session, messages) {
+  return JSON.stringify(
+    {
+      session: {
+        id: session.id,
+        title: session.title,
+        projectPath: session.projectPath,
+        summary: session.summary,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt
+      },
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+        timestamp: m.timestamp
+      }))
+    },
+    null,
+    2
+  );
+}
+
+// src/commands/delete.ts
+import chalk5 from "chalk";
+async function deleteCommand(id) {
+  let session = getSession(id);
+  if (!session) {
+    const sessions = listSessions();
+    const match = sessions.find((s) => s.id.startsWith(id));
+    if (match) {
+      session = match;
+    }
+  }
+  if (!session) {
+    console.log(chalk5.red(`Session not found: ${id}`));
+    console.log(chalk5.dim("Run: cmem list to see available sessions"));
+    return;
+  }
+  const deleted = deleteSession(session.id);
+  if (deleted) {
+    console.log(chalk5.green(`Deleted session: ${shortId(session.id)} - ${session.title}`));
+  } else {
+    console.log(chalk5.red("Failed to delete session."));
+  }
+}
+
+// src/commands/stats.ts
+import chalk6 from "chalk";
+import { statSync as statSync2, existsSync as existsSync6 } from "fs";
+async function statsCommand() {
+  console.log(chalk6.cyan("cmem Storage Statistics\n"));
+  const stats = getStats();
+  console.log(chalk6.white("Database:"));
+  console.log(`  Sessions:    ${formatNumber(stats.sessionCount)}`);
+  console.log(`  Messages:    ${formatNumber(stats.messageCount)}`);
+  console.log(`  Embeddings:  ${formatNumber(stats.embeddingCount)}`);
+  if (existsSync6(DB_PATH)) {
+    const dbStats = statSync2(DB_PATH);
+    console.log(`  DB Size:     ${formatBytes(dbStats.size)}`);
+  }
+  console.log(`  Location:    ${CMEM_DIR}`);
+  console.log("");
+  console.log(chalk6.white("Embeddings:"));
+  const modelCached = isModelCached();
+  if (modelCached) {
+    console.log(`  Model:       ${chalk6.green(EMBEDDING_MODEL)}`);
+    console.log(`  Location:    ${MODELS_DIR}`);
+  } else {
+    console.log(`  Model:       ${chalk6.yellow("Not downloaded")}`);
+    console.log(chalk6.dim("  Run cmem setup to download the embedding model"));
+  }
+  console.log("");
+  console.log(chalk6.white("Coverage:"));
+  const coveragePercent = stats.sessionCount > 0 ? Math.round(stats.embeddingCount / stats.sessionCount * 100) : 0;
+  console.log(`  Semantic:    ${coveragePercent}% of sessions have embeddings`);
+  if (coveragePercent < 100 && stats.sessionCount > 0) {
+    console.log(chalk6.dim("  Run cmem watch to generate missing embeddings"));
+  }
+}
+
+// src/commands/watch.ts
+import chalk7 from "chalk";
+import chokidar from "chokidar";
+import { statSync as statSync3, existsSync as existsSync7, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join4, dirname as dirname3, basename as basename5 } from "path";
+var spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner2 = class {
+  interval = null;
+  frameIndex = 0;
+  message;
+  constructor(message) {
+    this.message = message;
+  }
+  start() {
+    process.stdout.write(`  ${spinnerFrames[0]} ${this.message}`);
+    this.interval = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % spinnerFrames.length;
+      process.stdout.write(`\r  ${chalk7.cyan(spinnerFrames[this.frameIndex])} ${this.message}`);
+    }, 80);
+  }
+  update(message) {
+    this.message = message;
+    process.stdout.write(`\r  ${chalk7.cyan(spinnerFrames[this.frameIndex])} ${this.message}                              `);
+  }
+  succeed(message) {
+    this.stop();
+    console.log(`\r  ${chalk7.green("\u2713")} ${message || this.message}                              `);
+  }
+  fail(message) {
+    this.stop();
+    console.log(`\r  ${chalk7.red("\u2717")} ${message || this.message}                              `);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+};
+var processingDebounce = /* @__PURE__ */ new Map();
+var DEBOUNCE_MS = 2e3;
+async function watchCommand(options) {
+  const verbose = options.verbose ?? false;
+  const embedThreshold = options.embedThreshold ?? 500;
+  console.log(chalk7.cyan("\u{1F50D} cmem watch - Monitoring Claude Code sessions\n"));
+  const modelSpinner = new Spinner2("Initializing embedding model...");
+  modelSpinner.start();
+  try {
+    await initializeEmbeddings((progress) => {
+      if (progress.status === "downloading" && progress.progress !== void 0) {
+        const fileName = progress.file ? progress.file.split("/").pop() : "model";
+        modelSpinner.update(`Downloading ${fileName}... ${Math.round(progress.progress)}%`);
+      } else if (progress.status === "loading") {
+        modelSpinner.update("Loading model...");
+      }
+    });
+    modelSpinner.succeed("Embedding model ready");
+  } catch (err) {
+    modelSpinner.fail("Could not initialize embeddings");
+    console.log(chalk7.yellow("  Sessions will be saved but not vectorized.\n"));
+  }
+  const embeddingsReady = isReady();
+  console.log("");
+  const scanSpinner = new Spinner2("Scanning for existing sessions...");
+  scanSpinner.start();
+  const existingFiles = findAllSessionFiles(CLAUDE_DIR);
+  const totalFiles = existingFiles.length;
+  const statsBefore = getStats();
+  const alreadyIndexed = statsBefore.sessionCount;
+  const needsIndexing = totalFiles - alreadyIndexed;
+  if (totalFiles === 0) {
+    scanSpinner.succeed("No Claude Code sessions found yet");
+  } else if (needsIndexing <= 0) {
+    scanSpinner.succeed(`Found ${totalFiles} sessions (all indexed)`);
+  } else {
+    scanSpinner.update(`Found ${totalFiles} sessions, indexing ${needsIndexing} new...`);
+    let processed = 0;
+    let newlyIndexed = 0;
+    for (const filePath of existingFiles) {
+      processed++;
+      const wasNew = await processSessionFile(filePath, embeddingsReady, embedThreshold, false, true);
+      if (wasNew) newlyIndexed++;
+      const percent = Math.round(processed / totalFiles * 100);
+      scanSpinner.update(`Indexing sessions... ${percent}% (${processed}/${totalFiles})`);
+    }
+    scanSpinner.succeed(`Indexed ${totalFiles} sessions (${newlyIndexed} new, ${totalFiles - newlyIndexed} updated)`);
+  }
+  console.log("");
+  console.log(chalk7.dim(`Watching: ${CLAUDE_DIR}`));
+  console.log(chalk7.dim(`Embed threshold: ${embedThreshold} chars
+`));
+  const watcher = chokidar.watch(CLAUDE_DIR, {
+    persistent: true,
+    ignoreInitial: true,
+    // We already processed existing files above
+    depth: 10,
+    awaitWriteFinish: {
+      stabilityThreshold: 1e3,
+      pollInterval: 100
+    }
+  });
+  watcher.on("add", (filePath) => {
+    if (!filePath.endsWith(".jsonl")) return;
+    if (filePath.includes("/subagents/")) {
+      if (verbose) console.log(chalk7.dim(`[skip agent] ${filePath}`));
+      return;
+    }
+    if (verbose) console.log(chalk7.dim(`[new] ${filePath}`));
+    debouncedProcess(filePath, embeddingsReady, embedThreshold, verbose);
+  });
+  watcher.on("change", (filePath) => {
+    if (!filePath.endsWith(".jsonl")) return;
+    if (filePath.includes("/subagents/")) {
+      if (verbose) console.log(chalk7.dim(`[skip agent] ${filePath}`));
+      return;
+    }
+    if (verbose) console.log(chalk7.dim(`[changed] ${filePath}`));
+    debouncedProcess(filePath, embeddingsReady, embedThreshold, verbose);
+  });
+  watcher.on("error", (error) => {
+    console.error(chalk7.red("Watcher error:"), error);
+  });
+  watcher.on("ready", () => {
+    console.log(chalk7.green("\u2713 Watching for session changes..."));
+    console.log(chalk7.dim("Press Ctrl+C to stop\n"));
+  });
+  process.on("SIGINT", () => {
+    console.log(chalk7.dim("\nShutting down watcher..."));
+    watcher.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    watcher.close();
+    process.exit(0);
+  });
+}
+function findAllSessionFiles(dir) {
+  const files = [];
+  if (!existsSync7(dir)) return files;
+  function scanDir(currentDir, depth = 0) {
+    if (depth > 10) return;
+    try {
+      const entries = readdirSync2(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join4(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "subagents") continue;
+          scanDir(fullPath, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  scanDir(dir);
+  return files;
+}
+function debouncedProcess(filePath, embeddingsReady, embedThreshold, verbose) {
+  const existing = processingDebounce.get(filePath);
+  if (existing) {
+    clearTimeout(existing);
+  }
+  const timer = setTimeout(async () => {
+    processingDebounce.delete(filePath);
+    await processSessionFile(filePath, embeddingsReady, embedThreshold, verbose);
+  }, DEBOUNCE_MS);
+  processingDebounce.set(filePath, timer);
+}
+async function processSessionFile(filePath, embeddingsReady, embedThreshold, verbose, forceMetadataUpdate = false) {
+  try {
+    const messages = parseSessionFile(filePath);
+    if (messages.length === 0) {
+      if (verbose) console.log(chalk7.dim(`  Skipping empty session: ${filePath}`));
+      return false;
+    }
+    const stats = statSync3(filePath);
+    const fileMtime = stats.mtime.toISOString();
+    const existingSession = getSessionBySourceFile(filePath);
+    const sessionId_from_file = basename5(filePath, ".jsonl");
+    const agentMessages = loadSubagentMessages2(dirname3(filePath), sessionId_from_file);
+    const allMessages = [...messages, ...agentMessages];
+    const contentLength = allMessages.reduce((sum, m) => sum + m.content.length, 0);
+    const firstUserMsg = messages.find((m) => m.role === "user");
+    const title = firstUserMsg ? generateTitle(firstUserMsg.content) : "Untitled Session";
+    const summary = generateSummary(messages);
+    const rawData = JSON.stringify({ filePath, messages, mtime: fileMtime });
+    const projectPath = getProjectPathFromIndex(filePath, sessionId_from_file);
+    const metadata = extractSessionMetadata(filePath);
+    const isAutomated = metadata.isSidechain || metadata.isMeta;
+    let sessionId;
+    let isNew = false;
+    if (existingSession) {
+      sessionId = existingSession.id;
+      const needsMetadataUpdate = forceMetadataUpdate || !existingSession.isSidechain && !existingSession.isAutomated && isAutomated;
+      if (existingSession.messageCount !== messages.length || needsMetadataUpdate) {
+        updateSession(sessionId, {
+          title,
+          summary,
+          rawData,
+          messages,
+          isSidechain: metadata.isSidechain,
+          isAutomated
+        });
+        if (verbose) {
+          const automatedTag = isAutomated ? chalk7.dim(" [auto]") : "";
+          console.log(chalk7.blue(`\u21BB Updated: ${title} (${messages.length} msgs)${automatedTag}`));
+        }
+      }
+    } else {
+      isNew = true;
+      sessionId = createSession({
+        title,
+        summary,
+        projectPath,
+        sourceFile: filePath,
+        rawData,
+        messages,
+        isSidechain: metadata.isSidechain,
+        isAutomated
+      });
+      if (verbose) {
+        const automatedTag = isAutomated ? chalk7.dim(" [auto]") : "";
+        console.log(chalk7.green(`\u2713 Saved: ${title} (${messages.length} msgs)${automatedTag}`));
+      }
+    }
+    if (embeddingsReady) {
+      const shouldEmbed = needsReembedding(sessionId, contentLength, embedThreshold);
+      if (shouldEmbed) {
+        try {
+          const embeddingText = createEmbeddingText(title, summary, allMessages);
+          const embedding = await getEmbedding(embeddingText);
+          storeEmbedding(sessionId, embedding);
+          updateEmbeddingState(sessionId, contentLength, fileMtime);
+          if (verbose) {
+            const agentCount = agentMessages.length;
+            const agentInfo = agentCount > 0 ? ` (+${agentCount} agent msgs)` : "";
+            console.log(chalk7.dim(`  Embedded: ${title}${agentInfo}`));
+          }
+        } catch (err) {
+          if (verbose) {
+            console.log(chalk7.yellow(`  Failed to embed: ${title}`));
+            console.log(chalk7.dim(`    ${err}`));
+          }
+        }
+      }
+    }
+    return isNew;
+  } catch (err) {
+    if (verbose) console.log(chalk7.red(`Error processing ${filePath}:`), err);
+    return false;
+  }
+}
+function loadSubagentMessages2(projectDirPath, parentSessionId) {
+  const subagentsDir = join4(projectDirPath, parentSessionId, "subagents");
+  if (!existsSync7(subagentsDir)) return [];
+  const messages = [];
+  try {
+    const agentFiles = readdirSync2(subagentsDir).filter((f) => f.endsWith(".jsonl"));
+    for (const agentFile of agentFiles) {
+      const agentPath = join4(subagentsDir, agentFile);
+      const agentMessages = parseSessionFile(agentPath);
+      messages.push(...agentMessages);
+    }
+  } catch {
+  }
+  return messages;
+}
+function getProjectPathFromIndex(filePath, sessionId) {
+  const projectDir = dirname3(filePath);
+  const indexPath = join4(projectDir, "sessions-index.json");
+  if (!existsSync7(indexPath)) return null;
+  try {
+    const content = readFileSync2(indexPath, "utf-8");
+    const index = JSON.parse(content);
+    const entry = index.entries.find((e) => e.sessionId === sessionId);
+    return entry?.projectPath || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/mcp.ts
+import chalk8 from "chalk";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/utils/claude-cli.ts
+import { spawn } from "child_process";
+import { execSync } from "child_process";
+function getClaudePath() {
+  try {
+    const result = execSync("which claude", { encoding: "utf-8" }).trim();
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+function parseStreamJsonLine(line) {
+  if (!line.trim()) return null;
+  try {
+    const data = JSON.parse(line);
+    if (data.type === "assistant") {
+      if (data.message?.content && Array.isArray(data.message.content)) {
+        const textBlocks = [];
+        for (const block of data.message.content) {
+          if (block.type === "text" && block.text) {
+            textBlocks.push(block.text);
+          }
+        }
+        if (textBlocks.length > 0) {
+          return { type: "text", content: textBlocks.join("\n") };
+        }
+      }
+    } else if (data.type === "content_block_delta") {
+      if (data.delta?.type === "text_delta" && data.delta.text) {
+        return { type: "text", content: data.delta.text };
+      }
+    } else if (data.type === "result") {
+      if (data.is_error) {
+        return { type: "error", content: data.result || "Unknown error" };
+      }
+      const usage = data.usage || {};
+      const inputTokens = (usage.input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+      const outputTokens = usage.output_tokens || 0;
+      return {
+        type: "done",
+        inputTokens,
+        outputTokens,
+        costUsd: data.total_cost_usd,
+        durationMs: data.duration_ms
+      };
+    } else if (data.type === "error") {
+      return {
+        type: "error",
+        content: data.error?.message || JSON.stringify(data.error) || "Unknown error"
+      };
+    }
+    return { type: "skip" };
+  } catch {
+    return null;
+  }
+}
+async function runClaudePrompt(prompt, options = {}) {
+  const claudePath = getClaudePath();
+  if (!claudePath) {
+    return {
+      success: false,
+      content: "",
+      error: "Claude CLI not found. Please install Claude Code CLI."
+    };
+  }
+  const { model = "haiku" } = options;
+  const args = [
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    // Required when using stream-json with -p
+    "--model",
+    model,
+    "--permission-mode",
+    "plan"
+    // Read-only, no tools needed for summarization
+  ];
+  return new Promise((resolve) => {
+    const childProcess = spawn(claudePath, args, {
+      env: {
+        ...process.env,
+        CI: "true"
+        // Prevent interactive prompts
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    childProcess.stdin?.end();
+    let buffer = "";
+    const textChunks = [];
+    let finalResult = null;
+    let errorContent = "";
+    childProcess.stdout?.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const chunk = parseStreamJsonLine(line);
+        if (chunk) {
+          if (chunk.type === "text" && chunk.content) {
+            textChunks.push(chunk.content);
+          } else if (chunk.type === "done") {
+            finalResult = chunk;
+          } else if (chunk.type === "error" && chunk.content) {
+            errorContent = chunk.content;
+          }
+        }
+      }
+    });
+    childProcess.stderr?.on("data", (data) => {
+      const text = data.toString().toLowerCase();
+      if (text.includes("error") || text.includes("failed")) {
+        errorContent = data.toString().trim();
+      }
+    });
+    childProcess.on("close", (code) => {
+      if (buffer.trim()) {
+        const chunk = parseStreamJsonLine(buffer);
+        if (chunk) {
+          if (chunk.type === "text" && chunk.content) {
+            textChunks.push(chunk.content);
+          } else if (chunk.type === "done") {
+            finalResult = chunk;
+          } else if (chunk.type === "error" && chunk.content) {
+            errorContent = chunk.content;
+          }
+        }
+      }
+      const content = textChunks.join("");
+      if (errorContent && !content) {
+        resolve({
+          success: false,
+          content: "",
+          error: errorContent
+        });
+      } else {
+        resolve({
+          success: code === 0 && content.length > 0,
+          content,
+          error: errorContent || void 0,
+          inputTokens: finalResult?.inputTokens,
+          outputTokens: finalResult?.outputTokens,
+          costUsd: finalResult?.costUsd,
+          durationMs: finalResult?.durationMs
+        });
+      }
+    });
+    childProcess.on("error", (err) => {
+      resolve({
+        success: false,
+        content: "",
+        error: err.message
+      });
+    });
+    setTimeout(() => {
+      childProcess.kill("SIGTERM");
+      resolve({
+        success: false,
+        content: textChunks.join(""),
+        error: "Request timed out after 60 seconds"
+      });
+    }, 6e4);
+  });
+}
+function isClaudeCliAvailable() {
+  return getClaudePath() !== null;
+}
+
+// src/mcp/server.ts
+function createMcpServer() {
+  const server = new Server(
+    {
+      name: "cmem",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "search_sessions",
+          description: "Semantic search across all saved Claude Code conversation sessions. Use this to find past conversations about specific topics, projects, or problems. Returns matching sessions ranked by relevance.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: 'Natural language search query. Examples: "React hooks discussion", "database migration", "authentication implementation"'
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results to return (default: 5)"
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "list_sessions",
+          description: "List all saved Claude Code conversation sessions, ordered by most recently updated. Use this to browse available sessions or find recent conversations.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              limit: {
+                type: "number",
+                description: "Maximum number of sessions to return (default: 10)"
+              }
+            }
+          }
+        },
+        {
+          name: "get_session",
+          description: "Get detailed information about a specific conversation session, including its full message history. Use this after finding a session via search or list.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string",
+                description: "The session ID to retrieve"
+              },
+              includeMessages: {
+                type: "boolean",
+                description: "Whether to include the full message history (default: true)"
+              },
+              messageLimit: {
+                type: "number",
+                description: "Maximum number of messages to include (default: 50, from most recent)"
+              }
+            },
+            required: ["sessionId"]
+          }
+        },
+        {
+          name: "get_session_context",
+          description: "Get a formatted context summary from a past session that can be used to continue or reference that conversation. Returns key information and recent messages in a readable format.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              sessionId: {
+                type: "string",
+                description: "The session ID to get context from"
+              },
+              messageCount: {
+                type: "number",
+                description: "Number of recent messages to include (default: 10)"
+              }
+            },
+            required: ["sessionId"]
+          }
+        },
+        {
+          name: "search_and_summarize",
+          description: "Search past Claude Code sessions and get an AI-generated summary tailored to your specific question. This spawns a separate Claude instance to read and synthesize the relevant sessions, keeping your main context clean. Use this when you need insights from past conversations.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: 'Your question or topic to search for. Examples: "What did we decide about the database schema?", "How did we implement authentication?", "What was the bug fix for the login issue?"'
+              },
+              sessionLimit: {
+                type: "number",
+                description: "Maximum number of sessions to analyze (default: 3)"
+              },
+              model: {
+                type: "string",
+                enum: ["haiku", "sonnet", "opus"],
+                description: "Model to use for summarization (default: haiku for speed)"
+              }
+            },
+            required: ["query"]
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case "search_sessions":
+          return await handleSearchSessions(args);
+        case "list_sessions":
+          return await handleListSessions(args);
+        case "get_session":
+          return await handleGetSession(
+            args
+          );
+        case "get_session_context":
+          return await handleGetSessionContext(
+            args
+          );
+        case "search_and_summarize":
+          return await handleSearchAndSummarize(
+            args
+          );
+        default:
+          return {
+            content: [{ type: "text", text: `Unknown tool: ${name}` }],
+            isError: true
+          };
+      }
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error: ${String(error)}` }],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function handleSearchSessions(args) {
+  const { query, limit = 5 } = args;
+  if (!isReady()) {
+    try {
+      await initializeEmbeddings();
+    } catch {
+      const allSessions = listSessions(100);
+      const queryLower = query.toLowerCase();
+      const filtered = allSessions.filter(
+        (s) => s.title.toLowerCase().includes(queryLower) || s.summary && s.summary.toLowerCase().includes(queryLower)
+      ).slice(0, limit);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatSessionList(filtered, `Text search results for "${query}" (embeddings unavailable)`)
+          }
+        ]
+      };
+    }
+  }
+  const queryEmbedding = await getEmbedding(query);
+  const results = searchSessions(queryEmbedding, limit);
+  return {
+    content: [
+      {
+        type: "text",
+        text: formatSessionList(results, `Semantic search results for "${query}"`)
+      }
+    ]
+  };
+}
+async function handleListSessions(args) {
+  const { limit = 10 } = args;
+  const sessions = listSessions(limit);
+  return {
+    content: [
+      {
+        type: "text",
+        text: formatSessionList(sessions, "Recent sessions")
+      }
+    ]
+  };
+}
+async function handleGetSession(args) {
+  const { sessionId, includeMessages = true, messageLimit = 50 } = args;
+  let session = getSession(sessionId) || getSessionByIdPrefix(sessionId);
+  if (!session) {
+    return {
+      content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+      isError: true
+    };
+  }
+  const lines = [
+    `# Session: ${session.title}`,
+    "",
+    `**ID:** ${session.id}`,
+    `**Created:** ${session.createdAt}`,
+    `**Updated:** ${session.updatedAt} (${formatTimeAgo(session.updatedAt)})`,
+    `**Messages:** ${session.messageCount}`
+  ];
+  if (session.projectPath) {
+    lines.push(`**Project:** ${session.projectPath}`);
+  }
+  if (session.summary) {
+    lines.push("", "## Summary", session.summary);
+  }
+  if (includeMessages) {
+    const messages = getSessionMessages(session.id);
+    const recentMessages = messages.slice(-messageLimit);
+    lines.push("", "## Messages", "");
+    for (const msg of recentMessages) {
+      lines.push(`### ${msg.role === "user" ? "User" : "Assistant"}`);
+      lines.push(msg.content);
+      lines.push("");
+    }
+    if (messages.length > messageLimit) {
+      lines.push(`_...${messages.length - messageLimit} earlier messages omitted_`);
+    }
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+async function handleGetSessionContext(args) {
+  const { sessionId, messageCount = 10 } = args;
+  let session = getSession(sessionId) || getSessionByIdPrefix(sessionId);
+  if (!session) {
+    return {
+      content: [{ type: "text", text: `Session not found: ${sessionId}` }],
+      isError: true
+    };
+  }
+  const messages = getSessionMessages(session.id);
+  const recentMessages = messages.slice(-messageCount);
+  const lines = [
+    "# Context from Previous Session",
+    "",
+    `**Topic:** ${session.title}`
+  ];
+  if (session.projectPath) {
+    lines.push(`**Project:** ${session.projectPath}`);
+  }
+  if (session.summary) {
+    lines.push("", "## Summary", session.summary);
+  }
+  lines.push(
+    "",
+    "## Recent Conversation",
+    `_Last ${recentMessages.length} of ${messages.length} messages_`,
+    ""
+  );
+  for (const msg of recentMessages) {
+    const role = msg.role === "user" ? "**User:**" : "**Assistant:**";
+    lines.push(role);
+    lines.push(truncate(msg.content, 2e3));
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+async function handleSearchAndSummarize(args) {
+  const { query, sessionLimit = 3, model = "haiku" } = args;
+  if (!isClaudeCliAvailable()) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Claude CLI not found. This tool requires Claude Code CLI to be installed."
+        }
+      ],
+      isError: true
+    };
+  }
+  if (!isReady()) {
+    try {
+      await initializeEmbeddings();
+    } catch {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Embedding model not available. Please run `cmem setup` first."
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+  const queryEmbedding = await getEmbedding(query);
+  const sessions = searchSessions(queryEmbedding, sessionLimit);
+  if (sessions.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No relevant sessions found for: "${query}"`
+        }
+      ]
+    };
+  }
+  const sessionContents = [];
+  for (const session of sessions) {
+    const messages = getSessionMessages(session.id);
+    if (messages.length === 0) continue;
+    const sessionText = [
+      `## Session: ${session.title}`,
+      `Project: ${session.projectPath || "Unknown"}`,
+      `Date: ${session.updatedAt}`,
+      "",
+      ...messages.slice(-20).map((m) => `**${m.role}:** ${truncate(m.content, 1500)}`)
+    ].join("\n");
+    sessionContents.push(sessionText);
+  }
+  if (sessionContents.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Found ${sessions.length} sessions but they appear to be empty.`
+        }
+      ]
+    };
+  }
+  const prompt = `You are analyzing past Claude Code conversation sessions to answer a user's question.
+
+<user_question>
+${query}
+</user_question>
+
+<past_sessions>
+${sessionContents.join("\n\n---\n\n")}
+</past_sessions>
+
+Based on the past sessions above, provide a concise and helpful answer to the user's question. Focus on:
+1. Directly answering their question with specific details from the conversations
+2. Mentioning which session(s) the information came from
+3. Highlighting any relevant decisions, code snippets, or conclusions
+
+If the sessions don't contain relevant information to answer the question, say so clearly.
+
+Keep your response concise but complete.`;
+  const response = await runClaudePrompt(prompt, { model });
+  if (!response.success) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error generating summary: ${response.error || "Unknown error"}`
+        }
+      ],
+      isError: true
+    };
+  }
+  const resultLines = [
+    response.content,
+    "",
+    "---",
+    `*Analyzed ${sessions.length} session(s) | Model: ${model}${response.durationMs ? ` | ${(response.durationMs / 1e3).toFixed(1)}s` : ""}${response.outputTokens ? ` | ${response.outputTokens} tokens` : ""}*`
+  ];
+  return {
+    content: [{ type: "text", text: resultLines.join("\n") }]
+  };
+}
+function formatSessionList(sessions, header) {
+  if (sessions.length === 0) {
+    return `${header}
+
+No sessions found.`;
+  }
+  const lines = [header, ""];
+  for (const session of sessions) {
+    lines.push(`### ${session.title}`);
+    lines.push(`- **ID:** \`${session.id.slice(0, 8)}\` (use this to get full session)`);
+    lines.push(`- **Messages:** ${session.messageCount}`);
+    lines.push(`- **Updated:** ${formatTimeAgo(session.updatedAt)}`);
+    if (session.projectPath) {
+      lines.push(`- **Project:** ${session.projectPath}`);
+    }
+    if (session.summary) {
+      lines.push(`- **Summary:** ${truncate(session.summary, 150)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function startMcpServer() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/mcp.ts
+async function mcpCommand() {
+  console.error(chalk8.cyan("Starting cmem MCP server..."));
+  try {
+    await startMcpServer();
+  } catch (err) {
+    console.error(chalk8.red("MCP server error:"), err);
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+init_install();
+
+// src/commands/setup.ts
+import chalk10 from "chalk";
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join6, dirname as dirname5, basename as basename6 } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname5(__filename);
+var CLAUDE_JSON_PATH = join6(homedir3(), ".claude.json");
+var CLAUDE_SETTINGS_PATH = join6(homedir3(), ".claude", "settings.json");
+var CMEM_DIR2 = join6(homedir3(), ".cmem");
+var SETUP_MARKER = join6(CMEM_DIR2, ".setup-complete");
+var CMEM_PERMISSIONS = [
+  "mcp__cmem__search_sessions",
+  "mcp__cmem__list_sessions",
+  "mcp__cmem__get_session",
+  "mcp__cmem__get_session_context",
+  "mcp__cmem__search_and_summarize"
+];
+var spinnerFrames2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner3 = class {
+  interval = null;
+  frameIndex = 0;
+  message;
+  constructor(message) {
+    this.message = message;
+  }
+  start() {
+    process.stdout.write(`  ${spinnerFrames2[0]} ${this.message}`);
+    this.interval = setInterval(() => {
+      this.frameIndex = (this.frameIndex + 1) % spinnerFrames2.length;
+      process.stdout.write(`\r  ${chalk10.cyan(spinnerFrames2[this.frameIndex])} ${this.message}`);
+    }, 80);
+  }
+  update(message) {
+    this.message = message;
+    process.stdout.write(`\r  ${chalk10.cyan(spinnerFrames2[this.frameIndex])} ${this.message}                    `);
+  }
+  succeed(message) {
+    this.stop();
+    console.log(`\r  ${chalk10.green("\u2713")} ${message || this.message}                    `);
+  }
+  fail(message) {
+    this.stop();
+    console.log(`\r  ${chalk10.red("\u2717")} ${message || this.message}                    `);
+  }
+  warn(message) {
+    this.stop();
+    console.log(`\r  ${chalk10.yellow("!")} ${message || this.message}                    `);
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+};
+function printBanner(version) {
+  const magenta = chalk10.magenta;
+  const cyan = chalk10.cyan;
+  const dim = chalk10.dim;
+  console.log("");
+  console.log(magenta("   \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557"));
+  console.log(magenta("  \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551"));
+  console.log(magenta("  \u2588\u2588\u2551      \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551"));
+  console.log(magenta("  \u2588\u2588\u2551      \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551"));
+  console.log(magenta("  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551"));
+  console.log(magenta("   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D     \u255A\u2550\u255D"));
+  console.log("");
+  console.log(cyan(`  cmem v${version}`));
+  console.log(dim("  Persistent memory & semantic search for Claude Code"));
+  console.log(dim("  Created by Colby McHenry"));
+  console.log("");
+}
+async function promptChoice(question, options, defaultChoice = 1) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  options.forEach((opt, i) => {
+    console.log(chalk10.dim(`  ${i + 1}) ${opt}`));
+  });
+  console.log("");
+  return new Promise((resolve) => {
+    rl.question(chalk10.white(`  Choice [${defaultChoice}]: `), (answer) => {
+      rl.close();
+      const num = parseInt(answer.trim(), 10);
+      if (isNaN(num) || num < 1 || num > options.length) {
+        resolve(defaultChoice);
+      } else {
+        resolve(num);
+      }
+    });
+  });
+}
+async function promptYesNo(question, defaultYes = true) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultYes ? "[Y/n]" : "[y/N]";
+  return new Promise((resolve) => {
+    rl.question(chalk10.white(`  ${question} ${chalk10.dim(hint)} `), (answer) => {
+      rl.close();
+      const normalized = answer.toLowerCase().trim();
+      if (normalized === "") {
+        resolve(defaultYes);
+      } else {
+        resolve(normalized === "y" || normalized === "yes");
+      }
+    });
+  });
+}
+function isRunningViaNpx() {
+  const execPath = process.argv[1] || "";
+  return execPath.includes("_npx") || execPath.includes(".npm/_cacache");
+}
+function isGloballyInstalled() {
+  try {
+    const result = execSync3("which cmem 2>/dev/null || where cmem 2>/dev/null", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return result.length > 0 && !result.includes("_npx");
+  } catch {
+    return false;
+  }
+}
+function getCmemVersion() {
+  try {
+    const packagePath = join6(__dirname, "..", "package.json");
+    if (existsSync9(packagePath)) {
+      const pkg = JSON.parse(readFileSync3(packagePath, "utf-8"));
+      return pkg.version || "0.1.0";
+    }
+  } catch {
+  }
+  return "0.1.0";
+}
+function getInstalledVersion() {
+  try {
+    const result = execSync3("cmem --version 2>/dev/null", {
+      encoding: "utf-8"
+    }).trim();
+    return result;
+  } catch {
+    return null;
+  }
+}
+async function setupCommand() {
+  const currentVersion = getCmemVersion();
+  const installedVersion = getInstalledVersion();
+  const isGlobal = isGloballyInstalled();
+  const isNpx = isRunningViaNpx();
+  printBanner(currentVersion);
+  if (!isGlobal || isNpx) {
+    console.log(chalk10.yellow("  Install cmem globally?"));
+    console.log(chalk10.dim("  Makes the `cmem` command available everywhere\n"));
+    const choice = await promptChoice("", [
+      "Yes - install globally via npm",
+      "No - I'll use npx each time"
+    ], 1);
+    if (choice === 1) {
+      console.log(chalk10.dim("\n  Installing @colbymchenry/cmem globally...\n"));
+      try {
+        execSync3("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
+        console.log(chalk10.green("\n  \u2713 Installed globally\n"));
+      } catch {
+        console.log(chalk10.red("\n  \u2717 Failed to install. Try: sudo npm install -g @colbymchenry/cmem\n"));
+      }
+    } else {
+      console.log(chalk10.dim("\n  Skipped. Use `npx @colbymchenry/cmem` to run.\n"));
+    }
+  } else if (installedVersion && installedVersion !== currentVersion) {
+    console.log(chalk10.yellow(`  Update available: ${installedVersion} \u2192 ${currentVersion}`));
+    const shouldUpdate = await promptYesNo("Update to latest version?");
+    if (shouldUpdate) {
+      console.log(chalk10.dim("\n  Updating @colbymchenry/cmem...\n"));
+      try {
+        execSync3("npm install -g @colbymchenry/cmem", { stdio: "inherit" });
+        console.log(chalk10.green("\n  \u2713 Updated\n"));
+      } catch {
+        console.log(chalk10.red("\n  \u2717 Failed to update\n"));
+      }
+    } else {
+      console.log("");
+    }
+  } else {
+    console.log(chalk10.green("  \u2713 cmem is installed globally\n"));
+  }
+  console.log(chalk10.yellow("  Semantic search setup"));
+  console.log(chalk10.dim("  Enables searching conversations by meaning\n"));
+  const modelSpinner = new Spinner3("Checking embedding model...");
+  modelSpinner.start();
+  const cached = isModelCached();
+  if (cached) {
+    modelSpinner.succeed("Embedding model ready");
+  } else {
+    modelSpinner.update("Downloading embedding model (~130MB)...");
+    try {
+      await initializeEmbeddings((progress) => {
+        if (progress.status === "downloading" && progress.progress !== void 0) {
+          const percent = Math.round(progress.progress);
+          const fileName = progress.file ? progress.file.split("/").pop() : "";
+          modelSpinner.update(`Downloading ${fileName}... ${percent}%`);
+        } else if (progress.status === "loading") {
+          modelSpinner.update("Loading model...");
+        }
+      });
+      modelSpinner.succeed("Embedding model ready");
+    } catch (err) {
+      modelSpinner.fail("Failed to download embedding model");
+      console.log(chalk10.dim(`  Error: ${err}
+`));
+    }
+  }
+  console.log("");
+  const daemonInstalled = existsSync9(
+    join6(homedir3(), "Library", "LaunchAgents", "com.cmem.watch.plist")
+  );
+  const isUpdating = installedVersion && installedVersion !== currentVersion;
+  if (daemonInstalled && !isUpdating) {
+    console.log(chalk10.green("  \u2713 Auto-start daemon is installed"));
+    try {
+      execSync3("launchctl load ~/Library/LaunchAgents/com.cmem.watch.plist 2>/dev/null", { stdio: "ignore" });
+    } catch {
+    }
+    console.log("");
+  } else if (daemonInstalled && isUpdating && process.platform === "darwin") {
+    console.log(chalk10.yellow("  Updating daemon..."));
+    try {
+      const { installCommand: installCommand2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+      await installCommand2();
+    } catch {
+      console.log(chalk10.red("  \u2717 Failed to update daemon"));
+      console.log(chalk10.dim("  Try manually: cmem install\n"));
+    }
+  } else if (process.platform === "darwin") {
+    console.log(chalk10.yellow("  Auto-start daemon?"));
+    console.log(chalk10.dim("  Syncs Claude Code sessions in the background\n"));
+    const choice = await promptChoice("", [
+      "Yes - start on login (recommended)",
+      "No - I'll run `cmem watch` manually"
+    ], 1);
+    if (choice === 1) {
+      try {
+        const { installCommand: installCommand2 } = await Promise.resolve().then(() => (init_install(), install_exports));
+        await installCommand2();
+      } catch (err) {
+        console.log(chalk10.red("  \u2717 Failed to install daemon"));
+        console.log(chalk10.dim("  Try manually: cmem install\n"));
+      }
+    } else {
+      console.log(chalk10.dim("\n  Skipped. Run `cmem watch` when needed.\n"));
+    }
+  }
+  const mcpConfigured = isMcpConfigured();
+  if (mcpConfigured) {
+    console.log(chalk10.green("  \u2713 MCP server configured in Claude Code\n"));
+  } else {
+    console.log(chalk10.yellow("  Add MCP server to Claude Code?"));
+    console.log(chalk10.dim("  Lets Claude search your past conversations\n"));
+    const choice = await promptChoice("", [
+      "Yes - configure automatically (recommended)",
+      "No - I'll configure it manually"
+    ], 1);
+    if (choice === 1) {
+      const success = configureMcpServer();
+      if (success) {
+        console.log(chalk10.green("\n  \u2713 Added MCP server to ~/.claude.json"));
+        console.log(chalk10.green("  \u2713 Added permissions to ~/.claude/settings.json"));
+        console.log(chalk10.dim("  Restart Claude Code or run /mcp to connect\n"));
+      } else {
+        console.log(chalk10.red("\n  \u2717 Failed to configure MCP server\n"));
+      }
+    } else {
+      console.log(chalk10.dim("\n  Skipped.\n"));
+    }
+  }
+  console.log(chalk10.yellow("  Initial session indexing"));
+  console.log(chalk10.dim("  Scanning and indexing your existing Claude Code conversations\n"));
+  await indexExistingSessions();
+  if (!existsSync9(CMEM_DIR2)) {
+    mkdirSync3(CMEM_DIR2, { recursive: true });
+  }
+  writeFileSync2(SETUP_MARKER, (/* @__PURE__ */ new Date()).toISOString());
+  console.log(chalk10.magenta("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550"));
+  console.log(chalk10.green.bold("\n  \u2713 Setup complete!\n"));
+  console.log(chalk10.white("  Commands:"));
+  console.log(chalk10.dim("    cmem              Browse sessions (TUI)"));
+  console.log(chalk10.dim('    cmem search "X"   Semantic search'));
+  console.log(chalk10.dim("    cmem watch        Start sync daemon"));
+  console.log(chalk10.dim("    cmem stats        Storage statistics"));
+  console.log(chalk10.dim("    cmem --help       All commands"));
+  console.log(chalk10.white("\n  MCP Tools (available to Claude):"));
+  console.log(chalk10.dim("    search_sessions   Find past conversations"));
+  console.log(chalk10.dim("    get_session       Retrieve full history"));
+  console.log(chalk10.dim("    list_sessions     Browse recent sessions"));
+  if (process.platform === "darwin") {
+    const plistExists = existsSync9(join6(homedir3(), "Library", "LaunchAgents", "com.cmem.watch.plist"));
+    if (plistExists) {
+      console.log(chalk10.green("\n  \u{1F680} Daemon is now syncing your sessions in the background!"));
+    }
+  }
+  console.log("");
+}
+function isMcpConfigured() {
+  if (!existsSync9(CLAUDE_JSON_PATH)) {
+    return false;
+  }
+  try {
+    const config = JSON.parse(readFileSync3(CLAUDE_JSON_PATH, "utf-8"));
+    return !!config.mcpServers?.cmem;
+  } catch {
+    return false;
+  }
+}
+function configureMcpServer() {
+  try {
+    let claudeJson = {};
+    if (existsSync9(CLAUDE_JSON_PATH)) {
+      try {
+        claudeJson = JSON.parse(readFileSync3(CLAUDE_JSON_PATH, "utf-8"));
+      } catch {
+        claudeJson = {};
+      }
+    }
+    if (!claudeJson.mcpServers) {
+      claudeJson.mcpServers = {};
+    }
+    claudeJson.mcpServers.cmem = {
+      type: "stdio",
+      command: "cmem",
+      args: ["mcp"]
+    };
+    writeFileSync2(CLAUDE_JSON_PATH, JSON.stringify(claudeJson, null, 2) + "\n");
+    const claudeDir = dirname5(CLAUDE_SETTINGS_PATH);
+    if (!existsSync9(claudeDir)) {
+      mkdirSync3(claudeDir, { recursive: true });
+    }
+    let settings = {};
+    if (existsSync9(CLAUDE_SETTINGS_PATH)) {
+      try {
+        settings = JSON.parse(readFileSync3(CLAUDE_SETTINGS_PATH, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (!settings.permissions) {
+      settings.permissions = {};
+    }
+    if (!settings.permissions.allow) {
+      settings.permissions.allow = [];
+    }
+    for (const perm of CMEM_PERMISSIONS) {
+      if (!settings.permissions.allow.includes(perm)) {
+        settings.permissions.allow.push(perm);
+      }
+    }
+    writeFileSync2(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2) + "\n");
+    return true;
+  } catch (err) {
+    console.error(chalk10.red("Error configuring MCP:"), err);
+    return false;
+  }
+}
+function shouldRunSetup() {
+  const isNpx = isRunningViaNpx();
+  const setupComplete = existsSync9(SETUP_MARKER);
+  const isGlobal = isGloballyInstalled();
+  if (isNpx) return true;
+  if (!isGlobal && !setupComplete) return true;
+  const currentVersion = getCmemVersion();
+  const installedVersion = getInstalledVersion();
+  if (installedVersion && installedVersion !== currentVersion) {
+    return true;
+  }
+  return false;
+}
+function findAllSessionFiles2(dir) {
+  const files = [];
+  if (!existsSync9(dir)) return files;
+  function scanDir(currentDir, depth = 0) {
+    if (depth > 10) return;
+    try {
+      const entries = readdirSync3(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join6(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "subagents") continue;
+          scanDir(fullPath, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          files.push(fullPath);
+        }
+      }
+    } catch {
+    }
+  }
+  scanDir(dir);
+  return files;
+}
+async function indexSessionFile(filePath, embeddingsReady) {
+  try {
+    const messages = parseSessionFile(filePath);
+    if (messages.length === 0) return false;
+    const existing = getSessionBySourceFile(filePath);
+    if (existing) return false;
+    const stats = statSync4(filePath);
+    const fileMtime = stats.mtime.toISOString();
+    const firstUserMsg = messages.find((m) => m.role === "user");
+    const title = firstUserMsg ? generateTitle(firstUserMsg.content) : "Untitled Session";
+    const summary = generateSummary(messages);
+    const rawData = JSON.stringify({ filePath, messages, mtime: fileMtime });
+    const sessionId_from_file = basename6(filePath, ".jsonl");
+    const sessionId = createSession({
+      title,
+      summary,
+      projectPath: null,
+      sourceFile: filePath,
+      rawData,
+      messages
+    });
+    if (embeddingsReady) {
+      const contentLength = messages.reduce((sum, m) => sum + m.content.length, 0);
+      const shouldEmbed = needsReembedding(sessionId, contentLength, 500);
+      if (shouldEmbed) {
+        try {
+          const embeddingText = createEmbeddingText(title, summary, messages);
+          const embedding = await getEmbedding(embeddingText);
+          storeEmbedding(sessionId, embedding);
+          updateEmbeddingState(sessionId, contentLength, fileMtime);
+        } catch {
+        }
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function indexExistingSessions() {
+  const spinner = new Spinner3("Scanning for sessions...");
+  spinner.start();
+  const sessionFiles = findAllSessionFiles2(CLAUDE_DIR);
+  const totalFiles = sessionFiles.length;
+  if (totalFiles === 0) {
+    spinner.succeed("No Claude Code sessions found yet");
+    console.log(chalk10.dim("  Start using Claude Code, then run cmem to see your sessions\n"));
+    return;
+  }
+  const statsBefore = getStats();
+  const alreadyIndexed = statsBefore.sessionCount;
+  if (alreadyIndexed >= totalFiles) {
+    spinner.succeed(`Found ${totalFiles} sessions (all indexed)`);
+    console.log("");
+    return;
+  }
+  spinner.update(`Found ${totalFiles} sessions, indexing...`);
+  const embeddingsReady = isReady();
+  let processed = 0;
+  let newlyIndexed = 0;
+  for (const filePath of sessionFiles) {
+    processed++;
+    const wasNew = await indexSessionFile(filePath, embeddingsReady);
+    if (wasNew) newlyIndexed++;
+    const percent = Math.round(processed / totalFiles * 100);
+    spinner.update(`Indexing sessions... ${percent}% (${processed}/${totalFiles})`);
+  }
+  spinner.succeed(`Indexed ${totalFiles} sessions (${newlyIndexed} new)`);
+  const statsAfter = getStats();
+  console.log(chalk10.dim(`  ${statsAfter.sessionCount} sessions, ${statsAfter.embeddingCount} with embeddings
+`));
+}
+
+// src/cli.ts
+var sessionToResume = null;
+function getVersion() {
+  try {
+    const __filename2 = fileURLToPath2(import.meta.url);
+    const __dirname2 = dirname6(__filename2);
+    const packagePath = join7(__dirname2, "..", "package.json");
+    if (existsSync10(packagePath)) {
+      const pkg = JSON.parse(readFileSync4(packagePath, "utf-8"));
+      return pkg.version || "0.1.0";
+    }
+  } catch {
+  }
+  return "0.1.0";
+}
+program.name("cmem").description("Persistent session storage for Claude Code CLI").version(getVersion()).option("-l, --local", "Filter to sessions from current directory").action(async (options) => {
+  if (shouldRunSetup()) {
+    await setupCommand();
+    return;
+  }
+  const handleResume = (sessionId, projectPath) => {
+    sessionToResume = { sessionId, projectPath };
+  };
+  const projectFilter = options.local ? process.cwd() : null;
+  const { waitUntilExit } = render(React2.createElement(App, { onResume: handleResume, projectFilter }));
+  await waitUntilExit();
+  if (sessionToResume) {
+    const args = ["--resume", sessionToResume.sessionId];
+    const cwd = sessionToResume.projectPath || process.cwd();
+    console.log(`
+Resuming session in: ${cwd}
+`);
+    const child = spawn2("claude", args, {
+      cwd,
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("error", (err) => {
+      console.error("Failed to start Claude:", err.message);
+      process.exit(1);
+    });
+    child.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+  }
+});
+program.command("setup").description("Run interactive setup wizard").action(async () => {
+  await setupCommand();
+});
+program.command("save").description("Save a Claude Code session").option("-t, --title <title>", "Custom title").option("--latest", "Auto-save most recent session").action(async (options) => {
+  await saveCommand(options);
+});
+program.command("list").description("List saved sessions (human sessions only by default)").option("-a, --all", "Show all sessions including automated ones").action(async (options) => {
+  await listCommand(options);
+});
+program.command("search <query>").description("Semantic search across sessions").action(async (query) => {
+  await searchCommand(query);
+});
+program.command("restore <id>").description("Restore a session").option("--copy", "Copy to clipboard").option("--format <format>", "Output format: context|json|markdown", "context").action(async (id, options) => {
+  await restoreCommand(id, options);
+});
+program.command("delete <id>").description("Delete a session").action(async (id) => {
+  await deleteCommand(id);
+});
+program.command("stats").description("Show storage statistics").action(async () => {
+  await statsCommand();
+});
+program.command("watch").description("Watch for Claude Code session changes and auto-sync").option("-v, --verbose", "Show detailed output").option("--embed-threshold <chars>", "Re-embed after this many new chars", "500").action(async (options) => {
+  await watchCommand({
+    verbose: options.verbose,
+    embedThreshold: parseInt(options.embedThreshold, 10)
+  });
+});
+program.command("mcp").description("Start MCP server for Claude Code integration").action(async () => {
+  await mcpCommand();
+});
+program.command("install").description("Install watch daemon to run at system startup (macOS)").action(async () => {
+  await installCommand();
+});
+program.command("uninstall").description("Remove watch daemon from system startup").action(async () => {
+  await uninstallCommand();
+});
+program.command("status").description("Check watch daemon status").action(async () => {
+  await statusCommand();
+});
+program.parse();
+//# sourceMappingURL=cli.js.map