pi-hermes-memory 0.7.11 → 0.7.12

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.12",
   "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/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,5 @@
 import { DatabaseManager } from './db.js';
+import { isFts5QueryError, normalizeFts5Query } from './fts-query.js';
 import type { MemoryCategory } from '../types.js';
 
 const MEMORY_SELECT_COLUMNS = `
@@ -550,19 +551,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 +559,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 +570,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 +607,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;
+  }
 }
 
 /**