@alexzeitler/session-md 0.5.0

package/src/mcp/server.ts

@@ -0,0 +1,330 @@
+/**
+ * session-md MCP Server
+ *
+ * Exposes session search, listing, retrieval, and import as MCP tools.
+ * Shared by both stdio and HTTP transports.
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { SearchIndex } from "../search/index.ts";
+import { loadSessionMarkdownSync } from "../import/loader.ts";
+import { scanClaudeCodeSessions } from "../import/claude-code-to-md.ts";
+import { scanOpencodeSessions } from "../import/opencode-to-md.ts";
+import { scanMemorizerMemories } from "../import/memorizer-to-md.ts";
+import { importClaudeExport } from "../import/claude-export-to-md.ts";
+import { loadConfig, type Config } from "../config.ts";
+import type { SessionEntry, SourceType } from "../import/types.ts";
+
+const { version } = require("../../package.json");
+
+export type SessionStore = {
+  config: Config;
+  searchIndex: SearchIndex;
+  sessions: SessionEntry[];
+};
+
+/**
+ * Scan all configured sources and build/update the search index.
+ * Returns the populated SessionStore.
+ */
+export async function createSessionStore(): Promise<SessionStore> {
+  const config = await loadConfig();
+  const sessions: SessionEntry[] = [];
+
+  if (config.sources.claude_code) {
+    try {
+      sessions.push(...scanClaudeCodeSessions(config.sources.claude_code));
+    } catch {
+      // skip
+    }
+  }
+
+  if (config.sources.opencode) {
+    try {
+      sessions.push(...scanOpencodeSessions(config.sources.opencode));
+    } catch {
+      // skip
+    }
+  }
+
+  const asyncLoaders: Promise<SessionEntry[]>[] = [];
+
+  if (config.sources.memorizer_url) {
+    asyncLoaders.push(
+      scanMemorizerMemories(config.sources.memorizer_url).catch(() => []),
+    );
+  }
+
+  if (config.sources.claude_export) {
+    asyncLoaders.push(
+      importClaudeExport(config.sources.claude_export).catch(() => []),
+    );
+  }
+
+  if (asyncLoaders.length > 0) {
+    const results = await Promise.all(asyncLoaders);
+    for (const entries of results) {
+      sessions.push(...entries);
+    }
+  }
+
+  sessions.sort(
+    (a, b) =>
+      new Date(b.meta.created_at).getTime() -
+      new Date(a.meta.created_at).getTime(),
+  );
+
+  const searchIndex = new SearchIndex();
+  searchIndex.indexSessions(sessions);
+
+  const validIds = new Set(sessions.map((s) => s.meta.id));
+  searchIndex.cleanup(validIds);
+
+  return { config, searchIndex, sessions };
+}
+
+/**
+ * Create an MCP server with all session-md tools registered.
+ */
+export async function createMcpServer(store: SessionStore): Promise<McpServer> {
+  const server = new McpServer(
+    { name: "session-md", version },
+    {
+      instructions: [
+        `session-md provides access to ${store.sessions.length} AI chat sessions`,
+        `from Claude Code, Claude.ai exports, OpenCode, and Memorizer.`,
+        "",
+        "Tools:",
+        "  - search_sessions: Full-text search across all sessions",
+        "  - list_sessions: List sessions, optionally filtered by source",
+        "  - get_session: Retrieve full markdown content of a session by ID",
+        "  - import_sessions: Re-scan all configured sources and update the index",
+      ].join("\n"),
+    },
+  );
+
+  // --- search_sessions ---
+  server.registerTool(
+    "search_sessions",
+    {
+      title: "Search sessions",
+      description:
+        "Full-text search across all indexed AI chat sessions. Returns matching sessions with snippets.",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        query: z.string().describe("Search query (keywords, AND logic)"),
+        source: z
+          .enum(["claude-code", "claude-export", "opencode", "memorizer", "all"])
+          .optional()
+          .describe("Filter by source type (default: all)"),
+        limit: z
+          .number()
+          .optional()
+          .describe("Max results to return (default: 20)"),
+      },
+    },
+    async ({ query, source, limit }) => {
+      const results = store.searchIndex.search(
+        query,
+        source ?? "all",
+        limit ?? 20,
+      );
+
+      if (results.length === 0) {
+        return {
+          content: [{ type: "text", text: `No results found for "${query}"` }],
+        };
+      }
+
+      const lines = [
+        `Found ${results.length} result${results.length === 1 ? "" : "s"} for "${query}":\n`,
+      ];
+      for (const r of results) {
+        lines.push(`- **${r.title}** [${r.source}] (id: ${r.id})`);
+        if (r.project) lines.push(`  Project: ${r.project}`);
+        if (r.snippet) lines.push(`  ${r.snippet}`);
+        lines.push("");
+      }
+
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    },
+  );
+
+  // --- list_sessions ---
+  server.registerTool(
+    "list_sessions",
+    {
+      title: "List sessions",
+      description:
+        "List all indexed AI chat sessions, optionally filtered by source. Returns metadata (no content).",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        source: z
+          .enum(["claude-code", "claude-export", "opencode", "memorizer", "all"])
+          .optional()
+          .describe("Filter by source type (default: all)"),
+        limit: z
+          .number()
+          .optional()
+          .describe("Max results to return (default: 50)"),
+        offset: z
+          .number()
+          .optional()
+          .describe("Skip first N results (default: 0)"),
+      },
+    },
+    async ({ source, limit, offset }) => {
+      let filtered = store.sessions;
+      if (source && source !== "all") {
+        filtered = filtered.filter((s) => s.meta.source === source);
+      }
+
+      const start = offset ?? 0;
+      const end = start + (limit ?? 50);
+      const page = filtered.slice(start, end);
+
+      const lines = [
+        `${filtered.length} sessions total${source && source !== "all" ? ` (source: ${source})` : ""}, showing ${start + 1}-${Math.min(end, filtered.length)}:\n`,
+      ];
+
+      for (const s of page) {
+        lines.push(
+          `- **${s.meta.title}** [${s.meta.source}] ${s.meta.created_at} (id: ${s.meta.id})`,
+        );
+      }
+
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    },
+  );
+
+  // --- get_session ---
+  server.registerTool(
+    "get_session",
+    {
+      title: "Get session content",
+      description:
+        "Retrieve the full markdown content of a session by its ID.",
+      annotations: { readOnlyHint: true, openWorldHint: false },
+      inputSchema: {
+        id: z.string().describe("Session ID (UUID or short ID from search results)"),
+      },
+    },
+    async ({ id }) => {
+      const entry = store.sessions.find((s) => s.meta.id === id);
+      if (!entry) {
+        return {
+          content: [{ type: "text", text: `Session not found: ${id}` }],
+          isError: true,
+        };
+      }
+
+      try {
+        const md = loadSessionMarkdownSync(entry);
+        return { content: [{ type: "text", text: md }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to load session ${id}: ${err}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    },
+  );
+
+  // --- import_sessions ---
+  server.registerTool(
+    "import_sessions",
+    {
+      title: "Import sessions",
+      description:
+        "Re-scan all configured sources and update the search index. Returns import statistics.",
+      annotations: { readOnlyHint: false, openWorldHint: false },
+      inputSchema: {},
+    },
+    async () => {
+      const oldCount = store.sessions.length;
+
+      // Re-scan all sources
+      const newSessions: SessionEntry[] = [];
+
+      if (store.config.sources.claude_code) {
+        try {
+          newSessions.push(
+            ...scanClaudeCodeSessions(store.config.sources.claude_code),
+          );
+        } catch {
+          // skip
+        }
+      }
+
+      if (store.config.sources.opencode) {
+        try {
+          newSessions.push(
+            ...scanOpencodeSessions(store.config.sources.opencode),
+          );
+        } catch {
+          // skip
+        }
+      }
+
+      const asyncLoaders: Promise<SessionEntry[]>[] = [];
+
+      if (store.config.sources.memorizer_url) {
+        asyncLoaders.push(
+          scanMemorizerMemories(store.config.sources.memorizer_url).catch(
+            () => [],
+          ),
+        );
+      }
+
+      if (store.config.sources.claude_export) {
+        asyncLoaders.push(
+          importClaudeExport(store.config.sources.claude_export).catch(
+            () => [],
+          ),
+        );
+      }
+
+      if (asyncLoaders.length > 0) {
+        const results = await Promise.all(asyncLoaders);
+        for (const entries of results) {
+          newSessions.push(...entries);
+        }
+      }
+
+      newSessions.sort(
+        (a, b) =>
+          new Date(b.meta.created_at).getTime() -
+          new Date(a.meta.created_at).getTime(),
+      );
+
+      const indexed = store.searchIndex.indexSessions(newSessions);
+      const validIds = new Set(newSessions.map((s) => s.meta.id));
+      const removed = store.searchIndex.cleanup(validIds);
+
+      // Update store in-place
+      store.sessions = newSessions;
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: [
+              `Import complete.`,
+              `Sessions: ${oldCount} -> ${newSessions.length}`,
+              `Indexed: ${indexed} new/updated`,
+              `Removed: ${removed} stale`,
+            ].join("\n"),
+          },
+        ],
+      };
+    },
+  );
+
+  return server;
+}

package/src/search/index.ts

@@ -0,0 +1,235 @@
+import { Database } from "bun:sqlite";
+import { join } from "path";
+import { homedir } from "os";
+import { mkdirSync, existsSync, unlinkSync } from "fs";
+import { stripMarkdown } from "./plaintext.ts";
+import type { SessionEntry, SourceType } from "../import/types.ts";
+import { loadSessionMarkdownSync } from "../import/loader.ts";
+
+const CONFIG_DIR = join(homedir(), ".config", "session-md");
+const DB_PATH = join(CONFIG_DIR, "search-index.sqlite");
+
+export function deleteIndex(): boolean {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const p = DB_PATH + suffix;
+    if (existsSync(p)) unlinkSync(p);
+  }
+  return true;
+}
+
+export interface SearchResult {
+  id: string;
+  title: string;
+  source: SourceType;
+  project: string | null;
+  snippet: string;
+}
+
+export class SearchIndex {
+  private db: Database;
+
+  constructor() {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    this.db = new Database(DB_PATH);
+    this.db.exec("PRAGMA journal_mode=WAL");
+    this.setupSchema();
+  }
+
+  private setupSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        source TEXT NOT NULL,
+        title TEXT,
+        project TEXT,
+        content TEXT,
+        content_hash TEXT NOT NULL
+      )
+    `);
+
+    // Check if FTS table exists
+    const ftsExists = this.db
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='sessions_fts'",
+      )
+      .get();
+
+    if (!ftsExists) {
+      this.db.exec(`
+        CREATE VIRTUAL TABLE sessions_fts USING fts5(
+          title, project, content,
+          content='sessions',
+          content_rowid='rowid'
+        )
+      `);
+
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_ai AFTER INSERT ON sessions BEGIN
+          INSERT INTO sessions_fts(rowid, title, project, content)
+          VALUES (new.rowid, new.title, new.project, new.content);
+        END
+      `);
+
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_ad AFTER DELETE ON sessions BEGIN
+          INSERT INTO sessions_fts(sessions_fts, rowid, title, project, content)
+          VALUES ('delete', old.rowid, old.title, old.project, old.content);
+        END
+      `);
+
+      this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS sessions_au AFTER UPDATE ON sessions BEGIN
+          INSERT INTO sessions_fts(sessions_fts, rowid, title, project, content)
+          VALUES ('delete', old.rowid, old.title, old.project, old.content);
+          INSERT INTO sessions_fts(rowid, title, project, content)
+          VALUES (new.rowid, new.title, new.project, new.content);
+        END
+      `);
+    }
+  }
+
+  /**
+   * Index sessions incrementally. Returns count of newly indexed/updated sessions.
+   */
+  indexSessions(
+    sessions: SessionEntry[],
+    onProgress?: (current: number, total: number) => void,
+  ): number {
+    const checkStmt = this.db.prepare(
+      "SELECT content_hash FROM sessions WHERE id = ?",
+    );
+    const upsertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO sessions (id, source, title, project, content, content_hash)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+
+    let indexed = 0;
+    const toIndex: SessionEntry[] = [];
+
+    // First pass: determine what needs indexing
+    for (const entry of sessions) {
+      const existing = checkStmt.get(entry.meta.id) as
+        | { content_hash: string }
+        | null;
+      if (!existing || existing.content_hash !== entry.contentHash) {
+        toIndex.push(entry);
+      }
+    }
+
+    if (toIndex.length === 0) {
+      onProgress?.(sessions.length, sessions.length);
+      return 0;
+    }
+
+    // Second pass: index in a transaction
+    const indexBatch = this.db.transaction(() => {
+      for (const entry of toIndex) {
+        try {
+          let md: string;
+          if (entry.md) {
+            md = entry.md;
+          } else {
+            md = loadSessionMarkdownSync(entry);
+          }
+
+          const plaintext = stripMarkdown(md);
+
+          upsertStmt.run(
+            entry.meta.id,
+            entry.meta.source,
+            entry.meta.title,
+            entry.meta.project ?? null,
+            plaintext,
+            entry.contentHash,
+          );
+          indexed++;
+        } catch {
+          // Skip sessions that fail to load
+        }
+
+        onProgress?.(indexed, toIndex.length);
+      }
+    });
+
+    indexBatch();
+    return indexed;
+  }
+
+  /**
+   * Remove index entries for sessions that no longer exist.
+   */
+  cleanup(validIds: Set<string>): number {
+    const allIds = this.db
+      .prepare("SELECT id FROM sessions")
+      .all() as { id: string }[];
+
+    let removed = 0;
+    const deleteStmt = this.db.prepare("DELETE FROM sessions WHERE id = ?");
+
+    const cleanupBatch = this.db.transaction(() => {
+      for (const row of allIds) {
+        if (!validIds.has(row.id)) {
+          deleteStmt.run(row.id);
+          removed++;
+        }
+      }
+    });
+
+    cleanupBatch();
+    return removed;
+  }
+
+  /**
+   * Full-text search within a specific source (or all sources).
+   */
+  search(query: string, source?: SourceType | "all", limit = 100): SearchResult[] {
+    // Escape FTS5 special characters and build query
+    const ftsQuery = query
+      .replace(/["(){}[\]:^~!@#$%&*+=|\\<>,./;?]/g, " ")
+      .trim()
+      .split(/\s+/)
+      .filter(Boolean)
+      .map((term) => `"${term}"`)
+      .join(" AND ");
+
+    if (!ftsQuery) return [];
+
+    let sql: string;
+    let params: any[];
+
+    if (source && source !== "all") {
+      sql = `
+        SELECT s.id, s.title, s.source, s.project,
+               snippet(sessions_fts, 2, '»', '«', '…', 32) as snippet
+        FROM sessions_fts
+        JOIN sessions s ON s.rowid = sessions_fts.rowid
+        WHERE sessions_fts MATCH ?
+          AND s.source = ?
+        ORDER BY rank
+        LIMIT ?
+      `;
+      params = [ftsQuery, source, limit];
+    } else {
+      sql = `
+        SELECT s.id, s.title, s.source, s.project,
+               snippet(sessions_fts, 2, '»', '«', '…', 32) as snippet
+        FROM sessions_fts
+        JOIN sessions s ON s.rowid = sessions_fts.rowid
+        WHERE sessions_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `;
+      params = [ftsQuery, limit];
+    }
+
+    try {
+      return this.db.prepare(sql).all(...params) as SearchResult[];
+    } catch {
+      return [];
+    }
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/search/plaintext.ts

@@ -0,0 +1,47 @@
+/**
+ * Strips markdown syntax and YAML frontmatter from content,
+ * returning plain text suitable for full-text indexing.
+ */
+export function stripMarkdown(md: string): string {
+  let text = md;
+
+  // Remove YAML frontmatter
+  const fmEnd = text.indexOf("---", text.indexOf("---") + 3);
+  if (fmEnd !== -1) {
+    text = text.slice(fmEnd + 3).trimStart();
+  }
+
+  // Remove markdown headings (keep text)
+  text = text.replace(/^#{1,6}\s+/gm, "");
+
+  // Remove bold/italic markers
+  text = text.replace(/\*{1,3}([^*]+)\*{1,3}/g, "$1");
+  text = text.replace(/_{1,3}([^_]+)_{1,3}/g, "$1");
+
+  // Remove inline code backticks
+  text = text.replace(/`([^`]+)`/g, "$1");
+
+  // Remove code block fences (keep content)
+  text = text.replace(/^```[\s\S]*?^```/gm, "");
+
+  // Remove blockquote markers
+  text = text.replace(/^>\s?/gm, "");
+
+  // Remove link syntax [text](url) → text
+  text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+
+  // Remove image syntax ![alt](url)
+  text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+
+  // Remove horizontal rules
+  text = text.replace(/^[-*_]{3,}\s*$/gm, "");
+
+  // Remove list markers
+  text = text.replace(/^[\s]*[-*+]\s+/gm, "");
+  text = text.replace(/^[\s]*\d+\.\s+/gm, "");
+
+  // Collapse multiple newlines
+  text = text.replace(/\n{3,}/g, "\n\n");
+
+  return text.trim();
+}