pi-hermes-memory 0.7.11 → 0.7.13

package/README.md

@@ -278,6 +278,11 @@ By default, the extension indexes your Pi session history into a SQLite database
 | `session_search` | Search past conversations — "what did we discuss about auth?" |
 | `memory_search` | Search extended memory store — unlimited capacity, keyword-based |
 
+Search behavior notes:
+- Multi-word natural-language queries are supported for both `memory_search` and `session_search`.
+- Exact phrases can be requested with quotes, for example `"memory search"`.
+- Advanced FTS queries with operators like `OR` still work when you need them.
+
 Session history is indexed automatically on session shutdown. To bulk-import existing sessions:
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "🧠 Persistent memory + 🔍 session search + 🛡️ secret scanning for Pi. Token-aware policy-only memory by default, SQLite FTS5 search, auto-consolidation, procedural skills. 368 tests. Ported from Hermes agent.",
   "type": "module",
   "main": "src/index.ts",

package/src/handlers/auto-consolidate.ts

@@ -12,24 +12,38 @@ import { MemoryStore } from "../store/memory-store.js";
 import { CONSOLIDATION_PROMPT, ENTRY_DELIMITER } from "../constants.js";
 import type { ConsolidationResult } from "../types.js";
 
+type MemoryTarget = "memory" | "user" | "failure";
+type ToolMemoryTarget = MemoryTarget | "project";
+
+function entriesForTarget(store: MemoryStore, target: MemoryTarget): string[] {
+  return target === "user" ? store.getUserEntries() : store.getMemoryEntries();
+}
+
+function labelForTarget(target: MemoryTarget, toolTarget: ToolMemoryTarget): string {
+  if (toolTarget === "project") return "Project Memory";
+  if (target === "user") return "User Profile";
+  if (target === "failure") return "Failure Memory";
+  return "Memory";
+}
+
 export async function triggerConsolidation(
   pi: ExtensionAPI,
   store: MemoryStore,
-  target: "memory" | "user" | "failure",
+  target: MemoryTarget,
   signal?: AbortSignal,
   timeoutMs: number = 60000,
+  toolTarget: ToolMemoryTarget = target,
 ): Promise<ConsolidationResult> {
-  const entries =
-    target === "memory" ? store.getMemoryEntries() : store.getUserEntries();
+  const entries = entriesForTarget(store, target);
   const currentContent = entries.join(ENTRY_DELIMITER);
 
   const prompt = [
     CONSOLIDATION_PROMPT,
     "",
-    `--- Current ${target === "user" ? "User Profile" : "Memory"} Entries ---`,
+    `--- Current ${labelForTarget(target, toolTarget)} Entries ---`,
     currentContent || "(empty)",
     "",
-    `Use the memory tool to consolidate. Target: '${target}'`,
+    `Use the memory tool to consolidate. Target: '${toolTarget}'`,
   ].join("\n");
 
   try {
@@ -60,30 +74,47 @@ export function registerConsolidateCommand(
   pi: ExtensionAPI,
   store: MemoryStore,
   timeoutMs: number = 60000,
+  projectStore: MemoryStore | null = null,
+  projectName?: string | null,
 ): void {
   pi.registerCommand("memory-consolidate", {
     description: "Manually trigger memory consolidation to free up space",
     handler: async (_args, ctx) => {
       const results: string[] = [];
+      const targets: Array<{
+        label: string;
+        store: MemoryStore;
+        target: MemoryTarget;
+        toolTarget: ToolMemoryTarget;
+      }> = [
+        { label: "memory", store, target: "memory", toolTarget: "memory" },
+        { label: "user", store, target: "user", toolTarget: "user" },
+      ];
+
+      if (projectStore) {
+        targets.push({
+          label: projectName ? `project:${projectName}` : "project",
+          store: projectStore,
+          target: "memory",
+          toolTarget: "project",
+        });
+      }
 
-      for (const target of ["memory", "user"] as const) {
-        const entries =
-          target === "memory"
-            ? store.getMemoryEntries()
-            : store.getUserEntries();
+      for (const item of targets) {
+        const entries = entriesForTarget(item.store, item.target);
 
         if (entries.length === 0) {
-          results.push(`${target}: (empty, nothing to consolidate)`);
+          results.push(`${item.label}: (empty, nothing to consolidate)`);
           continue;
         }
 
-        const result = await triggerConsolidation(pi, store, target, ctx.signal, timeoutMs);
+        const result = await triggerConsolidation(pi, item.store, item.target, ctx.signal, timeoutMs, item.toolTarget);
 
         if (result.consolidated) {
-          await store.loadFromDisk();
-          results.push(`${target}: ✅ consolidated`);
+          await item.store.loadFromDisk();
+          results.push(`${item.label}: ✅ consolidated`);
         } else {
-          results.push(`${target}: ❌ ${result.error}`);
+          results.push(`${item.label}: ❌ ${result.error}`);
         }
       }
 

package/src/index.ts

@@ -177,11 +177,17 @@ export default function (pi: ExtensionAPI) {
   // ── 6. Setup session-end flush ──
   setupSessionFlush(pi, store, projectStore, config);
 
-  // ── 7. Setup auto-consolidation (inject consolidator into store) ──
+  // ── 7. Setup auto-consolidation (inject consolidator into stores) ──
   store.setConsolidator(async (target, signal) => {
     return triggerConsolidation(pi, store, target, signal, config.consolidationTimeoutMs);
   });
-  registerConsolidateCommand(pi, store, config.consolidationTimeoutMs);
+  if (projectStore) {
+    projectStore.setConsolidator(async (target, signal) => {
+      const toolTarget = target === "memory" ? "project" : target;
+      return triggerConsolidation(pi, projectStore, target, signal, config.consolidationTimeoutMs, toolTarget);
+    });
+  }
+  registerConsolidateCommand(pi, store, config.consolidationTimeoutMs, projectStore, projectName);
 
   // ── 8. Setup correction detection ──
   setupCorrectionDetector(pi, store, projectStore, config, dbManager, projectName);

package/src/store/db.ts

@@ -106,6 +106,8 @@ export class DatabaseManager {
 
     // Enable WAL mode + FK enforcement for each connection.
     db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA wal_autocheckpoint = 100');
+    db.exec('PRAGMA journal_size_limit = 5242880');
     db.exec('PRAGMA foreign_keys = ON');
 
     // Create tables and triggers
@@ -251,6 +253,7 @@ export class DatabaseManager {
    */
   close(): void {
     if (this.db) {
+      try { this.db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch { /* best effort */ }
       this.db.close();
       this.db = null;
     }

package/src/store/fts-query.ts

@@ -0,0 +1,38 @@
+const FTS5_OPERATOR_PATTERN = /\b(OR|AND|NOT|NEAR)\b/;
+const FTS5_TOKEN_PATTERN = /"([^"]*)"|(\S+)/g;
+const NATURAL_LANGUAGE_CONNECTORS = new Set(['and', 'or', 'not', 'near']);
+
+/**
+ * Normalize natural-language search input into an FTS5 query.
+ * Plain terms become individually quoted for implicit AND matching.
+ * Explicit quoted phrases are preserved, connector stopwords are ignored in
+ * natural-language mode, and raw uppercase FTS5 operators pass through.
+ */
+export function normalizeFts5Query(query: string): string {
+  const trimmed = query.trim();
+  if (trimmed.length === 0) return '';
+
+  if (FTS5_OPERATOR_PATTERN.test(trimmed)) {
+    return trimmed;
+  }
+
+  const normalizedTerms: string[] = [];
+  for (const match of trimmed.matchAll(FTS5_TOKEN_PATTERN)) {
+    const phrase = match[1];
+    const term = match[2];
+    if (phrase === undefined && term && NATURAL_LANGUAGE_CONNECTORS.has(term.toLowerCase())) {
+      continue;
+    }
+
+    const rawValue = phrase ?? term ?? '';
+    normalizedTerms.push(`"${rawValue.replace(/"/g, '""')}"`);
+  }
+
+  return normalizedTerms.join(' ');
+}
+
+export function isFts5QueryError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes('fts5') || msg.includes('unterminated string');
+}

package/src/store/memory-lookup.ts

@@ -0,0 +1,15 @@
+export function normalizeMemoryLookupText(text: string): string {
+  let normalized = text.trim();
+  if (!normalized) return "";
+
+  const firstNonEmptyLine = normalized
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0);
+  if (firstNonEmptyLine) normalized = firstNonEmptyLine;
+
+  normalized = normalized.replace(/^\S+\s+\[[^\]]+\]\s+/u, "");
+  normalized = normalized.replace(/^(\[[^\]]+\])\s+\1(\s+|$)/, "$1 ");
+
+  return normalized.trim();
+}

package/src/store/memory-store.ts

@@ -15,6 +15,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
 import { scanContent } from "./content-scanner.js";
+import { normalizeMemoryLookupText } from "./memory-lookup.js";
 import {
   ENTRY_DELIMITER,
   DEFAULT_MEMORY_CHAR_LIMIT,
@@ -117,32 +118,8 @@ export class MemoryStore {
     correctedTo?: string;
     project?: string;
   }): Promise<MemoryResult> {
-    content = content.trim();
-    if (!content) return { success: false, error: "Content cannot be empty." };
-
-    const scanError = scanContent(content);
-    if (scanError) return { success: false, error: scanError };
-
-    const categoryTag = "[" + options.category + "]";
-    const parts = [categoryTag + " " + content];
-    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);
-
-    const failureText = parts.join(" — ");
-    const today = new Date().toISOString().split("T")[0];
-    const encoded = this.encodeEntry(failureText, today, today);
-
-    this.failureEntries.push(encoded);
-    await this.saveToDisk("failure");
-
-    return {
-      success: true,
-      target: "failure",
-      message: "Failure memory saved: " + options.category,
-      entry_count: this.failureEntries.length,
-    };
+    const failureText = this.buildFailureMemoryText(content, options);
+    return this._add("failure", failureText, undefined, 1, "Failure memory saved: " + options.category);
   }
 
   getFailureEntries(maxAgeDays = 7): string[] {
@@ -158,7 +135,13 @@ export class MemoryStore {
       .map((entry) => this.stripMetadata(entry));
   }
 
-  private async _add(target: "memory" | "user" | "failure", content: string, signal?: AbortSignal, _retriesLeft = 1): Promise<MemoryResult> {
+  private async _add(
+    target: "memory" | "user" | "failure",
+    content: string,
+    signal?: AbortSignal,
+    _retriesLeft = 1,
+    addedMessage = "Entry added.",
+  ): Promise<MemoryResult> {
     content = content.trim();
     if (!content) return { success: false, error: "Content cannot be empty." };
 
@@ -194,7 +177,7 @@ export class MemoryStore {
             // CRITICAL: reload from disk — child process modified files, our arrays are stale
             await this.loadFromDisk();
             // Retry the add exactly once (retriesLeft = 0 means no more consolidation)
-            return this._add(target, content, signal, _retriesLeft - 1);
+            return this._add(target, content, signal, _retriesLeft - 1, addedMessage);
           }
         } catch {
           // Consolidation failed — fall through to error
@@ -207,7 +190,7 @@ export class MemoryStore {
     this.setEntries(target, entries);
     await this.saveToDisk(target);
 
-    return this.successResponse(target, "Entry added.");
+    return this.successResponse(target, addedMessage);
   }
 
   private async fifoEvictAndAdd(
@@ -253,7 +236,7 @@ export class MemoryStore {
   }
 
   async replace(target: "memory" | "user" | "failure", oldText: string, newContent: string): Promise<MemoryResult> {
-    oldText = oldText.trim();
+    oldText = normalizeMemoryLookupText(oldText);
     newContent = newContent.trim();
     if (!oldText) return { success: false, error: "old_text cannot be empty." };
     if (!newContent) return { success: false, error: "new_content cannot be empty. Use 'remove' to delete entries." };
@@ -299,18 +282,18 @@ export class MemoryStore {
   }
 
   async remove(target: "memory" | "user" | "failure", oldText: string): Promise<MemoryResult> {
-    oldText = oldText.trim();
+    oldText = normalizeMemoryLookupText(oldText);
     if (!oldText) return { success: false, error: "old_text cannot be empty." };
 
     const entries = this.entriesFor(target);
-    const matches = entries.filter((e) => e.includes(oldText));
+    const matches = entries.filter((e) => this.stripMetadata(e).includes(oldText));
 
     if (matches.length === 0) return { success: false, error: `No entry matched '${oldText}'.` };
     if (matches.length > 1 && new Set(matches).size > 1) {
       return {
         success: false,
         error: `Multiple entries matched '${oldText}'. Be more specific.`,
-        matches: matches.map((e) => e.slice(0, 80) + (e.length > 80 ? "..." : "")),
+        matches: matches.map((e) => this.stripMetadata(e).slice(0, 80) + (this.stripMetadata(e).length > 80 ? "..." : "")),
       };
     }
 
@@ -392,6 +375,23 @@ export class MemoryStore {
     return this.decodeEntry(text).text;
   }
 
+  private buildFailureMemoryText(content: string, options: {
+    category: MemoryCategory;
+    failureReason?: string;
+    toolState?: string;
+    correctedTo?: string;
+    project?: string;
+  }): string {
+    const trimmedContent = content.trim();
+    const categoryTag = "[" + options.category + "]";
+    const parts = [categoryTag + " " + trimmedContent];
+    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(" — ");
+  }
+
   private successResponse(target: "memory" | "user" | "failure", message?: string): MemoryResult {
     const entries = this.entriesFor(target);
     const current = this.charCount(target);
@@ -401,7 +401,6 @@ export class MemoryStore {
     const resp: MemoryResult = {
       success: true,
       target,
-      entries,
       usage: `${pct}% — ${current}/${limit} chars`,
       entry_count: entries.length,
     };

package/src/store/session-search.ts

@@ -1,17 +1,5 @@
 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, '""')}"`;
-}
+import { isFts5QueryError, normalizeFts5Query } from './fts-query.js';
 
 /**
  * Search result from session history.
@@ -52,6 +40,10 @@ export function searchSessions(
   query: string,
   options: SessionSearchOptions = {}
 ): SessionSearchResult[] {
+  if (query.trim().length === 0) {
+    return [];
+  }
+
   const db = dbManager.getDb();
   const { limit = 10, project, role, since } = options;
 
@@ -60,8 +52,12 @@ export function searchSessions(
   const params: unknown[] = [];
 
   // FTS5 match condition — use subquery for reliable rowid matching
+  const normalizedQuery = normalizeFts5Query(query);
+  if (normalizedQuery.length === 0) {
+    return [];
+  }
   conditions.push('m.rowid IN (SELECT rowid FROM message_fts WHERE message_fts MATCH ?)');
-  params.push(escapeFts5Query(query));
+  params.push(normalizedQuery);
 
   // Project filter
   if (project) {
@@ -119,8 +115,10 @@ export function searchSessions(
       snippet: row.snippet,
     }));
   } catch (err) {
-    // FTS5 can throw on malformed queries — return empty results
-    return [];
+    if (isFts5QueryError(err)) {
+      return [];
+    }
+    throw err;
   }
 }
 

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

@@ -1,4 +1,6 @@
 import { DatabaseManager } from './db.js';
+import { isFts5QueryError, normalizeFts5Query } from './fts-query.js';
+import { normalizeMemoryLookupText } from './memory-lookup.js';
 import type { MemoryCategory } from '../types.js';
 
 const MEMORY_SELECT_COLUMNS = `
@@ -420,10 +422,12 @@ export function replaceSyncedMemories(
   },
 ): SqliteMemoryUpdateResult {
   const db = dbManager.getDb();
+  const normalizedOldText = normalizeMemoryLookupText(oldText);
+  if (!normalizedOldText) return { matched: 0, updated: 0, entries: [] };
   const params: unknown[] = [];
   const conditions = buildScopeConditions(params, updates.target, updates.project ?? undefined);
   conditions.push(`content LIKE ? ESCAPE '\\'`);
-  params.push(`%${escapeLikePattern(oldText)}%`);
+  params.push(`%${escapeLikePattern(normalizedOldText)}%`);
 
   const rows = db.prepare(`
     SELECT ${MEMORY_SELECT_COLUMNS}
@@ -489,10 +493,12 @@ export function removeSyncedMemories(
   options: SqliteMemoryRemoveOptions,
 ): SqliteMemoryRemoveResult {
   const db = dbManager.getDb();
+  const normalizedOldText = normalizeMemoryLookupText(oldText);
+  if (!normalizedOldText) return { matched: 0, removed: 0 };
   const params: unknown[] = [];
   const conditions = buildScopeConditions(params, options.target, options.project ?? undefined);
   conditions.push(`content LIKE ? ESCAPE '\\'`);
-  params.push(`%${escapeLikePattern(oldText)}%`);
+  params.push(`%${escapeLikePattern(normalizedOldText)}%`);
 
   const matchingIds = db.prepare(`
     SELECT id
@@ -550,19 +556,6 @@ export function removeExactSyncedMemories(
   };
 }
 
-/**
- * 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.
  */
@@ -571,6 +564,10 @@ export function searchMemories(
   query: string,
   options: { project?: string; target?: string; category?: MemoryCategory; limit?: number } = {}
 ): SqliteMemoryEntry[] {
+  if (query.trim().length === 0) {
+    return [];
+  }
+
   const db = dbManager.getDb();
   const { project, target, category, limit = 10 } = options;
 
@@ -578,8 +575,12 @@ export function searchMemories(
   const params: unknown[] = [];
 
   // FTS5 match via subquery with escaped query
+  const normalizedQuery = normalizeFts5Query(query);
+  if (normalizedQuery.length === 0) {
+    return [];
+  }
   conditions.push('m.id IN (SELECT rowid FROM memory_fts WHERE memory_fts MATCH ?)');
-  params.push(escapeFts5Query(query));
+  params.push(normalizedQuery);
 
   if (project !== undefined) {
     if (project === null) {
@@ -611,20 +612,27 @@ export function searchMemories(
   `;
   params.push(limit);
 
-  const rows = db.prepare(sql).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;
-  }>;
-
-  return rows.map(mapRow);
+  try {
+    const rows = db.prepare(sql).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;
+    }>;
+
+    return rows.map(mapRow);
+  } catch (err) {
+    if (isFts5QueryError(err)) {
+      return [];
+    }
+    throw err;
+  }
 }
 
 /**