pi-hermes-memory 0.6.7 → 0.6.9

package/src/store/sqlite-memory-store.ts

@@ -1,6 +1,28 @@
 import { DatabaseManager } from './db.js';
 import type { MemoryCategory } from '../types.js';
 
+const MEMORY_SELECT_COLUMNS = `
+  id,
+  project,
+  target,
+  category,
+  content,
+  failure_reason,
+  tool_state,
+  corrected_to,
+  created,
+  last_referenced
+`;
+
+const FAILURE_CATEGORY_SET = new Set<MemoryCategory>([
+  'failure',
+  'correction',
+  'insight',
+  'preference',
+  'convention',
+  'tool-quirk',
+]);
+
 /**
  * A memory entry stored in SQLite.
  */
@@ -17,6 +39,157 @@ export interface SqliteMemoryEntry {
   lastReferenced: string;
 }
 
+export interface SqliteMemorySyncInput {
+  content: string;
+  target: 'memory' | 'user' | 'failure';
+  project?: string | null;
+  category?: MemoryCategory | null;
+  failureReason?: string | null;
+  toolState?: string | null;
+  correctedTo?: string | null;
+  created?: string | null;
+  lastReferenced?: string | null;
+}
+
+export interface SqliteMemorySyncResult {
+  action: 'inserted' | 'existing';
+  entry: SqliteMemoryEntry;
+}
+
+export interface SqliteMemoryUpdateResult {
+  matched: number;
+  updated: number;
+  entries: SqliteMemoryEntry[];
+}
+
+export interface SqliteMemoryRemoveResult {
+  matched: number;
+  removed: number;
+}
+
+export interface ParsedMarkdownMemoryEntry extends SqliteMemorySyncInput {}
+
+function today(): string {
+  return new Date().toISOString().split('T')[0];
+}
+
+function normalizeNullable(value?: string | null): string | null {
+  if (value == null) return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeCategory(value?: MemoryCategory | null): MemoryCategory | null {
+  return value ?? null;
+}
+
+function mapRow(row: {
+  id: number;
+  project: string | null;
+  target: string;
+  category: string | null;
+  content: string;
+  failure_reason: string | null;
+  tool_state: string | null;
+  corrected_to: string | null;
+  created: string;
+  last_referenced: string;
+}): SqliteMemoryEntry {
+  return {
+    id: row.id,
+    project: row.project,
+    target: row.target as 'memory' | 'user' | 'failure',
+    category: row.category as MemoryCategory | null,
+    content: row.content,
+    failureReason: row.failure_reason,
+    toolState: row.tool_state,
+    correctedTo: row.corrected_to,
+    created: row.created,
+    lastReferenced: row.last_referenced,
+  };
+}
+
+function buildScopeConditions(params: unknown[], target?: string, project?: string | null, category?: MemoryCategory | null): string[] {
+  const conditions: string[] = [];
+
+  if (target) {
+    conditions.push('target = ?');
+    params.push(target);
+  }
+
+  if (project !== undefined) {
+    if (project === null) {
+      conditions.push('project IS NULL');
+    } else {
+      conditions.push('project = ?');
+      params.push(project);
+    }
+  }
+
+  if (category !== undefined) {
+    if (category === null) {
+      conditions.push('category IS NULL');
+    } else {
+      conditions.push('category = ?');
+      params.push(category);
+    }
+  }
+
+  return conditions;
+}
+
+function getMemoryById(dbManager: DatabaseManager, id: number): SqliteMemoryEntry | null {
+  const db = dbManager.getDb();
+  const row = db.prepare(`
+    SELECT ${MEMORY_SELECT_COLUMNS}
+    FROM memories
+    WHERE id = ?
+  `).get(id) as {
+    id: number;
+    project: string | null;
+    target: string;
+    category: string | null;
+    content: string;
+    failure_reason: string | null;
+    tool_state: string | null;
+    corrected_to: string | null;
+    created: string;
+    last_referenced: string;
+  } | undefined;
+
+  return row ? mapRow(row) : null;
+}
+
+function minDate(a: string, b: string): string {
+  return a <= b ? a : b;
+}
+
+function maxDate(a: string, b: string): string {
+  return a >= b ? a : b;
+}
+
+function escapeLikePattern(text: string): string {
+  return text.replace(/[\\%_]/g, '\\$&');
+}
+
+function parseMetadataComment(raw: string): { text: string; created: string; lastReferenced: string } {
+  const match = raw.match(/^(.*?)\s*<!--\s*created=([^,]+),\s*last=([^>]+)\s*-->\s*$/);
+  if (match) {
+    return {
+      text: match[1].trim(),
+      created: match[2].trim(),
+      lastReferenced: match[3].trim(),
+    };
+  }
+
+  const fallback = today();
+  return {
+    text: raw.trim(),
+    created: fallback,
+    lastReferenced: fallback,
+  };
+}
+
 /**
  * Add a memory entry to the SQLite store.
  */
@@ -28,15 +201,16 @@ export function addMemory(
   category: MemoryCategory | null = null,
   failureReason: string | null = null,
   toolState: string | null = null,
-  correctedTo: string | null = null
+  correctedTo: string | null = null,
+  created = today(),
+  lastReferenced = created
 ): SqliteMemoryEntry {
   const db = dbManager.getDb();
-  const today = new Date().toISOString().split('T')[0];
 
   const result = db.prepare(`
     INSERT INTO memories (project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(project, target, category, content, failureReason, toolState, correctedTo, today, today);
+  `).run(project, target, category, content, failureReason, toolState, correctedTo, created, lastReferenced);
 
   return {
     id: Number(result.lastInsertRowid),
@@ -47,8 +221,294 @@ export function addMemory(
     failureReason,
     toolState,
     correctedTo,
-    created: today,
-    lastReferenced: today,
+    created,
+    lastReferenced,
+  };
+}
+
+/**
+ * Build the visible failure-memory text stored in Markdown.
+ */
+export function formatFailureMemoryContent(
+  content: string,
+  options: {
+    category: MemoryCategory;
+    failureReason?: string | null;
+    toolState?: string | null;
+    correctedTo?: string | null;
+    project?: string | null;
+  }
+): string {
+  const categoryTag = `[${options.category}]`;
+  const parts = [`${categoryTag} ${content.trim()}`.trim()];
+  if (options.failureReason) parts.push(`Failed: ${options.failureReason}`);
+  if (options.toolState) parts.push(`Tool state: ${options.toolState}`);
+  if (options.correctedTo) parts.push(`Corrected to: ${options.correctedTo}`);
+  if (options.project) parts.push(`Project: ${options.project}`);
+  return parts.join(' — ');
+}
+
+/**
+ * Parse a Markdown memory entry into SQLite sync fields.
+ * Best-effort only: if failure metadata cannot be fully reconstructed,
+ * content is still imported and available for search.
+ */
+export function parseMarkdownMemoryEntry(
+  rawEntry: string,
+  target: 'memory' | 'user' | 'failure',
+  project: string | null = null,
+): ParsedMarkdownMemoryEntry {
+  const { text, created, lastReferenced } = parseMetadataComment(rawEntry);
+  const parsedProject = normalizeNullable(project);
+
+  if (target !== 'failure') {
+    return {
+      content: text,
+      target,
+      project: parsedProject,
+      created,
+      lastReferenced,
+    };
+  }
+
+  let category: MemoryCategory | null = null;
+  let failureReason: string | null = null;
+  let toolState: string | null = null;
+  let correctedTo: string | null = null;
+
+  const categoryMatch = text.match(/^\[([^\]]+)\]\s+/);
+  if (categoryMatch && FAILURE_CATEGORY_SET.has(categoryMatch[1] as MemoryCategory)) {
+    category = categoryMatch[1] as MemoryCategory;
+  }
+
+  const segments = text.split(' — ');
+  for (const segment of segments.slice(1)) {
+    if (segment.startsWith('Failed: ') && !failureReason) {
+      failureReason = segment.slice('Failed: '.length).trim() || null;
+      continue;
+    }
+    if (segment.startsWith('Tool state: ') && !toolState) {
+      toolState = segment.slice('Tool state: '.length).trim() || null;
+      continue;
+    }
+    if (segment.startsWith('Corrected to: ') && !correctedTo) {
+      correctedTo = segment.slice('Corrected to: '.length).trim() || null;
+    }
+  }
+
+  return {
+    content: text,
+    target: 'failure',
+    project: parsedProject,
+    category,
+    failureReason,
+    toolState,
+    correctedTo,
+    created,
+    lastReferenced,
+  };
+}
+
+/**
+ * Idempotently sync a Markdown-backed memory entry into SQLite.
+ * Duplicate identity is exact: project + target + category + content.
+ */
+export function syncMemoryEntry(
+  dbManager: DatabaseManager,
+  input: SqliteMemorySyncInput,
+): SqliteMemorySyncResult {
+  const db = dbManager.getDb();
+  const content = input.content.trim();
+  const project = normalizeNullable(input.project);
+  const category = normalizeCategory(input.category);
+  const failureReason = normalizeNullable(input.failureReason);
+  const toolState = normalizeNullable(input.toolState);
+  const correctedTo = normalizeNullable(input.correctedTo);
+  const created = input.created?.trim() || today();
+  const lastReferenced = input.lastReferenced?.trim() || created;
+
+  const params: unknown[] = [];
+  const conditions = buildScopeConditions(params, input.target, project, category);
+  conditions.push('content = ?');
+  params.push(content);
+
+  const existing = db.prepare(`
+    SELECT ${MEMORY_SELECT_COLUMNS}
+    FROM memories
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY id ASC
+    LIMIT 1
+  `).get(...params) as {
+    id: number;
+    project: string | null;
+    target: string;
+    category: string | null;
+    content: string;
+    failure_reason: string | null;
+    tool_state: string | null;
+    corrected_to: string | null;
+    created: string;
+    last_referenced: string;
+  } | undefined;
+
+  if (!existing) {
+    return {
+      action: 'inserted',
+      entry: addMemory(
+        dbManager,
+        content,
+        input.target,
+        project,
+        category,
+        failureReason,
+        toolState,
+        correctedTo,
+        created,
+        lastReferenced,
+      ),
+    };
+  }
+
+  const updatedCreated = minDate(existing.created, created);
+  const updatedLastReferenced = maxDate(existing.last_referenced, lastReferenced);
+  const updatedCategory = (existing.category as MemoryCategory | null) ?? category;
+  const updatedFailureReason = existing.failure_reason ?? failureReason;
+  const updatedToolState = existing.tool_state ?? toolState;
+  const updatedCorrectedTo = existing.corrected_to ?? correctedTo;
+
+  db.prepare(`
+    UPDATE memories
+    SET category = ?, failure_reason = ?, tool_state = ?, corrected_to = ?, created = ?, last_referenced = ?
+    WHERE id = ?
+  `).run(
+    updatedCategory,
+    updatedFailureReason,
+    updatedToolState,
+    updatedCorrectedTo,
+    updatedCreated,
+    updatedLastReferenced,
+    existing.id,
+  );
+
+  return {
+    action: 'existing',
+    entry: getMemoryById(dbManager, existing.id)!,
+  };
+}
+
+/**
+ * Best-effort substring replacement for SQLite-backed memory sync.
+ * Updates all matches in the scoped slice to recover from prior duplicate rows.
+ */
+export function replaceSyncedMemories(
+  dbManager: DatabaseManager,
+  oldText: string,
+  updates: {
+    content: string;
+    target: 'memory' | 'user' | 'failure';
+    project?: string | null;
+    category?: MemoryCategory | null;
+    failureReason?: string | null;
+    toolState?: string | null;
+    correctedTo?: string | null;
+    lastReferenced?: string | null;
+  },
+): SqliteMemoryUpdateResult {
+  const db = dbManager.getDb();
+  const params: unknown[] = [];
+  const conditions = buildScopeConditions(params, updates.target, updates.project ?? undefined);
+  conditions.push(`content LIKE ? ESCAPE '\\'`);
+  params.push(`%${escapeLikePattern(oldText)}%`);
+
+  const rows = db.prepare(`
+    SELECT ${MEMORY_SELECT_COLUMNS}
+    FROM memories
+    WHERE ${conditions.join(' AND ')}
+    ORDER BY id ASC
+  `).all(...params) as Array<{
+    id: number;
+    project: string | null;
+    target: string;
+    category: string | null;
+    content: string;
+    failure_reason: string | null;
+    tool_state: string | null;
+    corrected_to: string | null;
+    created: string;
+    last_referenced: string;
+  }>;
+
+  if (rows.length === 0) {
+    return { matched: 0, updated: 0, entries: [] };
+  }
+
+  const nextLastReferenced = updates.lastReferenced?.trim() || today();
+
+  for (const row of rows) {
+    db.prepare(`
+      UPDATE memories
+      SET content = ?,
+          category = ?,
+          failure_reason = ?,
+          tool_state = ?,
+          corrected_to = ?,
+          last_referenced = ?
+      WHERE id = ?
+    `).run(
+      updates.content.trim(),
+      updates.category === undefined ? row.category : updates.category,
+      updates.failureReason === undefined ? row.failure_reason : normalizeNullable(updates.failureReason),
+      updates.toolState === undefined ? row.tool_state : normalizeNullable(updates.toolState),
+      updates.correctedTo === undefined ? row.corrected_to : normalizeNullable(updates.correctedTo),
+      nextLastReferenced,
+      row.id,
+    );
+  }
+
+  return {
+    matched: rows.length,
+    updated: rows.length,
+    entries: rows
+      .map((row) => getMemoryById(dbManager, row.id))
+      .filter((entry): entry is SqliteMemoryEntry => entry !== null),
+  };
+}
+
+/**
+ * Best-effort substring removal for SQLite-backed memory sync.
+ * Deletes all matches in the scoped slice to recover from prior duplicate rows.
+ */
+export function removeSyncedMemories(
+  dbManager: DatabaseManager,
+  oldText: string,
+  options: {
+    target: 'memory' | 'user' | 'failure';
+    project?: string | null;
+  },
+): SqliteMemoryRemoveResult {
+  const db = dbManager.getDb();
+  const params: unknown[] = [];
+  const conditions = buildScopeConditions(params, options.target, options.project ?? undefined);
+  conditions.push(`content LIKE ? ESCAPE '\\'`);
+  params.push(`%${escapeLikePattern(oldText)}%`);
+
+  const matchingIds = db.prepare(`
+    SELECT id
+    FROM memories
+    WHERE ${conditions.join(' AND ')}
+  `).all(...params) as Array<{ id: number }>;
+
+  if (matchingIds.length === 0) {
+    return { matched: 0, removed: 0 };
+  }
+
+  const deleteParams = matchingIds.map((row) => row.id);
+  const placeholders = deleteParams.map(() => '?').join(', ');
+  const result = db.prepare(`DELETE FROM memories WHERE id IN (${placeholders})`).run(...deleteParams);
+
+  return {
+    matched: matchingIds.length,
+    removed: result.changes,
   };
 }
 
@@ -105,7 +565,7 @@ export function searchMemories(
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
 
   const sql = `
-    SELECT id, project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced
+    SELECT ${MEMORY_SELECT_COLUMNS}
     FROM memories m
     ${whereClause}
     ORDER BY m.last_referenced DESC
@@ -126,18 +586,7 @@ export function searchMemories(
     last_referenced: string;
   }>;
 
-  return rows.map(row => ({
-    id: row.id,
-    project: row.project,
-    target: row.target as 'memory' | 'user' | 'failure',
-    category: row.category as MemoryCategory | null,
-    content: row.content,
-    failureReason: row.failure_reason,
-    toolState: row.tool_state,
-    correctedTo: row.corrected_to,
-    created: row.created,
-    lastReferenced: row.last_referenced,
-  }));
+  return rows.map(mapRow);
 }
 
 /**
@@ -175,7 +624,7 @@ export function getMemories(
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
 
   const rows = db.prepare(`
-    SELECT id, project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced
+    SELECT ${MEMORY_SELECT_COLUMNS}
     FROM memories
     ${whereClause}
     ORDER BY last_referenced DESC
@@ -192,18 +641,7 @@ export function getMemories(
     last_referenced: string;
   }>;
 
-  return rows.map(row => ({
-    id: row.id,
-    project: row.project,
-    target: row.target as 'memory' | 'user' | 'failure',
-    category: row.category as MemoryCategory | null,
-    content: row.content,
-    failureReason: row.failure_reason,
-    toolState: row.tool_state,
-    correctedTo: row.corrected_to,
-    created: row.created,
-    lastReferenced: row.last_referenced,
-  }));
+  return rows.map(mapRow);
 }
 
 /**
@@ -241,7 +679,7 @@ export function getRecentFailures(
   }
 
   const rows = db.prepare(`
-    SELECT id, project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced
+    SELECT ${MEMORY_SELECT_COLUMNS}
     FROM memories
     WHERE ${conditions.join(' AND ')}
     ORDER BY created DESC
@@ -259,18 +697,7 @@ export function getRecentFailures(
     last_referenced: string;
   }>;
 
-  return rows.map(row => ({
-    id: row.id,
-    project: row.project,
-    target: row.target as 'memory' | 'user' | 'failure',
-    category: row.category as MemoryCategory | null,
-    content: row.content,
-    failureReason: row.failure_reason,
-    toolState: row.tool_state,
-    correctedTo: row.corrected_to,
-    created: row.created,
-    lastReferenced: row.last_referenced,
-  }));
+  return rows.map(mapRow);
 }
 
 /**
@@ -278,8 +705,7 @@ export function getRecentFailures(
  */
 export function touchMemory(dbManager: DatabaseManager, id: number): void {
   const db = dbManager.getDb();
-  const today = new Date().toISOString().split('T')[0];
-  db.prepare('UPDATE memories SET last_referenced = ? WHERE id = ?').run(today, id);
+  db.prepare('UPDATE memories SET last_referenced = ? WHERE id = ?').run(today(), id);
 }
 
 /**