pi-hermes-memory 0.6.6 → 0.6.8

package/src/handlers/learn-memory.ts

@@ -41,7 +41,7 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("  User:     Who you are — name, preferences, communication style");
         lines.push("  Failures: What didn't work — corrections, failures, insights");
         lines.push("  Skills:   Procedures — how to debug, deploy, test");
-        lines.push("  Extended: Searchable memories beyond the core limit");
+        lines.push("  Extended: SQLite search mirror for Markdown memory + backfill");
         lines.push("");
         lines.push("  Memory Categories:");
         lines.push("  ─────────────────");
@@ -70,7 +70,7 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("    Search past conversations across all sessions");
         lines.push("");
         lines.push("  memory_search");
-        lines.push("    Search extended memory store (unlimited)");
+        lines.push("    Search the SQLite-backed memory mirror/store");
         lines.push("    Filters: project, target, category");
         lines.push("    Categories: failure, correction, insight, preference, convention, tool-quirk");
       }
@@ -87,6 +87,8 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("  /memory-interview     Answer questions to pre-fill profile");
         lines.push("  /memory-switch-project List all project memories");
         lines.push("  /memory-index-sessions Import past sessions for search");
+        lines.push("  /memory-sync-markdown Backfill Markdown memories into SQLite");
+        lines.push("  /memory-preview-context Show injected memory/skill prompt blocks");
       }
 
       if (section.startsWith("✅")) {
@@ -115,12 +117,13 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("  ╚══════════════════════════════════════════════╝");
         lines.push("");
         lines.push("  1. Session starts     → Core memory + recent failures injected");
-        lines.push("  2. During conversation → Agent saves via memory tool");
-        lines.push("  3. Every 10 turns     → Background review saves items");
-        lines.push("  4. On correction      → Immediate save as [correction] category");
-        lines.push("  5. On failure         → Saves what failed + why");
-        lines.push("  6. When full          → Auto-consolidation merges");
-        lines.push("  7. Session ends       → Final flush");
+        lines.push("  2. During conversation → Agent saves to Markdown memory");
+        lines.push("  3. Successful saves   → Best-effort SQLite search sync");
+        lines.push("  4. Every 10 turns     → Background review saves items");
+        lines.push("  5. On correction      → Immediate save as [correction] category");
+        lines.push("  6. On failure         → Saves what failed + why");
+        lines.push("  7. When full          → Auto-consolidation merges");
+        lines.push("  8. Session ends       → Final flush");
       }
 
       if (section.startsWith("🏗️")) {
@@ -137,10 +140,11 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("  │ Project memory — When cwd matches   │");
         lines.push("  └─────────────────────────────────────┘");
         lines.push("");
-        lines.push("  Searchable on Demand (Unlimited)");
+        lines.push("  Searchable on Demand (SQLite mirror/store)");
         lines.push("  ┌─────────────────────────────────────┐");
         lines.push("  │ session_search(\"auth flow\")         │");
         lines.push("  │ memory_search(\"testing patterns\")   │");
+        lines.push("  │ /memory-sync-markdown (backfill old md)│");
         lines.push("  │ memory_search(\"auth\", cat:\"failure\")│");
         lines.push("  └─────────────────────────────────────┘");
       }
@@ -153,9 +157,11 @@ export function registerLearnMemoryCommand(pi: ExtensionAPI): void {
         lines.push("");
         lines.push("  \"Memory is full\"");
         lines.push("    → /memory-consolidate to merge entries");
+        lines.push("    → If it still fails, the save does NOT silently become SQLite-only");
         lines.push("");
         lines.push("  \"Can't find something\"");
-        lines.push("    → memory_search to search extended store");
+        lines.push("    → memory_search to search the SQLite mirror/store");
+        lines.push("    → /memory-sync-markdown to import older Markdown entries");
         lines.push("");
         lines.push("  \"Agent forgot something\"");
         lines.push("    → Check /memory-insights, tell agent \"remember X\"");

package/src/handlers/preview-context.ts

@@ -0,0 +1,67 @@
+/**
+ * Preview context command — /memory-preview-context shows the memory/skill blocks
+ * that are injected into the system prompt.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { MemoryStore } from "../store/memory-store.js";
+import { SkillStore } from "../store/skill-store.js";
+
+export function registerPreviewContextCommand(
+  pi: ExtensionAPI,
+  store: MemoryStore,
+  projectStore: MemoryStore | null,
+  skillStore: SkillStore,
+  projectName: string,
+): void {
+  pi.registerCommand("memory-preview-context", {
+    description: "Preview the memory/skill context blocks injected into the system prompt",
+    handler: async (_args, ctx) => {
+      const memoryBlock = store.formatForSystemPrompt();
+      const projectBlock = projectStore ? projectStore.formatProjectBlock(projectName) : "";
+      const skillIndex = await skillStore.formatIndexForSystemPrompt();
+
+      const lines: string[] = [];
+      lines.push("");
+      lines.push("  ╔══════════════════════════════════════════════╗");
+      lines.push("  ║        👀 Injected Context Preview          ║");
+      lines.push("  ╚══════════════════════════════════════════════╝");
+      lines.push("");
+      lines.push("  This is the memory/skill context appended to the system prompt.");
+      lines.push("  (Core hidden system instructions are NOT shown.)");
+      lines.push("");
+
+      let blockCount = 0;
+
+      if (memoryBlock) {
+        blockCount++;
+        lines.push("  ── MEMORY + USER + RECENT FAILURES ─────────────────────────");
+        lines.push(memoryBlock);
+        lines.push("");
+      }
+
+      if (projectBlock) {
+        blockCount++;
+        lines.push(`  ── PROJECT MEMORY (${projectName}) ─────────────────────────`);
+        lines.push(projectBlock);
+        lines.push("");
+      }
+
+      if (skillIndex) {
+        blockCount++;
+        lines.push("  ── SKILL INDEX ─────────────────────────────────────────────");
+        lines.push(skillIndex);
+        lines.push("");
+      }
+
+      if (blockCount === 0) {
+        lines.push("  No memory context blocks are currently injected.");
+        lines.push("  Add memory entries or skills, then run this command again.");
+        lines.push("");
+      }
+
+      lines.push(`  Blocks shown: ${blockCount}`);
+      ctx.ui.notify(lines.join("\n"), "info");
+    },
+  });
+}

package/src/handlers/sync-markdown-memories.ts

@@ -0,0 +1,136 @@
+/**
+ * Markdown memory sync command — /memory-sync-markdown imports existing
+ * Markdown-backed memories into the SQLite search store.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { DatabaseManager } from '../store/db.js';
+import {
+  parseMarkdownMemoryEntry,
+  syncMemoryEntry,
+} from '../store/sqlite-memory-store.js';
+import { ENTRY_DELIMITER, MEMORY_FILE, USER_FILE } from '../constants.js';
+
+interface BackfillCounters {
+  filesScanned: number;
+  entriesScanned: number;
+  imported: number;
+  skipped: number;
+  warnings: string[];
+}
+
+function readEntries(filePath: string): string[] {
+  if (!fs.existsSync(filePath)) return [];
+  const raw = fs.readFileSync(filePath, 'utf-8').trim();
+  if (!raw) return [];
+  return raw.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+}
+
+function importEntries(
+  dbManager: DatabaseManager,
+  counters: BackfillCounters,
+  entries: string[],
+  target: 'memory' | 'user' | 'failure',
+  project: string | null = null,
+): void {
+  for (const rawEntry of entries) {
+    counters.entriesScanned++;
+    try {
+      const parsed = parseMarkdownMemoryEntry(rawEntry, target, project);
+      const result = syncMemoryEntry(dbManager, parsed);
+      if (result.action === 'inserted') counters.imported++;
+      else counters.skipped++;
+    } catch (err) {
+      counters.warnings.push(
+        `${path.basename(project ?? 'global')}/${target}: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+}
+
+function scanProjectDirs(agentRoot: string, globalDir: string): Array<{ name: string; memoryFile: string }> {
+  if (!fs.existsSync(agentRoot)) return [];
+  const globalDirName = path.basename(globalDir);
+
+  return fs.readdirSync(agentRoot)
+    .map((name) => ({ name, dir: path.join(agentRoot, name) }))
+    .filter(({ name, dir }) => name !== globalDirName && fs.existsSync(dir) && fs.statSync(dir).isDirectory())
+    .map(({ name, dir }) => ({ name, memoryFile: path.join(dir, MEMORY_FILE) }))
+    .filter(({ memoryFile }) => fs.existsSync(memoryFile));
+}
+
+export function registerSyncMarkdownMemoriesCommand(
+  pi: ExtensionAPI,
+  dbManager: DatabaseManager,
+  globalDir: string,
+): void {
+  pi.registerCommand('memory-sync-markdown', {
+    description: 'Backfill Markdown memories into the SQLite search store',
+    handler: async (_args, ctx: ExtensionCommandContext) => {
+      const counters: BackfillCounters = {
+        filesScanned: 0,
+        entriesScanned: 0,
+        imported: 0,
+        skipped: 0,
+        warnings: [],
+      };
+
+      ctx.ui.notify('🔄 Scanning Markdown memory files for SQLite backfill...', 'info');
+
+      try {
+        const globalMemoryFile = path.join(globalDir, MEMORY_FILE);
+        const globalUserFile = path.join(globalDir, USER_FILE);
+        const globalFailureFile = path.join(globalDir, 'failures.md');
+
+        const importFile = (
+          filePath: string,
+          target: 'memory' | 'user' | 'failure',
+          project: string | null = null,
+        ) => {
+          if (!fs.existsSync(filePath)) return;
+          counters.filesScanned++;
+          const entries = readEntries(filePath);
+          importEntries(dbManager, counters, entries, target, project);
+        };
+
+        importFile(globalMemoryFile, 'memory');
+        importFile(globalUserFile, 'user');
+        importFile(globalFailureFile, 'failure');
+
+        const agentRoot = path.dirname(globalDir);
+        const projects = scanProjectDirs(agentRoot, globalDir);
+        for (const project of projects) {
+          importFile(project.memoryFile, 'memory', project.name);
+        }
+
+        let output = `\n✅ Markdown → SQLite sync complete!\n\n`;
+        output += `📊 Results:\n`;
+        output += `├─ Files scanned: ${counters.filesScanned}\n`;
+        output += `├─ Entries scanned: ${counters.entriesScanned}\n`;
+        output += `├─ Imported into SQLite: ${counters.imported}\n`;
+        output += `└─ Skipped as duplicates: ${counters.skipped}\n`;
+
+        if (projects.length > 0) {
+          output += `\n📁 Project memories scanned: ${projects.length}\n`;
+        }
+
+        if (counters.warnings.length > 0) {
+          output += `\n⚠️ Warnings (${counters.warnings.length}):\n`;
+          for (const warning of counters.warnings.slice(0, 5)) {
+            output += `├─ ${warning}\n`;
+          }
+          if (counters.warnings.length > 5) {
+            output += `└─ ... and ${counters.warnings.length - 5} more\n`;
+          }
+        }
+
+        output += `\n💡 Re-running this command is safe — existing SQLite rows are de-duplicated.`;
+        ctx.ui.notify(output, 'info');
+      } catch (err) {
+        ctx.ui.notify(`❌ Markdown sync failed: ${err instanceof Error ? err.message : String(err)}`, 'error');
+      }
+    },
+  });
+}

package/src/index.ts

@@ -45,6 +45,8 @@ import { registerInterviewCommand } from "./handlers/interview.js";
 import { registerSwitchProjectCommand } from "./handlers/switch-project.js";
 import { registerIndexSessionsCommand } from "./handlers/index-sessions.js";
 import { registerLearnMemoryCommand } from "./handlers/learn-memory.js";
+import { registerSyncMarkdownMemoriesCommand } from "./handlers/sync-markdown-memories.js";
+import { registerPreviewContextCommand } from "./handlers/preview-context.js";
 import { loadConfig } from "./config.js";
 import { detectProject } from "./project.js";
 
@@ -90,8 +92,8 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // ── 3. Register the memory tool (with project store) ──
-  registerMemoryTool(pi, store, projectStore);
+  // ── 3. Register the memory tool (with project store + SQLite sync) ──
+  registerMemoryTool(pi, store, projectStore, dbManager, projectName);
 
   // ── 4. Register the skill tool ──
   registerSkillTool(pi, skillStore);
@@ -109,7 +111,7 @@ export default function (pi: ExtensionAPI) {
   registerConsolidateCommand(pi, store);
 
   // ── 8. Setup correction detection ──
-  setupCorrectionDetector(pi, store, projectStore, config);
+  setupCorrectionDetector(pi, store, projectStore, config, dbManager);
 
   // ── 9. Setup skill auto-trigger ──
   setupSkillAutoTrigger(pi, store, skillStore, config);
@@ -120,6 +122,8 @@ export default function (pi: ExtensionAPI) {
   registerInterviewCommand(pi, store);
   registerSwitchProjectCommand(pi);
   registerLearnMemoryCommand(pi);
+  registerSyncMarkdownMemoriesCommand(pi, dbManager, globalDir);
+  registerPreviewContextCommand(pi, store, projectStore, skillStore, projectName);
 
   // ── 11. SQLite session search + extended memory ──
   registerSessionSearchTool(pi, dbManager);

package/src/store/memory-store.ts

@@ -19,6 +19,8 @@ import {
   ENTRY_DELIMITER,
   DEFAULT_MEMORY_CHAR_LIMIT,
   DEFAULT_USER_CHAR_LIMIT,
+  DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS,
+  DEFAULT_FAILURE_INJECTION_MAX_ENTRIES,
   MEMORY_FILE,
   USER_FILE,
 } from "../constants.js";
@@ -280,12 +282,17 @@ export class MemoryStore {
     if (this.snapshot.user) parts.push(this.fenceBlock(this.snapshot.user));
 
     // Add recent failure memories
-    const recentFailures = this.getFailureEntries(7);
-    if (recentFailures.length > 0) {
-      const maxFailures = 5;
-      const failures = recentFailures.slice(0, maxFailures);
-      const failureBlock = this.renderFailureBlock(failures);
-      parts.push(this.fenceBlock(failureBlock));
+    if (this.config.failureInjectionEnabled !== false) {
+      const maxAgeDays = this.config.failureInjectionMaxAgeDays ?? DEFAULT_FAILURE_INJECTION_MAX_AGE_DAYS;
+      const maxFailures = this.config.failureInjectionMaxEntries ?? DEFAULT_FAILURE_INJECTION_MAX_ENTRIES;
+      const recentFailures = this.getFailureEntries(maxAgeDays);
+      if (recentFailures.length > 0) {
+        const failures = recentFailures.slice(0, maxFailures);
+        if (failures.length > 0) {
+          const failureBlock = this.renderFailureBlock(failures);
+          parts.push(this.fenceBlock(failureBlock));
+        }
+      }
     }
 
     return parts.join("\n\n");