pi-hermes-memory 0.6.7 → 0.6.9

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/db.ts

@@ -51,9 +51,11 @@ export class DatabaseManager {
       db.exec(SCHEMA_SQL);
     }
 
-    // Extra safety: always ensure the legacy memories columns exist, even when
-    // schema execution succeeds (idempotent on upgraded DBs).
+    // Extra safety: always ensure legacy memories columns exist, then migrate
+    // legacy CHECK(target IN ('memory','user')) constraints to include 'failure'.
     this.ensureMemoriesColumns(db);
+    this.migrateLegacyMemoriesTargetConstraint(db);
+    this.rebuildMemoryFts(db);
 
     return db;
   }
@@ -85,6 +87,56 @@ export class DatabaseManager {
     }
   }
 
+  private migrateLegacyMemoriesTargetConstraint(db: Database.Database): void {
+    const tableSqlRow = db.prepare("SELECT sql FROM sqlite_master WHERE type='table' AND name='memories'").get() as { sql?: string } | undefined;
+    const tableSql = tableSqlRow?.sql ?? '';
+    if (!tableSql) return;
+
+    // Legacy schema allowed only memory/user. New schema must allow failure too.
+    const hasLegacyTargetCheck = /target\s+TEXT\s+NOT\s+NULL\s+CHECK\s*\(\s*target\s+IN\s*\(\s*'memory'\s*,\s*'user'\s*\)\s*\)/i.test(tableSql);
+    if (!hasLegacyTargetCheck) return;
+
+    const tx = db.transaction(() => {
+      db.exec('PRAGMA foreign_keys = OFF');
+
+      db.exec(`
+        CREATE TABLE memories_new (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          project TEXT,
+          target TEXT NOT NULL CHECK (target IN ('memory', 'user', 'failure')),
+          category TEXT CHECK (category IN ('failure', 'correction', 'insight', 'preference', 'convention', 'tool-quirk')),
+          content TEXT NOT NULL,
+          failure_reason TEXT,
+          tool_state TEXT,
+          corrected_to TEXT,
+          created DATE NOT NULL,
+          last_referenced DATE NOT NULL
+        );
+      `);
+
+      db.exec(`
+        INSERT INTO memories_new (id, project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced)
+        SELECT id, project, target, category, content, failure_reason, tool_state, corrected_to, created, last_referenced
+        FROM memories;
+      `);
+
+      db.exec('DROP TABLE memories');
+      db.exec('ALTER TABLE memories_new RENAME TO memories');
+
+      db.exec('PRAGMA foreign_keys = ON');
+    });
+
+    tx();
+  }
+
+  private rebuildMemoryFts(db: Database.Database): void {
+    const ftsTable = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memory_fts'").get() as { name?: string } | undefined;
+    if (!ftsTable) return;
+
+    // Keep FTS index consistent after table rebuild/migrations.
+    db.exec("INSERT INTO memory_fts(memory_fts) VALUES('rebuild')");
+  }
+
   /**
    * Close the database connection.
    */