@aeriondyseti/vector-memory-mcp 1.1.0-dev.2 → 1.1.0-dev.5

package/hooks/session-start.ts

@@ -1,100 +0,0 @@
-#!/usr/bin/env bun
-/**
- * SessionStart hook for Claude Code
- *
- * Fetches config from the running vector-memory server's /health endpoint,
- * then retrieves and outputs the latest checkpoint.
- *
- * Requires the server to be running with HTTP enabled.
- *
- * Usage in ~/.claude/settings.json:
- * {
- *   "hooks": {
- *     "SessionStart": [{
- *       "hooks": [{
- *         "type": "command",
- *         "command": "bun /path/to/vector-memory-mcp/hooks/session-start.ts"
- *       }]
- *     }]
- *   }
- * }
- */
-
-import { existsSync } from "fs";
-import { connectToDatabase } from "../src/db/connection.js";
-import { MemoryRepository } from "../src/db/memory.repository.js";
-import { EmbeddingsService } from "../src/services/embeddings.service.js";
-import { MemoryService } from "../src/services/memory.service.js";
-
-const VECTOR_MEMORY_URL = process.env.VECTOR_MEMORY_URL ?? "http://127.0.0.1:3271";
-
-interface HealthResponse {
-  status: string;
-  config: {
-    dbPath: string;
-    embeddingModel: string;
-    embeddingDimension: number;
-  };
-}
-
-async function main() {
-  // Get config from running server
-  let health: HealthResponse;
-  try {
-    const response = await fetch(`${VECTOR_MEMORY_URL}/health`);
-    if (!response.ok) {
-      throw new Error(`Server returned ${response.status}`);
-    }
-    health = await response.json();
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
-      console.log("Vector memory server not running. Starting fresh session.");
-      return;
-    }
-    throw error;
-  }
-
-  const { dbPath, embeddingModel, embeddingDimension } = health.config;
-
-  // Check if DB exists
-  if (!existsSync(dbPath)) {
-    console.log("Vector memory database not found. Starting fresh session.");
-    return;
-  }
-
-  const db = await connectToDatabase(dbPath);
-  const repository = new MemoryRepository(db);
-  const embeddings = new EmbeddingsService(embeddingModel, embeddingDimension);
-  const service = new MemoryService(repository, embeddings);
-
-  const checkpoint = await service.getLatestCheckpoint();
-
-  if (!checkpoint) {
-    console.log("No checkpoint found. Starting fresh session.");
-    return;
-  }
-
-  // Fetch referenced memories if any
-  const memoryIds = (checkpoint.metadata.memory_ids as string[] | undefined) ?? [];
-  let memoriesSection = "";
-
-  if (memoryIds.length > 0) {
-    const memories: string[] = [];
-    for (const id of memoryIds) {
-      const memory = await service.get(id);
-      if (memory) {
-        memories.push(`### Memory: ${id}\n${memory.content}`);
-      }
-    }
-    if (memories.length > 0) {
-      memoriesSection = `\n\n## Referenced Memories\n\n${memories.join("\n\n")}`;
-    }
-  }
-
-  console.log(checkpoint.content + memoriesSection);
-}
-
-main().catch((err) => {
-  console.error("Error loading checkpoint:", err.message);
-  process.exit(1);
-});

package/src/db/conversation-history.repository.ts

@@ -1,255 +0,0 @@
-import * as lancedb from "@lancedb/lancedb";
-import { type Table } from "@lancedb/lancedb";
-import {
-  CONVERSATION_HISTORY_TABLE,
-  INDEXED_SESSIONS_TABLE,
-  conversationHistorySchema,
-  indexedSessionsSchema,
-} from "./conversation-history.schema.js";
-import {
-  arrowVectorToArray,
-  getOrCreateTable,
-  createFtsMutex,
-  createRerankerMutex,
-  escapeLanceDbString,
-} from "./lancedb-utils.js";
-import type {
-  ConversationHistoryEntry,
-  ConversationHistoryHybridRow,
-  IndexedSession,
-  IndexedSessionSummary,
-  MessageRole,
-} from "../types/conversation-history.js";
-
-export class ConversationHistoryRepository {
-  // Cached table handles — initialized once, retained for instance lifetime
-  private tablePromise: Promise<Table> | null = null;
-  private sessionsTablePromise: Promise<Table> | null = null;
-
-  // FTS index mutex — once created, the promise is never cleared (index persists in LanceDB)
-  private ensureFtsIndex: () => Promise<void>;
-
-  // Cached reranker — k=60 is constant, no need to recreate per search
-  private getReranker = createRerankerMutex();
-
-  constructor(private db: lancedb.Connection) {
-    this.ensureFtsIndex = createFtsMutex(() => this.getTable());
-  }
-
-  private getTable(): Promise<Table> {
-    if (!this.tablePromise) {
-      this.tablePromise = getOrCreateTable(
-        this.db,
-        CONVERSATION_HISTORY_TABLE,
-        conversationHistorySchema
-      ).catch((e) => {
-        this.tablePromise = null;
-        throw e;
-      });
-    }
-    return this.tablePromise;
-  }
-
-  private getSessionsTable(): Promise<Table> {
-    if (!this.sessionsTablePromise) {
-      this.sessionsTablePromise = getOrCreateTable(
-        this.db,
-        INDEXED_SESSIONS_TABLE,
-        indexedSessionsSchema
-      ).catch((e) => {
-        this.sessionsTablePromise = null;
-        throw e;
-      });
-    }
-    return this.sessionsTablePromise;
-  }
-
-  private rowToEntry(row: Record<string, unknown>): ConversationHistoryEntry {
-    return {
-      id: row.id as string,
-      content: row.content as string,
-      embedding: arrowVectorToArray(row.vector),
-      sessionId: row.session_id as string,
-      role: row.role as MessageRole,
-      messageIndex: row.message_index as number,
-      timestamp: new Date(row.timestamp as number),
-      metadata: JSON.parse(row.metadata as string),
-      createdAt: new Date(row.created_at as number),
-    };
-  }
-
-  private rowToSessionSummary(
-    row: Record<string, unknown>
-  ): IndexedSessionSummary {
-    return {
-      sessionId: row.session_id as string,
-      messageCount: row.message_count as number,
-      firstMessageAt: new Date(row.first_message_at as number),
-      lastMessageAt: new Date(row.last_message_at as number),
-      indexedAt: new Date(row.indexed_at as number),
-      // Use null check (not truthiness) — empty string is a valid value distinct from null
-      ...(row.project != null ? { project: row.project as string } : {}),
-      ...(row.git_branch != null ? { gitBranch: row.git_branch as string } : {}),
-    };
-  }
-
-  private rowToSession(row: Record<string, unknown>): IndexedSession {
-    return {
-      ...this.rowToSessionSummary(row),
-      filePath: row.file_path as string,
-      fileSize: row.file_size as number,
-    };
-  }
-
-  // --- Conversation History Operations ---
-
-  async insert(entries: ConversationHistoryEntry[]): Promise<void> {
-    if (entries.length === 0) return;
-
-    const table = await this.getTable();
-    await table.add(
-      entries.map((entry) => ({
-        id: entry.id,
-        vector: entry.embedding,
-        content: entry.content,
-        session_id: entry.sessionId,
-        role: entry.role,
-        message_index: entry.messageIndex,
-        timestamp: entry.timestamp.getTime(),
-        metadata: JSON.stringify(entry.metadata),
-        created_at: entry.createdAt.getTime(),
-      }))
-    );
-  }
-
-  async findHybrid(
-    embedding: number[],
-    query: string,
-    limit: number
-  ): Promise<ConversationHistoryHybridRow[]> {
-    await this.ensureFtsIndex();
-
-    const table = await this.getTable();
-    const reranker = await this.getReranker();
-
-    const results = await table
-      .query()
-      .nearestTo(embedding)
-      .fullTextSearch(query)
-      .rerank(reranker)
-      .limit(limit)
-      .toArray();
-
-    return results.map((row) => {
-      const entry = this.rowToEntry(row as Record<string, unknown>);
-      return {
-        ...entry,
-        rrfScore: (row._relevance_score as number) ?? 0,
-      };
-    });
-  }
-
-  async findBySessionId(sessionId: string): Promise<ConversationHistoryEntry[]> {
-    const table = await this.getTable();
-    const results = await table
-      .query()
-      .where(`session_id = '${escapeLanceDbString(sessionId)}'`)
-      .toArray();
-
-    return results.map((row) =>
-      this.rowToEntry(row as Record<string, unknown>)
-    );
-  }
-
-  async deleteBySessionId(sessionId: string): Promise<number> {
-    const table = await this.getTable();
-
-    // Select only id — avoids deserializing embedding vectors just for a count
-    const existing = await table
-      .query()
-      .where(`session_id = '${escapeLanceDbString(sessionId)}'`)
-      .select(["id"])
-      .toArray();
-    const count = existing.length;
-
-    if (count > 0) {
-      await table.delete(`session_id = '${escapeLanceDbString(sessionId)}'`);
-    }
-
-    return count;
-  }
-
-  // --- Indexed Sessions Tracking ---
-
-  async getIndexedSession(
-    sessionId: string
-  ): Promise<IndexedSession | null> {
-    const table = await this.getSessionsTable();
-    const results = await table
-      .query()
-      .where(`session_id = '${escapeLanceDbString(sessionId)}'`)
-      .limit(1)
-      .toArray();
-
-    if (results.length === 0) {
-      return null;
-    }
-
-    return this.rowToSession(results[0] as Record<string, unknown>);
-  }
-
-  async upsertIndexedSession(session: IndexedSession): Promise<void> {
-    const table = await this.getSessionsTable();
-    const existing = await table
-      .query()
-      .where(`session_id = '${escapeLanceDbString(session.sessionId)}'`)
-      .limit(1)
-      .toArray();
-
-    const row = {
-      session_id: session.sessionId,
-      file_path: session.filePath,
-      file_size: session.fileSize,
-      message_count: session.messageCount,
-      first_message_at: session.firstMessageAt.getTime(),
-      last_message_at: session.lastMessageAt.getTime(),
-      indexed_at: session.indexedAt.getTime(),
-      project: session.project ?? null,
-      git_branch: session.gitBranch ?? null,
-    };
-
-    if (existing.length === 0) {
-      await table.add([row]);
-    } else {
-      await table.update({
-        where: `session_id = '${escapeLanceDbString(session.sessionId)}'`,
-        values: row,
-      });
-    }
-  }
-
-  async listIndexedSessions(): Promise<IndexedSessionSummary[]> {
-    const table = await this.getSessionsTable();
-    const results = await table.query().toArray();
-
-    return results.map((row) =>
-      this.rowToSessionSummary(row as Record<string, unknown>)
-    );
-  }
-
-  async deleteIndexedSession(sessionId: string): Promise<boolean> {
-    const table = await this.getSessionsTable();
-    const existing = await table
-      .query()
-      .where(`session_id = '${escapeLanceDbString(sessionId)}'`)
-      .limit(1)
-      .toArray();
-
-    if (existing.length === 0) {
-      return false;
-    }
-
-    await table.delete(`session_id = '${escapeLanceDbString(sessionId)}'`);
-    return true;
-  }
-}

package/src/db/conversation-history.schema.ts

@@ -1,40 +0,0 @@
-import {
-  Schema,
-  Field,
-  Utf8,
-  Int32,
-  Float64,
-} from "apache-arrow";
-import { vectorField, timestampField } from "./schema.js";
-
-export const CONVERSATION_HISTORY_TABLE = "conversation_history";
-
-/**
- * Tracks which sessions have been indexed and their file sizes,
- * enabling idempotent incremental indexing.
- */
-export const INDEXED_SESSIONS_TABLE = "indexed_sessions";
-
-export const conversationHistorySchema = new Schema([
-  new Field("id", new Utf8(), false),
-  vectorField(),
-  new Field("content", new Utf8(), false),
-  new Field("session_id", new Utf8(), false),
-  new Field("role", new Utf8(), false), // "user" | "assistant"
-  new Field("message_index", new Int32(), false),
-  timestampField("timestamp"),
-  new Field("metadata", new Utf8(), false), // JSON string
-  timestampField("created_at"),
-]);
-
-export const indexedSessionsSchema = new Schema([
-  new Field("session_id", new Utf8(), false),
-  new Field("file_path", new Utf8(), false),
-  new Field("file_size", new Float64(), false), // Float64 avoids Int32 overflow and BigInt handling
-  new Field("message_count", new Int32(), false),
-  timestampField("first_message_at"),
-  timestampField("last_message_at"),
-  timestampField("indexed_at"),
-  new Field("project", new Utf8(), true), // Nullable
-  new Field("git_branch", new Utf8(), true), // Nullable
-]);

package/src/services/conversation-history.service.ts

@@ -1,320 +0,0 @@
-import { readdir, stat } from "fs/promises";
-import { join } from "path";
-import type { ConversationHistoryRepository } from "../db/conversation-history.repository.js";
-import type { EmbeddingsService } from "./embeddings.service.js";
-import {
-  parseSessionFile,
-  discoverSessionFiles,
-  detectSessionPath,
-  type ParsedMessage,
-  type ParseResult,
-  type SessionFileInfo,
-} from "./session-parser.js";
-import type {
-  ConversationHistoryEntry,
-  HistorySearchResult,
-  IndexedSession,
-  IndexedSessionSummary,
-  IndexingSummary,
-} from "../types/conversation-history.js";
-
-const EMBED_BATCH_SIZE = 50;
-
-export class ConversationHistoryService {
-  constructor(
-    private repository: ConversationHistoryRepository,
-    private embeddings: EmbeddingsService,
-    private sessionPath: string | null, // null = auto-detect
-  ) {}
-
-  /**
-   * Index all conversation sessions found in the session directory.
-   *
-   * For each .jsonl file discovered:
-   * - New (not tracked): full parse from byte 0
-   * - Grown (fileSize increased): incremental parse from last-known size
-   * - Shrunk (fileSize decreased — file replaced): delete + full reindex
-   * - Unchanged (same fileSize): skip
-   */
-  async indexConversations(sessionDir?: string): Promise<IndexingSummary> {
-    const allFiles = await this.discoverAllFiles(sessionDir);
-
-    // Bulk-fetch all tracked sessions into a Map to avoid N+1 lookups
-    const trackedSessions = await this.buildSessionIndex();
-
-    const summary: IndexingSummary = {
-      sessionsDiscovered: allFiles.length,
-      sessionsIndexed: 0,
-      sessionsSkipped: 0,
-      messagesIndexed: 0,
-    };
-
-    for (const file of allFiles) {
-      const indexed = trackedSessions.get(file.sessionId) ?? null;
-
-      if (indexed && indexed.fileSize === file.fileSize) {
-        // Unchanged — skip
-        summary.sessionsSkipped++;
-        continue;
-      }
-
-      if (indexed && file.fileSize < indexed.fileSize) {
-        // Shrunk — file was replaced, full reindex
-        await this.repository.deleteBySessionId(file.sessionId);
-        await this.repository.deleteIndexedSession(file.sessionId);
-        const count = await this.indexFile(file, 0, 0, null);
-        summary.sessionsIndexed++;
-        summary.messagesIndexed += count;
-        continue;
-      }
-
-      if (indexed && file.fileSize > indexed.fileSize) {
-        // Grown — incremental parse from where we left off
-        const count = await this.indexFile(
-          file,
-          indexed.fileSize,
-          indexed.messageCount,
-          indexed,
-        );
-        summary.sessionsIndexed++;
-        summary.messagesIndexed += count;
-        continue;
-      }
-
-      // New — full parse
-      const count = await this.indexFile(file, 0, 0, null);
-      summary.sessionsIndexed++;
-      summary.messagesIndexed += count;
-    }
-
-    return summary;
-  }
-
-  /**
-   * Search conversation history using hybrid (vector + FTS) search.
-   */
-  async search(query: string, limit: number): Promise<HistorySearchResult[]> {
-    const embedding = await this.embeddings.embed(query);
-    const rows = await this.repository.findHybrid(embedding, query, limit);
-
-    return rows.map((row) => ({
-      source: "conversation_history" as const,
-      id: row.id,
-      content: row.content,
-      metadata: row.metadata,
-      score: row.rrfScore,
-      sessionId: row.sessionId,
-      role: row.role,
-      messageIndex: row.messageIndex,
-      timestamp: row.timestamp,
-    }));
-  }
-
-  /**
-   * List all indexed sessions (pass-through to repository).
-   */
-  async listIndexedSessions(): Promise<IndexedSessionSummary[]> {
-    return this.repository.listIndexedSessions();
-  }
-
-  /**
-   * Force a full reindex of a specific session.
-   * Deletes all existing entries and tracking, then re-parses from byte 0.
-   */
-  async reindexSession(sessionId: string): Promise<IndexingSummary> {
-    const indexed = await this.repository.getIndexedSession(sessionId);
-
-    const summary: IndexingSummary = {
-      sessionsDiscovered: 1,
-      sessionsIndexed: 0,
-      sessionsSkipped: 0,
-      messagesIndexed: 0,
-    };
-
-    if (!indexed) {
-      // Nothing to reindex — no tracking record means we don't know the file path
-      summary.sessionsSkipped = 1;
-      return summary;
-    }
-
-    // Delete existing data
-    await this.repository.deleteBySessionId(sessionId);
-    await this.repository.deleteIndexedSession(sessionId);
-
-    // Get current file size (file may have changed since last index)
-    let fileSize: number;
-    try {
-      const stats = await stat(indexed.filePath);
-      fileSize = stats.size;
-    } catch {
-      // File no longer exists
-      summary.sessionsSkipped = 1;
-      return summary;
-    }
-
-    const fileInfo: SessionFileInfo = {
-      sessionId,
-      filePath: indexed.filePath,
-      fileSize,
-    };
-
-    const count = await this.indexFile(fileInfo, 0, 0, null);
-    summary.sessionsIndexed = 1;
-    summary.messagesIndexed = count;
-    return summary;
-  }
-
-  // --- Private helpers ---
-
-  /**
-   * Bulk-fetch all tracked sessions into a Map for O(1) lookups.
-   * Uses listIndexedSessions() which returns summaries, but we need full
-   * IndexedSession records. We call getIndexedSession() is avoided by using
-   * a repository method that returns all sessions with full details.
-   *
-   * Note: listIndexedSessions returns IndexedSessionSummary (no filePath/fileSize),
-   * so we use getIndexedSession per unique session. However, we batch this via
-   * the list + individual fetches only when needed. For now, we fetch all as
-   * summaries and promote to full records via individual lookups grouped upfront.
-   */
-  private async buildSessionIndex(): Promise<Map<string, IndexedSession>> {
-    const summaries = await this.repository.listIndexedSessions();
-    const sessionMap = new Map<string, IndexedSession>();
-
-    // Fetch full records in parallel for all known sessions
-    const fullRecords = await Promise.all(
-      summaries.map((s) => this.repository.getIndexedSession(s.sessionId)),
-    );
-
-    for (const record of fullRecords) {
-      if (record) {
-        sessionMap.set(record.sessionId, record);
-      }
-    }
-
-    return sessionMap;
-  }
-
-  /**
-   * Discover all .jsonl files across resolved session directories.
-   * Resolves dirs and discovers files in one pass to avoid double-scanning.
-   */
-  private async discoverAllFiles(sessionDir?: string): Promise<SessionFileInfo[]> {
-    const base = sessionDir ?? this.sessionPath ?? detectSessionPath();
-    if (!base) return [];
-
-    // Check if base dir itself has .jsonl files
-    const rootFiles = await discoverSessionFiles(base);
-    if (rootFiles.length > 0) return rootFiles;
-
-    // Otherwise enumerate subdirectories and discover files in each
-    const dirs = await this.listSubdirectories(base);
-    const nested = await Promise.all(dirs.map((d) => discoverSessionFiles(d)));
-    return nested.flat();
-  }
-
-  /**
-   * List immediate subdirectories of a path. Stat calls are parallelized.
-   */
-  private async listSubdirectories(base: string): Promise<string[]> {
-    let entries: string[];
-    try {
-      entries = await readdir(base);
-    } catch {
-      return [];
-    }
-
-    const results = await Promise.allSettled(
-      entries.map(async (entry) => {
-        const fullPath = join(base, entry);
-        const stats = await stat(fullPath);
-        return stats.isDirectory() ? fullPath : null;
-      }),
-    );
-
-    return results
-      .filter((r): r is PromiseFulfilledResult<string | null> => r.status === "fulfilled")
-      .map((r) => r.value)
-      .filter((v): v is string => v != null);
-  }
-
-  /**
-   * Parse a session file, embed messages in batches, insert into repository,
-   * and upsert the tracking record. Returns count of messages indexed.
-   */
-  private async indexFile(
-    file: SessionFileInfo,
-    fromByte: number,
-    startIndex: number,
-    existing: IndexedSession | null,
-  ): Promise<number> {
-    const parseResult = await parseSessionFile(
-      file.filePath,
-      fromByte,
-      startIndex,
-      file.fileSize,
-    );
-
-    if (parseResult.messages.length === 0) {
-      // Still upsert tracking so we don't re-parse an empty/no-new-content file
-      await this.upsertTracking(file, parseResult.messages, startIndex, parseResult, existing);
-      return 0;
-    }
-
-    // Embed and insert in batches
-    for (let i = 0; i < parseResult.messages.length; i += EMBED_BATCH_SIZE) {
-      const batch = parseResult.messages.slice(i, i + EMBED_BATCH_SIZE);
-      const texts = batch.map((m) => m.content);
-      const embeddings = await this.embeddings.embedBatch(texts);
-
-      const entries: ConversationHistoryEntry[] = batch.map((msg, idx) => ({
-        id: msg.id,
-        content: msg.content,
-        embedding: embeddings[idx],
-        sessionId: msg.sessionId,
-        role: msg.role,
-        messageIndex: msg.messageIndex,
-        timestamp: msg.timestamp,
-        metadata: msg.metadata,
-        createdAt: new Date(),
-      }));
-
-      await this.repository.insert(entries);
-    }
-
-    await this.upsertTracking(file, parseResult.messages, startIndex, parseResult, existing);
-    return parseResult.messages.length;
-  }
-
-  /**
-   * Upsert the indexed session tracking record.
-   * For incremental indexing, merges timestamps with the existing record.
-   */
-  private async upsertTracking(
-    file: SessionFileInfo,
-    newMessages: ParsedMessage[],
-    startIndex: number,
-    parseResult: ParseResult,
-    existing: IndexedSession | null,
-  ): Promise<void> {
-    const totalMessageCount = startIndex + newMessages.length;
-    const firstMessageAt =
-      existing?.firstMessageAt ?? parseResult.firstMessageAt ?? new Date();
-    const lastMessageAt =
-      parseResult.lastMessageAt ?? existing?.lastMessageAt ?? new Date();
-
-    const session: IndexedSession = {
-      sessionId: file.sessionId,
-      filePath: file.filePath,
-      fileSize: file.fileSize,
-      messageCount: totalMessageCount,
-      firstMessageAt,
-      lastMessageAt,
-      indexedAt: new Date(),
-      ...(parseResult.project ? { project: parseResult.project } : existing?.project ? { project: existing.project } : {}),
-      ...(parseResult.gitBranch ? { gitBranch: parseResult.gitBranch } : existing?.gitBranch ? { gitBranch: existing.gitBranch } : {}),
-    };
-
-    await this.repository.upsertIndexedSession(session);
-  }
-}