pi-hermes-memory 0.3.3 → 0.4.1

package/src/store/session-search.ts

@@ -0,0 +1,134 @@
+import { DatabaseManager } from './db.js';
+
+/**
+ * Escape a string for FTS5 query syntax.
+ * Wraps the query in double quotes to treat it as a literal phrase.
+ */
+function escapeFts5Query(query: string): string {
+  // If the query already contains FTS5 operators (OR, AND, NOT, NEAR), leave it as-is
+  if (/\b(OR|AND|NOT|NEAR)\b/.test(query)) {
+    return query;
+  }
+  // Otherwise, wrap in double quotes to treat as literal phrase
+  return `"${query.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Search result from session history.
+ */
+export interface SessionSearchResult {
+  sessionId: string;
+  project: string;
+  role: string;
+  content: string;
+  timestamp: string;
+  snippet: string;
+}
+
+/**
+ * Search options for session search.
+ */
+export interface SessionSearchOptions {
+  /** Maximum number of results (default: 10) */
+  limit?: number;
+  /** Filter by project name */
+  project?: string;
+  /** Filter by role: 'user', 'assistant', 'system' */
+  role?: string;
+  /** Only return messages after this date (ISO string) */
+  since?: string;
+}
+
+/**
+ * Search across indexed session messages using FTS5.
+ *
+ * @param dbManager — Database manager instance
+ * @param query — FTS5 search query
+ * @param options — Search options
+ * @returns Array of search results with snippets
+ */
+export function searchSessions(
+  dbManager: DatabaseManager,
+  query: string,
+  options: SessionSearchOptions = {}
+): SessionSearchResult[] {
+  const db = dbManager.getDb();
+  const { limit = 10, project, role, since } = options;
+
+  // Build the query dynamically based on filters
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  // FTS5 match condition — use subquery for reliable rowid matching
+  conditions.push('m.rowid IN (SELECT rowid FROM message_fts WHERE message_fts MATCH ?)');
+  params.push(escapeFts5Query(query));
+
+  // Project filter
+  if (project) {
+    conditions.push('s.project = ?');
+    params.push(project);
+  }
+
+  // Role filter
+  if (role) {
+    conditions.push('m.role = ?');
+    params.push(role);
+  }
+
+  // Date filter
+  if (since) {
+    conditions.push('m.timestamp >= ?');
+    params.push(since);
+  }
+
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+  const sql = `
+    SELECT
+      m.session_id,
+      s.project,
+      m.role,
+      m.content,
+      m.timestamp,
+      m.content as snippet
+    FROM messages m
+    JOIN sessions s ON s.id = m.session_id
+    ${whereClause}
+    ORDER BY m.timestamp DESC
+    LIMIT ?
+  `;
+  params.push(limit);
+
+  try {
+    const rows = db.prepare(sql).all(...params) as Array<{
+      session_id: string;
+      project: string;
+      role: string;
+      content: string;
+      timestamp: string;
+      snippet: string;
+    }>;
+
+    // Map snake_case column names to camelCase
+    return rows.map(row => ({
+      sessionId: row.session_id,
+      project: row.project,
+      role: row.role,
+      content: row.content,
+      timestamp: row.timestamp,
+      snippet: row.snippet,
+    }));
+  } catch (err) {
+    // FTS5 can throw on malformed queries — return empty results
+    return [];
+  }
+}
+
+/**
+ * Get the total number of indexed messages.
+ */
+export function getIndexedMessageCount(dbManager: DatabaseManager): number {
+  const db = dbManager.getDb();
+  const result = db.prepare('SELECT COUNT(*) as count FROM messages').get() as { count: number };
+  return result.count;
+}

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

@@ -0,0 +1,215 @@
+import { DatabaseManager } from './db.js';
+
+/**
+ * A memory entry stored in SQLite.
+ */
+export interface SqliteMemoryEntry {
+  id: number;
+  project: string | null;
+  target: 'memory' | 'user';
+  content: string;
+  created: string;
+  lastReferenced: string;
+}
+
+/**
+ * Add a memory entry to the SQLite store.
+ */
+export function addMemory(
+  dbManager: DatabaseManager,
+  content: string,
+  target: 'memory' | 'user' = 'memory',
+  project: string | null = null
+): SqliteMemoryEntry {
+  const db = dbManager.getDb();
+  const today = new Date().toISOString().split('T')[0];
+
+  const result = db.prepare(`
+    INSERT INTO memories (project, target, content, created, last_referenced)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(project, target, content, today, today);
+
+  return {
+    id: Number(result.lastInsertRowid),
+    project,
+    target,
+    content,
+    created: today,
+    lastReferenced: today,
+  };
+}
+
+/**
+ * Escape a string for FTS5 query syntax.
+ * Wraps the query in double quotes to treat it as a literal phrase.
+ */
+function escapeFts5Query(query: string): string {
+  // If the query already contains FTS5 operators (OR, AND, NOT, NEAR), leave it as-is
+  if (/\b(OR|AND|NOT|NEAR)\b/.test(query)) {
+    return query;
+  }
+  // Otherwise, wrap in double quotes to treat as literal phrase
+  return `"${query.replace(/"/g, '""')}"`;
+}
+
+/**
+ * Search memories using FTS5.
+ */
+export function searchMemories(
+  dbManager: DatabaseManager,
+  query: string,
+  options: { project?: string; target?: string; limit?: number } = {}
+): SqliteMemoryEntry[] {
+  const db = dbManager.getDb();
+  const { project, target, limit = 10 } = options;
+
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  // FTS5 match via subquery with escaped query
+  conditions.push('m.id IN (SELECT rowid FROM memory_fts WHERE memory_fts MATCH ?)');
+  params.push(escapeFts5Query(query));
+
+  if (project !== undefined) {
+    if (project === null) {
+      conditions.push('m.project IS NULL');
+    } else {
+      conditions.push('m.project = ?');
+      params.push(project);
+    }
+  }
+
+  if (target) {
+    conditions.push('m.target = ?');
+    params.push(target);
+  }
+
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+  const sql = `
+    SELECT id, project, target, content, created, last_referenced
+    FROM memories m
+    ${whereClause}
+    ORDER BY m.last_referenced DESC
+    LIMIT ?
+  `;
+  params.push(limit);
+
+  const rows = db.prepare(sql).all(...params) as Array<{
+    id: number;
+    project: string | null;
+    target: string;
+    content: string;
+    created: string;
+    last_referenced: string;
+  }>;
+
+  return rows.map(row => ({
+    id: row.id,
+    project: row.project,
+    target: row.target as 'memory' | 'user',
+    content: row.content,
+    created: row.created,
+    lastReferenced: row.last_referenced,
+  }));
+}
+
+/**
+ * Get all memories, optionally filtered.
+ */
+export function getMemories(
+  dbManager: DatabaseManager,
+  options: { project?: string | null; target?: string } = {}
+): SqliteMemoryEntry[] {
+  const db = dbManager.getDb();
+  const { project, target } = options;
+
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (project !== undefined) {
+    if (project === null) {
+      conditions.push('project IS NULL');
+    } else {
+      conditions.push('project = ?');
+      params.push(project);
+    }
+  }
+
+  if (target) {
+    conditions.push('target = ?');
+    params.push(target);
+  }
+
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+
+  const rows = db.prepare(`
+    SELECT id, project, target, content, created, last_referenced
+    FROM memories
+    ${whereClause}
+    ORDER BY last_referenced DESC
+  `).all(...params) as Array<{
+    id: number;
+    project: string | null;
+    target: string;
+    content: string;
+    created: string;
+    last_referenced: string;
+  }>;
+
+  return rows.map(row => ({
+    id: row.id,
+    project: row.project,
+    target: row.target as 'memory' | 'user',
+    content: row.content,
+    created: row.created,
+    lastReferenced: row.last_referenced,
+  }));
+}
+
+/**
+ * Remove a memory by ID.
+ */
+export function removeMemory(dbManager: DatabaseManager, id: number): boolean {
+  const db = dbManager.getDb();
+  const result = db.prepare('DELETE FROM memories WHERE id = ?').run(id);
+  return result.changes > 0;
+}
+
+/**
+ * Update a memory's last_referenced date.
+ */
+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);
+}
+
+/**
+ * Get memory statistics.
+ */
+export function getMemoryStats(dbManager: DatabaseManager): {
+  total: number;
+  byProject: { project: string | null; count: number }[];
+  byTarget: { target: string; count: number }[];
+} {
+  const db = dbManager.getDb();
+
+  const total = (db.prepare('SELECT COUNT(*) as count FROM memories').get() as { count: number }).count;
+
+  const byProject = db.prepare(`
+    SELECT project, COUNT(*) as count
+    FROM memories
+    GROUP BY project
+    ORDER BY count DESC
+  `).all() as { project: string | null; count: number }[];
+
+  const byTarget = db.prepare(`
+    SELECT target, COUNT(*) as count
+    FROM memories
+    GROUP BY target
+    ORDER BY count DESC
+  `).all() as { target: string; count: number }[];
+
+  return { total, byProject, byTarget };
+}

package/src/tools/memory-search-tool.ts

@@ -0,0 +1,74 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { DatabaseManager } from '../store/db.js';
+import { searchMemories, getMemoryStats } from '../store/sqlite-memory-store.js';
+
+interface SearchResult {
+  success: boolean;
+  count?: number;
+  message?: string;
+  output?: string;
+}
+
+export function registerMemorySearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+  pi.registerTool({
+    name: 'memory_search',
+    label: 'Memory Search',
+    description: `Search extended memory store for relevant entries. Use this when you need context beyond what's in the system prompt — the extended store has unlimited capacity and is searchable.
+
+Use cases:
+- Find memories about a specific topic: "What do I know about auth setup?"
+- Search project-specific memories: "What conventions does project X follow?"
+- Find user preferences: "What are the user's testing preferences?"
+
+Returns matching memory entries with project context and dates.`,
+    promptSnippet: 'Search extended memory store (unlimited capacity)',
+    promptGuidelines: [
+      'Use memory_search when you need context beyond what is in the system prompt.',
+      'Use memory_search to find project-specific memories or user preferences.',
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: 'Search query. Use natural language or specific terms.' }),
+      project: Type.Optional(Type.String({ description: 'Filter by project name. Pass null for global memories only.' })),
+      target: Type.Optional(StringEnum(['memory', 'user'] as const, { description: 'Filter by target type (memory or user).' })),
+      limit: Type.Optional(Type.Number({ description: 'Maximum results to return (default: 10, max: 20).' })),
+    }),
+    execute: async (_id: string, args: { query: string; project?: string; target?: string; limit?: number }) => {
+      const query = args.query;
+      const project = args.project;
+      const target = args.target;
+      const limit = Math.min(args.limit || 10, 20);
+
+      if (!query || query.trim().length === 0) {
+        const result: SearchResult = { success: false, message: 'query is required' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const stats = getMemoryStats(dbManager);
+      if (stats.total === 0) {
+        const result: SearchResult = { success: false, message: 'No memories in extended store yet. Use the memory tool with add action to store memories.' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const results = searchMemories(dbManager, query, { project, target, limit });
+
+      if (results.length === 0) {
+        const result: SearchResult = { success: true, count: 0, message: `No memories found matching "${query}". Try a different search term or broader query.` };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      let output = `Found ${results.length} memories matching "${query}":\n\n`;
+
+      for (const entry of results) {
+        const projectLabel = entry.project ? `[${entry.project}]` : '[global]';
+        const targetLabel = entry.target === 'user' ? '👤' : '🧠';
+        output += `${targetLabel} ${projectLabel} ${entry.content}\n`;
+        output += `   Created: ${entry.created} | Last used: ${entry.lastReferenced}\n\n`;
+      }
+
+      const finalResult: SearchResult = { success: true, count: results.length, output: output.trim() };
+      return { content: [{ type: 'text' as const, text: output.trim() }], details: finalResult };
+    },
+  });
+}

package/src/tools/session-search-tool.ts

@@ -0,0 +1,79 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import { StringEnum } from "@mariozechner/pi-ai";
+import { DatabaseManager } from '../store/db.js';
+import { searchSessions, getIndexedMessageCount } from '../store/session-search.js';
+
+interface SearchResult {
+  success: boolean;
+  count?: number;
+  message?: string;
+  output?: string;
+}
+
+export function registerSessionSearchTool(pi: ExtensionAPI, dbManager: DatabaseManager): void {
+  pi.registerTool({
+    name: 'session_search',
+    label: 'Session Search',
+    description: `Search across past Pi coding sessions for relevant conversation context. Use this when the user asks about previous discussions, past work, or when you need context from earlier sessions.
+
+Examples:
+- "What did we discuss about auth last week?"
+- "Find the PR where we fixed the test hang"
+- "What approach did we take for the database migration?"
+
+Returns conversation snippets with session dates and project context.`,
+    promptSnippet: 'Search past conversations for relevant context',
+    promptGuidelines: [
+      'Use session_search when the user asks about previous discussions or past work.',
+      'Use session_search when you need context from earlier sessions.',
+    ],
+    parameters: Type.Object({
+      query: Type.String({ description: 'Search query. Use natural language or specific terms.' }),
+      project: Type.Optional(Type.String({ description: 'Filter by project name (optional).' })),
+      role: Type.Optional(StringEnum(['user', 'assistant'] as const, { description: 'Filter by message role (optional).' })),
+      limit: Type.Optional(Type.Number({ description: 'Maximum results to return (default: 10, max: 20).' })),
+    }),
+    execute: async (_id: string, args: { query: string; project?: string; role?: string; limit?: number }) => {
+      const query = args.query;
+      const project = args.project;
+      const role = args.role;
+      const limit = Math.min(args.limit || 10, 20);
+
+      if (!query || query.trim().length === 0) {
+        const result: SearchResult = { success: false, message: 'query is required' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const totalMessages = getIndexedMessageCount(dbManager);
+      if (totalMessages === 0) {
+        const result: SearchResult = { success: false, message: 'No sessions indexed yet. Run /memory-index-sessions to import past sessions.' };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      const results = searchSessions(dbManager, query, { project, role, limit });
+
+      if (results.length === 0) {
+        const result: SearchResult = { success: true, count: 0, message: `No results found for "${query}". Try a different search term or broader query.` };
+        return { content: [{ type: 'text' as const, text: result.message! }], details: result };
+      }
+
+      let output = `Found ${results.length} results for "${query}":\n\n`;
+
+      for (const r of results) {
+        const date = new Date(r.timestamp).toLocaleDateString('en-US', {
+          year: 'numeric',
+          month: 'short',
+          day: 'numeric',
+        });
+
+        output += `---\n`;
+        output += `📅 ${date} | 📁 ${r.project} | ${r.role === 'user' ? '👤 User' : '🤖 Assistant'}\n`;
+        output += `${r.snippet}\n\n`;
+      }
+
+      const finalResult: SearchResult = { success: true, count: results.length, output: output.trim() };
+      return { content: [{ type: 'text' as const, text: output.trim() }], details: finalResult };
+    },
+  });
+}

package/src/types.ts

@@ -5,11 +5,11 @@
 import type { TextContent } from "@mariozechner/pi-ai";
 
 export interface MemoryConfig {
-  /** Max chars for MEMORY.md (agent notes). Default: 2200 */
+  /** Max chars for MEMORY.md (agent notes). Default: 5000 */
   memoryCharLimit: number;
-  /** Max chars for USER.md (user profile). Default: 1375 */
+  /** Max chars for USER.md (user profile). Default: 5000 */
   userCharLimit: number;
-  /** Max chars for project-level MEMORY.md. Default: 2200 */
+  /** Max chars for project-level MEMORY.md. Default: 5000 */
   projectCharLimit: number;
   /** Turns between background auto-reviews. Default: 10 */
   nudgeInterval: number;
@@ -29,6 +29,10 @@ export interface MemoryConfig {
   correctionDetection: boolean;
   /** Tool calls before triggering background review (in addition to turn count). Default: 15 */
   nudgeToolCalls: number;
+  /** Enable session history search via SQLite FTS5. Default: true */
+  sessionSearchEnabled?: boolean;
+  /** Days to retain session history. Default: 90 */
+  sessionRetentionDays?: number;
 }
 
 export interface MemoryResult {