claude-memory-layer 1.0.26 → 1.0.28

package/src/core/session-qrels.ts

@@ -0,0 +1,360 @@
+import { readdir, stat } from 'node:fs/promises';
+import * as path from 'node:path';
+
+export interface SessionQrelsMemory {
+  id: string;
+  content: string;
+  sourceSessionId: string;
+  sourceTurnIndex: number;
+  timestamp?: string;
+}
+
+export type SessionQrelsExpectation = 'match' | 'no_match';
+
+export interface SessionQrelsQuery {
+  queryId: string;
+  query: string;
+  expectedIds: string[];
+  expectedRelevance: Record<string, number>;
+  sourceSessionId: string;
+  sourceTurnIndex: number;
+  expectation?: SessionQrelsExpectation;
+  forbiddenIds?: string[];
+  knownAnswer?: string;
+}
+
+export interface SessionQrelsFixtureMetadata {
+  sourceFileCount?: number;
+  rawContentIncluded: boolean;
+  generatedAt?: string;
+}
+
+export interface SessionQrelsFixture {
+  name: string;
+  description: string;
+  ks: number[];
+  queries: SessionQrelsQuery[];
+  memories: SessionQrelsMemory[];
+  metadata?: SessionQrelsFixtureMetadata;
+}
+
+export interface SessionQrelsNoMatchQueryInput {
+  queryId?: string;
+  query: string;
+  forbiddenIds?: string[];
+  sourceSessionId?: string;
+  sourceTurnIndex?: number;
+}
+
+export interface SessionQrelsOptions {
+  name?: string;
+  description?: string;
+  ks?: number[];
+  maxQueries?: number;
+  redactContent?: boolean;
+  sourceFileCount?: number;
+  rawContentIncluded?: boolean;
+  generatedAt?: string;
+  noMatchQueries?: SessionQrelsNoMatchQueryInput[];
+}
+
+export interface SessionQrelsFileCollectionOptions {
+  includeSubagents?: boolean;
+  maxFiles?: number;
+  minBytes?: number;
+}
+
+export interface SessionQrelsPerSessionSummary {
+  sourceSessionId: string;
+  queryCount: number;
+  memoryCount: number;
+  firstTurnIndex: number;
+  lastTurnIndex: number;
+}
+
+export interface SessionQrelsSummary {
+  name: string;
+  description: string;
+  ks: number[];
+  queryCount: number;
+  positiveQueryCount: number;
+  noMatchQueryCount: number;
+  knownAnswerCount: number;
+  memoryCount: number;
+  sourceSessionCount: number;
+  sourceFileCount?: number;
+  rawContentIncluded: boolean;
+  perSession: SessionQrelsPerSessionSummary[];
+}
+
+interface ClaudeContentBlock {
+  type: string;
+  text?: string;
+}
+
+type ClaudeMessageContent = string | ClaudeContentBlock[];
+
+interface ClaudeJsonlEntry {
+  type?: string;
+  sessionId?: string;
+  timestamp?: string;
+  message?: {
+    role?: string;
+    content?: ClaudeMessageContent;
+  };
+}
+
+interface PendingPrompt {
+  sessionId: string;
+  text: string;
+  turnIndex: number;
+  timestamp?: string;
+}
+
+export function buildSessionQrelsFixtureFromJsonl(
+  jsonl: string | string[],
+  options: SessionQrelsOptions = {}
+): SessionQrelsFixture {
+  const lines = Array.isArray(jsonl) ? jsonl : jsonl.split(/\r?\n/);
+  const queries: SessionQrelsQuery[] = [];
+  const memories: SessionQrelsMemory[] = [];
+  const sessionCounters = new Map<string, number>();
+  const pendingBySession = new Map<string, PendingPrompt>();
+
+  for (const line of lines) {
+    if (options.maxQueries !== undefined && queries.length >= options.maxQueries) break;
+    const entry = parseEntry(line);
+    if (!entry) continue;
+
+    const sessionId = entry.sessionId || 'unknown-session';
+    const content = extractTextContent(entry.message?.content);
+    if (!content) continue;
+
+    if (entry.type === 'user') {
+      if (isWorthBenchmarkingPrompt(content)) {
+        const turnIndex = nextSessionCounter(sessionCounters, sessionId);
+        pendingBySession.set(sessionId, { sessionId, text: content, turnIndex, timestamp: entry.timestamp });
+      } else {
+        pendingBySession.delete(sessionId);
+      }
+      continue;
+    }
+
+    if (entry.type === 'assistant') {
+      const pending = pendingBySession.get(sessionId);
+      if (!pending) continue;
+
+      const answer = content.trim();
+      if (answer.length === 0) continue;
+      const idSuffix = `${pending.sessionId}-${pending.turnIndex}`;
+      const memoryId = `m-${idSuffix}`;
+      const queryId = `q-${idSuffix}`;
+      const memoryContent = options.redactContent ? `[redacted memory ${memoryId}]` : answer;
+      memories.push({
+        id: memoryId,
+        content: memoryContent,
+        sourceSessionId: pending.sessionId,
+        sourceTurnIndex: pending.turnIndex,
+        timestamp: entry.timestamp ?? pending.timestamp
+      });
+      queries.push({
+        queryId,
+        query: options.redactContent ? `[redacted query ${queryId}]` : pending.text,
+        expectedIds: [memoryId],
+        expectedRelevance: { [memoryId]: 2 },
+        sourceSessionId: pending.sessionId,
+        sourceTurnIndex: pending.turnIndex,
+        expectation: 'match',
+        knownAnswer: memoryContent
+      });
+      pendingBySession.delete(sessionId);
+    }
+  }
+
+  appendExplicitNoMatchQueries(queries, options);
+
+  const redactContent = options.redactContent === true;
+  const rawContentIncluded = options.rawContentIncluded ?? !redactContent;
+
+  return {
+    name: options.name ?? 'session-qrels-fixture',
+    description: options.description ?? 'Session-derived qrels fixture generated from Claude JSONL user/assistant turns.',
+    ks: options.ks ?? [1, 3, 5],
+    queries,
+    memories,
+    metadata: {
+      sourceFileCount: options.sourceFileCount,
+      rawContentIncluded,
+      generatedAt: options.generatedAt
+    }
+  };
+}
+
+export async function collectClaudeSessionJsonlFiles(
+  rootDir: string,
+  options: SessionQrelsFileCollectionOptions = {}
+): Promise<string[]> {
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  const minBytes = options.minBytes ?? 0;
+  const files: string[] = [];
+
+  async function walk(dir: string): Promise<void> {
+    if (files.length >= maxFiles) return;
+
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const entry of entries) {
+      if (files.length >= maxFiles) return;
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!options.includeSubagents && entry.name.toLowerCase() === 'subagents') continue;
+        await walk(fullPath);
+        continue;
+      }
+
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      if (minBytes > 0) {
+        try {
+          const info = await stat(fullPath);
+          if (info.size < minBytes) continue;
+        } catch {
+          continue;
+        }
+      }
+      files.push(fullPath);
+    }
+  }
+
+  await walk(rootDir);
+  return files;
+}
+
+export function summarizeSessionQrelsFixture(fixture: SessionQrelsFixture): SessionQrelsSummary {
+  const bySession = new Map<string, SessionQrelsPerSessionSummary>();
+
+  function ensureSession(sourceSessionId: string, turnIndex: number): SessionQrelsPerSessionSummary {
+    const existing = bySession.get(sourceSessionId);
+    if (existing) {
+      existing.firstTurnIndex = Math.min(existing.firstTurnIndex, turnIndex);
+      existing.lastTurnIndex = Math.max(existing.lastTurnIndex, turnIndex);
+      return existing;
+    }
+    const created: SessionQrelsPerSessionSummary = {
+      sourceSessionId,
+      queryCount: 0,
+      memoryCount: 0,
+      firstTurnIndex: turnIndex,
+      lastTurnIndex: turnIndex
+    };
+    bySession.set(sourceSessionId, created);
+    return created;
+  }
+
+  for (const query of fixture.queries) {
+    ensureSession(query.sourceSessionId, query.sourceTurnIndex).queryCount += 1;
+  }
+  for (const memory of fixture.memories) {
+    ensureSession(memory.sourceSessionId, memory.sourceTurnIndex).memoryCount += 1;
+  }
+
+  const perSession = Array.from(bySession.values()).sort((a, b) => a.sourceSessionId.localeCompare(b.sourceSessionId));
+
+  const positiveQueryCount = fixture.queries.filter((query) => getQueryExpectation(query) === 'match').length;
+  const noMatchQueryCount = fixture.queries.filter((query) => getQueryExpectation(query) === 'no_match').length;
+  const knownAnswerCount = fixture.queries.filter((query) => typeof query.knownAnswer === 'string' && query.knownAnswer.length > 0).length;
+
+  return {
+    name: fixture.name,
+    description: fixture.description,
+    ks: fixture.ks,
+    queryCount: fixture.queries.length,
+    positiveQueryCount,
+    noMatchQueryCount,
+    knownAnswerCount,
+    memoryCount: fixture.memories.length,
+    sourceSessionCount: perSession.length,
+    sourceFileCount: fixture.metadata?.sourceFileCount,
+    rawContentIncluded: fixture.metadata?.rawContentIncluded ?? true,
+    perSession
+  };
+}
+
+function appendExplicitNoMatchQueries(
+  queries: SessionQrelsQuery[],
+  options: SessionQrelsOptions
+): void {
+  const inputs = options.noMatchQueries ?? [];
+  if (inputs.length === 0) return;
+
+  const remaining = options.maxQueries === undefined
+    ? Number.POSITIVE_INFINITY
+    : Math.max(0, options.maxQueries - queries.length);
+
+  const startIndex = queries.length;
+  inputs.slice(0, remaining).forEach((input, index) => {
+    const queryId = input.queryId ?? `q-no-match-${startIndex + index + 1}`;
+    queries.push({
+      queryId,
+      query: options.redactContent ? `[redacted query ${queryId}]` : input.query,
+      expectedIds: [],
+      expectedRelevance: {},
+      sourceSessionId: input.sourceSessionId ?? 'no-match',
+      sourceTurnIndex: input.sourceTurnIndex ?? 0,
+      expectation: 'no_match',
+      forbiddenIds: [...(input.forbiddenIds ?? [])]
+    });
+  });
+}
+
+function getQueryExpectation(query: SessionQrelsQuery): SessionQrelsExpectation {
+  return query.expectation ?? (query.expectedIds.length === 0 ? 'no_match' : 'match');
+}
+
+function parseEntry(line: string): ClaudeJsonlEntry | null {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed) as ClaudeJsonlEntry;
+  } catch {
+    return null;
+  }
+}
+
+function extractTextContent(content: ClaudeMessageContent | undefined): string | null {
+  if (!content) return null;
+  if (typeof content === 'string') return content.trim();
+  const texts = content
+    .filter((block) => block.type === 'text' && block.text)
+    .map((block) => block.text?.trim() ?? '')
+    .filter(Boolean);
+  return texts.length > 0 ? texts.join('\n') : null;
+}
+
+function isWorthBenchmarkingPrompt(content: string): boolean {
+  const trimmed = content.trim();
+  if (isClaudeLocalCommandArtifact(trimmed)) return false;
+  if (trimmed.startsWith('/')) return false;
+  if (trimmed.length < 15) return false;
+  return /[a-zA-Z가-힣]{2,}/.test(trimmed);
+}
+
+function isClaudeLocalCommandArtifact(content: string): boolean {
+  return (
+    /^<local-command-(stdout|stderr)>/.test(content) ||
+    /^<command-(name|message)>/.test(content) ||
+    (content.includes('<command-name>') && content.includes('<local-command-stdout>'))
+  );
+}
+
+function nextSessionCounter(counters: Map<string, number>, sessionId: string): number {
+  const next = (counters.get(sessionId) ?? 0) + 1;
+  counters.set(sessionId, next);
+  return next;
+}

package/src/core/shared-event-store.ts

@@ -14,7 +14,7 @@ export class SharedEventStore {
   private db: Database;
   private initialized = false;
 
-  constructor(private dbPath: string) {
+  constructor(dbPath: string) {
     this.db = createDatabase(dbPath);
   }
 

package/src/core/sqlite-event-store.ts

@@ -36,7 +36,7 @@ export class SQLiteEventStore {
   private readonly readOnly: boolean;
   private readonly markdownMirror: MarkdownMirror | null;
 
-  constructor(private dbPath: string, options?: SQLiteEventStoreOptions) {
+  constructor(dbPath: string, options?: SQLiteEventStoreOptions) {
     this.readOnly = options?.readonly ?? false;
     this.db = createSQLiteDatabase(dbPath, {
       readonly: this.readOnly,
@@ -346,8 +346,7 @@ export class SQLiteEventStore {
       CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
         content,
         event_id UNINDEXED,
-        content='events',
-        content_rowid='rowid'
+        tokenize='porter unicode61'
       );
 
       -- Triggers to keep FTS in sync with events table
@@ -356,11 +355,11 @@ export class SQLiteEventStore {
       END;
 
       CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
-        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+        DELETE FROM events_fts WHERE rowid = OLD.rowid;
       END;
 
       CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
-        INSERT INTO events_fts(events_fts, rowid, content, event_id) VALUES('delete', OLD.rowid, OLD.content, OLD.id);
+        DELETE FROM events_fts WHERE rowid = OLD.rowid;
         INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
       END;
     `);
@@ -1422,11 +1421,36 @@ export class SQLiteEventStore {
     const countRow = sqliteGet<{count: number}>(this.db, 'SELECT COUNT(*) as count FROM events', []);
     const totalEvents = countRow?.count ?? 0;
 
-    // Clear and rebuild FTS index
+    // Clear and rebuild FTS index. Recreate the virtual table instead of
+    // issuing DELETE against it: older migrated FTS5 tables/triggers can fail
+    // with `no such column: T.event_id` when processing synthetic deletes.
     sqliteExec(this.db, `
-      DELETE FROM events_fts;
+      DROP TRIGGER IF EXISTS events_fts_insert;
+      DROP TRIGGER IF EXISTS events_fts_delete;
+      DROP TRIGGER IF EXISTS events_fts_update;
+      DROP TABLE IF EXISTS events_fts;
+
+      CREATE VIRTUAL TABLE events_fts USING fts5(
+        content,
+        event_id UNINDEXED,
+        tokenize='porter unicode61'
+      );
+
       INSERT INTO events_fts(rowid, content, event_id)
       SELECT rowid, content, id FROM events;
+
+      CREATE TRIGGER events_fts_insert AFTER INSERT ON events BEGIN
+        INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
+      END;
+
+      CREATE TRIGGER events_fts_delete AFTER DELETE ON events BEGIN
+        DELETE FROM events_fts WHERE rowid = OLD.rowid;
+      END;
+
+      CREATE TRIGGER events_fts_update AFTER UPDATE ON events BEGIN
+        DELETE FROM events_fts WHERE rowid = OLD.rowid;
+        INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
+      END;
     `);
 
     return totalEvents;
@@ -1773,14 +1797,14 @@ export class SQLiteEventStore {
 
         // Recreate triggers
         sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_insert AFTER INSERT ON events BEGIN
-          INSERT INTO events_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
         END`);
         sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_delete AFTER DELETE ON events BEGIN
-          INSERT INTO events_fts(events_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
+          DELETE FROM events_fts WHERE rowid = OLD.rowid;
         END`);
         sqliteRun(this.db, `CREATE TRIGGER IF NOT EXISTS events_fts_update AFTER UPDATE ON events BEGIN
-          INSERT INTO events_fts(events_fts, rowid, content) VALUES('delete', OLD.rowid, OLD.content);
-          INSERT INTO events_fts(rowid, content) VALUES (NEW.rowid, NEW.content);
+          DELETE FROM events_fts WHERE rowid = OLD.rowid;
+          INSERT INTO events_fts(rowid, content, event_id) VALUES (NEW.rowid, NEW.content, NEW.id);
         END`);
       } catch {
         // FTS rebuild failed - non-critical, will be rebuilt on next initialize

package/src/core/task/blocker-resolver.ts

@@ -5,7 +5,7 @@
 
 import { dbRun, dbAll, type Database } from '../db-wrapper.js';
 import { randomUUID } from 'crypto';
-import type { BlockerRef, BlockerKind, Entity } from '../types.js';
+import type { BlockerRef, Entity } from '../types.js';
 import { makeEntityCanonicalKey, makeArtifactKey } from '../canonical-key.js';
 import { TaskMatcher } from './task-matcher.js';
 
@@ -39,7 +39,7 @@ export class BlockerResolver {
    */
   async resolveBlocker(
     text: string,
-    sourceEntryId?: string
+    _sourceEntryId?: string
   ): Promise<BlockerRef> {
     const trimmedText = text.trim();
 

package/src/core/task/task-resolver.ts

@@ -9,7 +9,6 @@ import type {
   Entity,
   TaskStatus,
   TaskPriority,
-  BlockerRef,
   BlockerMode
 } from '../types.js';
 import { makeEntityCanonicalKey, makeTaskEventDedupeKey } from '../canonical-key.js';

package/src/core/vector-outbox.ts

@@ -8,8 +8,7 @@ import { randomUUID } from 'crypto';
 import type {
   OutboxJob,
   OutboxStatus,
-  OutboxItemKind,
-  VALID_OUTBOX_TRANSITIONS
+  OutboxItemKind
 } from './types.js';
 
 export interface OutboxConfig {
@@ -191,14 +190,6 @@ export class VectorOutbox {
       [now.toISOString(), this.config.maxRetries]
     );
 
-    // Get counts (DuckDB doesn't return affected rows easily)
-    const recoveredRows = await dbAll<{ count: number }>(
-      this.db,
-      `SELECT COUNT(*) as count FROM vector_outbox
-       WHERE status = 'pending' AND updated_at = ?`,
-      [now.toISOString()]
-    );
-
     return {
       recovered: 0,  // Approximate
       retried: 0     // Approximate

package/src/core/vector-worker.ts

@@ -6,7 +6,7 @@
 import { EventStore } from './event-store.js';
 import { VectorStore } from './vector-store.js';
 import { Embedder } from './embedder.js';
-import type { OutboxItem, VectorRecord } from './types.js';
+import type { VectorRecord } from './types.js';
 
 export interface WorkerConfig {
   batchSize: number;