codesesh 0.2.0 → 0.3.0

package/README.md

@@ -19,9 +19,11 @@ Your browser will open at `http://localhost:4321` with all your sessions ready t
 ## Features
 
 - **Unified Timeline** — Browse sessions across all your AI agents in a single, searchable interface
+- **Full-Text Search** — Search across session titles and conversation content with highlighted matches
 - **Dashboard & Activity Trends** — See totals, daily activity, agent distribution, and recent sessions
 - **Full Conversation Replay** — Read every message, tool call, and reasoning step exactly as it happened
 - **Cost & Token Visibility** — See exactly how many tokens and dollars each session consumed
+- **SQLite-Backed Cache & Search Index** — Restore session lists quickly and reuse the same local store for search
 - **Zero Configuration** — Just run it. CodeSesh auto-discovers everything on your filesystem
 - **100% Local & Private** — Nothing leaves your machine. No accounts, no cloud sync, no telemetry
 - **Live Refresh** — Local session changes are picked up automatically while the server is running
@@ -45,7 +47,7 @@ npx codesesh
 # Choose a custom port
 npx codesesh --port 8080
 
-# Only show sessions from the last 3 days
+# Only show sessions active in the last 3 days
 npx codesesh --days 3
 
 # Jump directly to a session
@@ -69,11 +71,11 @@ npx codesesh --trace
 | Flag        | Alias | Default | Description                                                 |
 | ----------- | ----- | ------- | ----------------------------------------------------------- |
 | `--port`    | `-p`  | `4321`  | HTTP server port                                            |
-| `--days`    | `-d`  | `7`     | Only include sessions from the last N days (`0` = all time) |
+| `--days`    | `-d`  | `7`     | Only include sessions active in the last N days (`0` = all time) |
 | `--cwd`     | —     | —       | Filter to sessions from a project directory                 |
 | `--agent`   | `-a`  | all     | Filter to specific agent(s), comma-separated                |
-| `--from`    | —     | —       | Sessions created after this date `YYYY-MM-DD`               |
-| `--to`      | —     | —       | Sessions created before this date `YYYY-MM-DD`              |
+| `--from`    | —     | —       | Sessions active after this date `YYYY-MM-DD`                |
+| `--to`      | —     | —       | Sessions active before this date `YYYY-MM-DD`               |
 | `--session` | `-s`  | —       | Directly open a session (`agent://session-id`)              |
 | `--json`    | `-j`  | `false` | Output JSON and exit (no server)                            |
 | `--no-open` | —     | `false` | Don't auto-open the browser                                 |

package/dist/{chunk-2UNXB2D3.js → chunk-UQI7CTEK.js}

@@ -10,16 +10,18 @@ import { readFileSync } from "fs";
 import { basename } from "path";
 import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { join as join3 } from "path";
+import { mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
 import { createRequire } from "module";
 import { createHash } from "crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join4, basename as basename3, dirname as dirname2 } from "path";
+import { join as join4, basename as basename3, dirname as dirname3 } from "path";
 import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join5, basename as basename4 } from "path";
 import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
 import { join as join6, normalize } from "path";
 import { resolve, sep } from "path";
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync7, rmSync, unlinkSync } from "fs";
 import { join as join7 } from "path";
 import { homedir as homedir2 } from "os";
 var registrations = [];
@@ -982,6 +984,19 @@ function openDbReadOnly(dbPath) {
     return null;
   }
 }
+function openDb(dbPath) {
+  if (!DatabaseConstructor) return null;
+  try {
+    mkdirSync(dirname2(dbPath), { recursive: true });
+    const db = DatabaseConstructor(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("foreign_keys = ON");
+    return db;
+  } catch {
+    return null;
+  }
+}
 function isSqliteAvailable() {
   return DatabaseConstructor !== null;
 }
@@ -1340,7 +1355,7 @@ var KimiAgent = class extends BaseAgent {
   parseSessionDir(sessionDir) {
     try {
       const sessionId = basename3(sessionDir);
-      const projectHash = basename3(dirname2(sessionDir));
+      const projectHash = basename3(dirname3(sessionDir));
       const contextFile = join4(sessionDir, "context.jsonl");
       const wireFile = join4(sessionDir, "wire.jsonl");
       if (!existsSync4(contextFile) && !existsSync4(wireFile)) return null;
@@ -3492,89 +3507,438 @@ registerAgent({
   icon: "/icon/agent/cursor.svg",
   create: () => new CursorAgent()
 });
-var CACHE_VERSION = 2;
-var CACHE_FILENAME = "scan-cache.json";
+var CACHE_VERSION = 3;
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+var CACHE_FILENAME = "codesesh.db";
+var LEGACY_CACHE_FILENAME = "scan-cache.json";
+function getCacheDir() {
+  return join7(homedir2(), ".cache", "codesesh");
+}
 function getCachePath() {
-  return join7(homedir2(), ".cache", "codesesh", CACHE_FILENAME);
+  return join7(getCacheDir(), CACHE_FILENAME);
 }
-function ensureCacheDir() {
-  const cacheDir = join7(homedir2(), ".cache", "codesesh");
-  if (!existsSync7(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
-  }
+function getLegacyCachePath() {
+  return join7(getCacheDir(), LEGACY_CACHE_FILENAME);
 }
-function loadCachedSessions(agentName) {
+function hasCacheStorage() {
+  return existsSync7(getCachePath());
+}
+function withCacheDb(fn) {
+  const db = openDb(getCachePath());
+  if (!db) return null;
   try {
-    const cachePath = getCachePath();
-    if (!existsSync7(cachePath)) return null;
-    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-    if (data.version !== CACHE_VERSION) return null;
-    const entry = data.entries[agentName];
-    if (!entry) return null;
-    const CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
-    if (Date.now() - entry.timestamp > CACHE_TTL) return null;
-    return { sessions: entry.sessions, meta: entry.meta || {}, timestamp: entry.timestamp };
+    ensureSchema(db);
+    return fn(db);
   } catch {
     return null;
+  } finally {
+    db.close();
   }
 }
-function saveCachedSessions(agentName, sessions, meta = {}) {
-  try {
-    ensureCacheDir();
-    const cachePath = getCachePath();
-    let data;
-    if (existsSync7(cachePath)) {
-      try {
-        data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-        if (data.version !== CACHE_VERSION) {
-          data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
-        }
-      } catch {
-        data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
-      }
-    } else {
-      data = { version: CACHE_VERSION, entries: {}, lastScanTime: 0 };
+function ensureSchema(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS cache_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_cache (
+      agent_name TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS cached_sessions (
+      agent_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      session_json TEXT NOT NULL,
+      meta_json TEXT,
+      PRIMARY KEY (agent_name, session_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS session_documents (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_name TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      title TEXT NOT NULL,
+      directory TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER,
+      activity_time INTEGER NOT NULL,
+      content_text TEXT NOT NULL,
+      content_hash TEXT NOT NULL,
+      indexed_at INTEGER NOT NULL,
+      UNIQUE(agent_name, session_id)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_documents_fts USING fts5(
+      title,
+      content_text,
+      content='session_documents',
+      content_rowid='id'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_ai AFTER INSERT ON session_documents BEGIN
+      INSERT INTO session_documents_fts(rowid, title, content_text)
+      VALUES (new.id, new.title, new.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_ad AFTER DELETE ON session_documents BEGIN
+      INSERT INTO session_documents_fts(session_documents_fts, rowid, title, content_text)
+      VALUES ('delete', old.id, old.title, old.content_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_documents_au AFTER UPDATE ON session_documents BEGIN
+      INSERT INTO session_documents_fts(session_documents_fts, rowid, title, content_text)
+      VALUES ('delete', old.id, old.title, old.content_text);
+      INSERT INTO session_documents_fts(rowid, title, content_text)
+      VALUES (new.id, new.title, new.content_text);
+    END;
+  `);
+  const versionRow = db.prepare("SELECT value FROM cache_meta WHERE key = 'version'").get();
+  const version = Number(versionRow?.value ?? 0);
+  if (version === CACHE_VERSION) {
+    return;
+  }
+  db.exec(`
+    DELETE FROM agent_cache;
+    DELETE FROM cached_sessions;
+    DELETE FROM session_documents;
+    INSERT INTO session_documents_fts(session_documents_fts) VALUES ('rebuild');
+    INSERT INTO cache_meta(key, value)
+    VALUES ('version', '${CACHE_VERSION}')
+    ON CONFLICT(key) DO UPDATE SET value = excluded.value;
+  `);
+}
+function sessionContentHash(session) {
+  return JSON.stringify([
+    session.slug,
+    session.title,
+    session.directory,
+    session.time_created,
+    session.time_updated ?? session.time_created,
+    session.stats.message_count,
+    session.stats.total_input_tokens,
+    session.stats.total_output_tokens,
+    session.stats.total_cost,
+    session.stats.total_tokens ?? 0
+  ]);
+}
+function escapeFtsTerm(value) {
+  return value.replaceAll('"', '""');
+}
+function toFtsQuery(input) {
+  const tokens = input.match(/"[^"]+"|\S+/g) ?? [];
+  return tokens.map((token) => {
+    if (/^OR$/i.test(token)) {
+      return "OR";
     }
-    data.entries[agentName] = {
-      sessions,
-      meta,
-      timestamp: Date.now(),
-      version: CACHE_VERSION
-    };
-    data.lastScanTime = Date.now();
-    writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+    if (token.startsWith('"') && token.endsWith('"')) {
+      return `"${escapeFtsTerm(token.slice(1, -1))}"`;
+    }
+    return `"${escapeFtsTerm(token)}"`;
+  }).join(" ");
+}
+function appendPlainText(value, chunks) {
+  if (value == null) return;
+  if (typeof value === "string") {
+    const normalized = value.trim();
+    if (normalized) {
+      chunks.push(normalized);
+    }
+    return;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    chunks.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      appendPlainText(item, chunks);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const nested of Object.values(value)) {
+      appendPlainText(nested, chunks);
+    }
+  }
+}
+function buildSessionContent(session) {
+  const chunks = [];
+  appendPlainText(session.title, chunks);
+  for (const message of session.messages) {
+    chunks.push(message.role);
+    appendPlainText(message.agent, chunks);
+    appendPlainText(message.model, chunks);
+    for (const part of message.parts) {
+      appendPlainText(part.type, chunks);
+      appendPlainText(part.title, chunks);
+      appendPlainText(part.nickname, chunks);
+      appendPlainText(part.tool, chunks);
+      appendPlainText(part.text, chunks);
+      appendPlainText(part.input, chunks);
+      appendPlainText(part.output, chunks);
+      appendPlainText(part.state, chunks);
+    }
+  }
+  return chunks.join("\n");
+}
+function deleteLegacyCacheFile() {
+  const legacyPath = getLegacyCachePath();
+  if (!existsSync7(legacyPath)) {
+    return;
+  }
+  try {
+    unlinkSync(legacyPath);
   } catch {
   }
 }
+function loadCachedSessions(agentName) {
+  if (!hasCacheStorage()) {
+    return null;
+  }
+  return withCacheDb((db) => {
+    const timestampRow = db.prepare("SELECT timestamp AS value FROM agent_cache WHERE agent_name = ?").get(agentName);
+    const timestamp = Number(timestampRow?.value ?? 0);
+    if (!timestamp || Date.now() - timestamp > CACHE_TTL) {
+      return null;
+    }
+    const rows = db.prepare(
+      `
+          SELECT session_json, meta_json
+          FROM cached_sessions
+          WHERE agent_name = ?
+          ORDER BY rowid
+        `
+    ).all(agentName);
+    const sessions = [];
+    const meta = {};
+    for (const row of rows) {
+      if (!row.session_json) {
+        continue;
+      }
+      const session = JSON.parse(row.session_json);
+      sessions.push(session);
+      if (row.meta_json) {
+        meta[session.id] = JSON.parse(row.meta_json);
+      }
+    }
+    return { sessions, meta, timestamp };
+  });
+}
+function saveCachedSessions(agentName, sessions, meta = {}) {
+  withCacheDb((db) => {
+    const deleteAgent = db.prepare("DELETE FROM agent_cache WHERE agent_name = ?");
+    const deleteSessions = db.prepare("DELETE FROM cached_sessions WHERE agent_name = ?");
+    const upsertAgent = db.prepare(`
+      INSERT INTO agent_cache(agent_name, timestamp)
+      VALUES (?, ?)
+      ON CONFLICT(agent_name) DO UPDATE SET timestamp = excluded.timestamp
+    `);
+    const insertSession = db.prepare(`
+      INSERT INTO cached_sessions(agent_name, session_id, session_json, meta_json)
+      VALUES (?, ?, ?, ?)
+    `);
+    const write = db.transaction(() => {
+      const timestamp = Date.now();
+      deleteAgent.run(agentName);
+      deleteSessions.run(agentName);
+      upsertAgent.run(agentName, timestamp);
+      for (const session of sessions) {
+        insertSession.run(
+          agentName,
+          session.id,
+          JSON.stringify(session),
+          meta[session.id] ? JSON.stringify(meta[session.id]) : null
+        );
+      }
+    });
+    write();
+    deleteLegacyCacheFile();
+  });
+}
 function clearCache() {
-  try {
-    const cachePath = getCachePath();
-    if (existsSync7(cachePath)) {
-      const data = {
-        version: CACHE_VERSION,
-        entries: {},
-        lastScanTime: 0
-      };
-      writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  if (!hasCacheStorage()) {
+    deleteLegacyCacheFile();
+    return;
+  }
+  withCacheDb((db) => {
+    db.exec(`
+      DELETE FROM agent_cache;
+      DELETE FROM cached_sessions;
+    `);
+  });
+  deleteLegacyCacheFile();
+  const cachePath = getCachePath();
+  const walPath = `${cachePath}-wal`;
+  const shmPath = `${cachePath}-shm`;
+  for (const filePath of [walPath, shmPath]) {
+    if (!existsSync7(filePath)) {
+      continue;
+    }
+    try {
+      rmSync(filePath, { force: true });
+    } catch {
     }
-  } catch {
   }
 }
 function getCacheInfo() {
-  try {
-    const cachePath = getCachePath();
-    if (!existsSync7(cachePath)) {
-      return { lastScanTime: null, size: 0 };
-    }
-    const data = JSON.parse(readFileSync6(cachePath, "utf-8"));
-    const size = Object.values(data.entries).reduce((sum, entry) => sum + entry.sessions.length, 0);
-    return {
-      lastScanTime: data.lastScanTime || null,
-      size
-    };
-  } catch {
+  if (!hasCacheStorage()) {
     return { lastScanTime: null, size: 0 };
   }
+  const info = withCacheDb((db) => {
+    const timestampRow = db.prepare("SELECT MAX(timestamp) AS value FROM agent_cache").get();
+    const sizeRow = db.prepare("SELECT COUNT(*) AS value FROM cached_sessions").get();
+    const lastScanTime = Number(timestampRow?.value ?? 0) || null;
+    const size = Number(sizeRow?.value ?? 0);
+    return { lastScanTime, size };
+  });
+  return info ?? { lastScanTime: null, size: 0 };
+}
+function syncSessionSearchIndex(agentName, sessions, loadSessionData) {
+  if (!hasCacheStorage()) {
+    return;
+  }
+  withCacheDb((db) => {
+    const existingRows = db.prepare(
+      "SELECT session_id, content_hash FROM session_documents WHERE agent_name = ? ORDER BY id"
+    ).all(agentName);
+    const existingMap = new Map(
+      existingRows.map((row) => [String(row.session_id), String(row.content_hash ?? "")])
+    );
+    const sessionMap = new Map(sessions.map((session) => [session.id, session]));
+    const toDelete = existingRows.map((row) => String(row.session_id)).filter((sessionId) => !sessionMap.has(sessionId));
+    const toUpsert = sessions.filter(
+      (session) => existingMap.get(session.id) !== sessionContentHash(session)
+    );
+    const loaded = toUpsert.map((session) => {
+      try {
+        const data = loadSessionData(session.id);
+        return {
+          session,
+          contentText: buildSessionContent(data),
+          contentHash: sessionContentHash(session)
+        };
+      } catch {
+        return null;
+      }
+    }).filter((entry) => entry !== null);
+    const deleteRow = db.prepare(
+      "DELETE FROM session_documents WHERE agent_name = ? AND session_id = ?"
+    );
+    const upsertRow = db.prepare(`
+      INSERT INTO session_documents(
+        agent_name,
+        session_id,
+        slug,
+        title,
+        directory,
+        time_created,
+        time_updated,
+        activity_time,
+        content_text,
+        content_hash,
+        indexed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(agent_name, session_id) DO UPDATE SET
+        slug = excluded.slug,
+        title = excluded.title,
+        directory = excluded.directory,
+        time_created = excluded.time_created,
+        time_updated = excluded.time_updated,
+        activity_time = excluded.activity_time,
+        content_text = excluded.content_text,
+        content_hash = excluded.content_hash,
+        indexed_at = excluded.indexed_at
+    `);
+    const write = db.transaction(() => {
+      for (const sessionId of toDelete) {
+        deleteRow.run(agentName, sessionId);
+      }
+      for (const entry of loaded) {
+        const activityTime = entry.session.time_updated ?? entry.session.time_created;
+        upsertRow.run(
+          agentName,
+          entry.session.id,
+          entry.session.slug,
+          entry.session.title,
+          entry.session.directory,
+          entry.session.time_created,
+          entry.session.time_updated ?? null,
+          activityTime,
+          entry.contentText,
+          entry.contentHash,
+          Date.now()
+        );
+      }
+    });
+    write();
+  });
+}
+function searchSessions(query, options = {}) {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery || !hasCacheStorage()) {
+    return [];
+  }
+  const ftsQuery = toFtsQuery(normalizedQuery);
+  const results = withCacheDb((db) => {
+    const rows = db.prepare(
+      `
+          SELECT
+            d.agent_name,
+            d.session_id,
+            d.slug,
+            d.title,
+            d.directory,
+            d.time_created,
+            d.time_updated,
+            COALESCE(
+              NULLIF(snippet(session_documents_fts, 1, '<mark>', '</mark>', ' \u2026 ', 18), ''),
+              highlight(session_documents_fts, 0, '<mark>', '</mark>')
+            ) AS snippet
+          FROM session_documents_fts
+          JOIN session_documents d ON d.id = session_documents_fts.rowid
+          WHERE session_documents_fts MATCH ?
+            AND (? IS NULL OR d.agent_name = ?)
+            AND (? IS NULL OR LOWER(d.directory) LIKE ?)
+            AND (? IS NULL OR d.activity_time >= ?)
+            AND (? IS NULL OR d.activity_time <= ?)
+          ORDER BY bm25(session_documents_fts, 8.0, 1.0), d.activity_time DESC
+          LIMIT ?
+        `
+    ).all(
+      ftsQuery,
+      options.agent ?? null,
+      options.agent ?? null,
+      options.cwd?.toLowerCase() ?? null,
+      options.cwd ? `%${options.cwd.toLowerCase()}%` : null,
+      options.from ?? null,
+      options.from ?? null,
+      options.to ?? null,
+      options.to ?? null,
+      options.limit ?? 50
+    );
+    return rows.map((row) => ({
+      agentName: String(row.agent_name),
+      session: {
+        id: String(row.session_id),
+        slug: String(row.slug),
+        title: String(row.title),
+        directory: String(row.directory),
+        time_created: Number(row.time_created),
+        time_updated: row.time_updated == null ? void 0 : Number(row.time_updated),
+        stats: {
+          message_count: 0,
+          total_input_tokens: 0,
+          total_output_tokens: 0,
+          total_cost: 0
+        }
+      },
+      snippet: String(row.snippet ?? "")
+    }));
+  });
+  return results ?? [];
 }
 function isPathScopeMatch(queryPath, sessionPath) {
   if (!sessionPath) return false;
@@ -3728,13 +4092,16 @@ export {
   resolveSessionTitle,
   perf,
   openDbReadOnly,
+  openDb,
   isSqliteAvailable,
   loadCachedSessions,
   saveCachedSessions,
   clearCache,
   getCacheInfo,
+  syncSessionSearchIndex,
+  searchSessions,
   filterSessions,
   scanSessions,
   scanSessionsAsync
 };
-//# sourceMappingURL=chunk-2UNXB2D3.js.map
+//# sourceMappingURL=chunk-UQI7CTEK.js.map