pi-hermes-memory 0.7.0 → 0.7.2

package/README.md

@@ -412,6 +412,8 @@ Create `~/.pi/agent/hermes-memory-config.json`:
 
 These are plain markdown files. You can read and edit them directly if you want to curate what the agent remembers. Memory entries are separated by `§` (section sign). Skills use standard SKILL.md format with frontmatter.
 
+If you are upgrading from a version that stored project memory directly at `~/.pi/agent/<project>/MEMORY.md`, the extension copies or merges those entries into `~/.pi/agent/projects-memory/<project>/MEMORY.md` on startup. The old folders are left in place as a backup.
+
 The `sessions.db` SQLite database stores session history and extended memory entries. It's searchable via FTS5 full-text search.
 
 ## Known Limitations

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-hermes-memory",
-  "version": "0.7.0",
-  "description": "🧠 Persistent memory + 🔍 session search + 🛡️ secret scanning for Pi. Token-aware policy-only memory by default, SQLite FTS5 search, auto-consolidation, procedural skills. 362 tests. Ported from Hermes agent.",
+  "version": "0.7.2",
+  "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",
   "files": [

package/src/handlers/correction-detector.ts

@@ -78,6 +78,7 @@ export function setupCorrectionDetector(
   projectStore: MemoryStore | null,
   config: MemoryConfig,
   dbManager: DatabaseManager | null = null,
+  projectName?: string | null,
 ): void {
   if (!config.correctionDetection) return;
 
@@ -174,11 +175,11 @@ export function setupCorrectionDetector(
         if (correctionText) {
           const directive = extractCorrectionDirective(correctionText);
           const failureReason = "User corrected the agent";
-          const projectMarker = projectStore ? "project" : undefined;
+          const scopedProjectName = projectStore ? projectName?.trim() || null : null;
           const addResult = await store.addFailure(directive, {
             category: "correction",
             failureReason,
-            project: projectMarker,
+            project: scopedProjectName ?? undefined,
           });
 
           if (addResult.success && dbManager) {
@@ -187,9 +188,10 @@ export function setupCorrectionDetector(
                 content: formatFailureMemoryContent(directive, {
                   category: "correction",
                   failureReason,
-                  project: projectMarker,
+                  project: scopedProjectName,
                 }),
                 target: "failure",
+                project: scopedProjectName,
                 category: "correction",
                 failureReason,
               });

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

@@ -13,7 +13,7 @@ import {
 } from '../store/sqlite-memory-store.js';
 import { ENTRY_DELIMITER, MEMORY_FILE, USER_FILE } from '../constants.js';
 
-interface BackfillCounters {
+export interface BackfillCounters {
   filesScanned: number;
   entriesScanned: number;
   imported: number;
@@ -52,15 +52,77 @@ function importEntries(
 
 function scanProjectDirs(agentRoot: string, globalDir: string, projectsMemoryDir = "projects-memory"): Array<{ name: string; memoryFile: string }> {
   const projectsRoot = path.join(agentRoot, projectsMemoryDir);
-  if (!fs.existsSync(projectsRoot)) return [];
+  const projects = new Map<string, string>();
+
+  if (fs.existsSync(projectsRoot)) {
+    for (const name of fs.readdirSync(projectsRoot)) {
+      const dir = path.join(projectsRoot, name);
+      const memoryFile = path.join(dir, MEMORY_FILE);
+      if (fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(memoryFile)) {
+        projects.set(name, memoryFile);
+      }
+    }
+  }
+
+  const globalDirName = path.basename(globalDir);
+  if (fs.existsSync(agentRoot)) {
+    for (const name of fs.readdirSync(agentRoot)) {
+      if (name === globalDirName || name === projectsMemoryDir || name === 'skills' || name.startsWith('.')) continue;
+      if (projects.has(name)) continue;
+      const dir = path.join(agentRoot, name);
+      const memoryFile = path.join(dir, MEMORY_FILE);
+      if (fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(memoryFile)) {
+        projects.set(name, memoryFile);
+      }
+    }
+  }
 
-  return fs.readdirSync(projectsRoot)
-    .map((name) => ({ name, dir: path.join(projectsRoot, name) }))
-    .filter(({ dir }) => fs.existsSync(dir) && fs.statSync(dir).isDirectory())
-    .map(({ name, dir }) => ({ name, memoryFile: path.join(dir, MEMORY_FILE) }))
+  return [...projects.entries()]
+    .map(([name, memoryFile]) => ({ name, memoryFile }))
     .filter(({ memoryFile }) => fs.existsSync(memoryFile));
 }
 
+export function syncMarkdownMemoriesToSqlite(
+  dbManager: DatabaseManager,
+  globalDir: string,
+  projectsMemoryDir?: string,
+): BackfillCounters & { projectCount: number } {
+  const counters: BackfillCounters = {
+    filesScanned: 0,
+    entriesScanned: 0,
+    imported: 0,
+    skipped: 0,
+    warnings: [],
+  };
+
+  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, projectsMemoryDir);
+  for (const project of projects) {
+    importFile(project.memoryFile, 'memory', project.name);
+  }
+
+  return { ...counters, projectCount: projects.length };
+}
+
 export function registerSyncMarkdownMemoriesCommand(
   pi: ExtensionAPI,
   dbManager: DatabaseManager,
@@ -70,41 +132,10 @@ export function registerSyncMarkdownMemoriesCommand(
   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, projectsMemoryDir);
-        for (const project of projects) {
-          importFile(project.memoryFile, 'memory', project.name);
-        }
+        const counters = syncMarkdownMemoriesToSqlite(dbManager, globalDir, projectsMemoryDir);
 
         let output = `\n✅ Markdown → SQLite sync complete!\n\n`;
         output += `📊 Results:\n`;
@@ -113,8 +144,8 @@ export function registerSyncMarkdownMemoriesCommand(
         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.projectCount > 0) {
+          output += `\n📁 Project memories scanned: ${counters.projectCount}\n`;
         }
 
         if (counters.warnings.length > 0) {

package/src/index.ts

@@ -45,11 +45,12 @@ 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 { registerSyncMarkdownMemoriesCommand, syncMarkdownMemoriesToSqlite } from "./handlers/sync-markdown-memories.js";
 import { registerPreviewContextCommand } from "./handlers/preview-context.js";
 import { loadConfig } from "./config.js";
 import { detectProject } from "./project.js";
 import { buildPromptContext } from "./prompt-context.js";
+import { migrateLegacyProjectMemoryDirs } from "./project-memory-migration.js";
 
 export default function (pi: ExtensionAPI) {
   const config = loadConfig();
@@ -59,6 +60,16 @@ export default function (pi: ExtensionAPI) {
   const skillStore = new SkillStore(path.join(globalDir, "skills"));
   const dbManager = new DatabaseManager(globalDir);
 
+  // Keep project memory available for users upgrading from the old
+  // ~/.pi/agent/<project>/ layout. This is non-destructive: legacy folders
+  // remain in place while entries are copied/merged into projects-memory/.
+  migrateLegacyProjectMemoryDirs(globalDir, config.projectsMemoryDir);
+  try {
+    syncMarkdownMemoriesToSqlite(dbManager, globalDir, config.projectsMemoryDir);
+  } catch {
+    // Best-effort only: failed SQLite backfill should not block extension startup.
+  }
+
   // Detect project from cwd using shared helper
   const project = detectProject(config.projectsMemoryDir);
 
@@ -105,7 +116,7 @@ export default function (pi: ExtensionAPI) {
   registerConsolidateCommand(pi, store);
 
   // ── 8. Setup correction detection ──
-  setupCorrectionDetector(pi, store, projectStore, config, dbManager);
+  setupCorrectionDetector(pi, store, projectStore, config, dbManager, projectName);
 
   // ── 9. Setup skill auto-trigger ──
   setupSkillAutoTrigger(pi, store, skillStore, config);

package/src/project-memory-migration.ts

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ENTRY_DELIMITER, MEMORY_FILE } from "./constants.js";
+
+export interface ProjectMemoryMigrationResult {
+  scanned: number;
+  copied: number;
+  merged: 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 writeEntries(filePath: string, entries: string[]): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, entries.join(ENTRY_DELIMITER), "utf-8");
+}
+
+function isLegacyProjectDir(agentRoot: string, projectsMemoryDir: string, name: string): boolean {
+  if (name === "memory" || name === "skills" || name === projectsMemoryDir) return false;
+  if (name.startsWith(".")) return false;
+
+  const dir = path.join(agentRoot, name);
+  return fs.existsSync(dir) && fs.statSync(dir).isDirectory() && fs.existsSync(path.join(dir, MEMORY_FILE));
+}
+
+export function migrateLegacyProjectMemoryDirs(
+  globalDir: string,
+  projectsMemoryDir = "projects-memory",
+): ProjectMemoryMigrationResult {
+  const result: ProjectMemoryMigrationResult = {
+    scanned: 0,
+    copied: 0,
+    merged: 0,
+    skipped: 0,
+    warnings: [],
+  };
+
+  const agentRoot = path.dirname(globalDir);
+  if (!fs.existsSync(agentRoot)) return result;
+
+  const projectsRoot = path.join(agentRoot, projectsMemoryDir);
+
+  for (const name of fs.readdirSync(agentRoot)) {
+    if (!isLegacyProjectDir(agentRoot, projectsMemoryDir, name)) continue;
+    result.scanned++;
+
+    const legacyFile = path.join(agentRoot, name, MEMORY_FILE);
+    const targetFile = path.join(projectsRoot, name, MEMORY_FILE);
+
+    try {
+      const legacyEntries = readEntries(legacyFile);
+      if (legacyEntries.length === 0) {
+        result.skipped++;
+        continue;
+      }
+
+      if (!fs.existsSync(targetFile)) {
+        writeEntries(targetFile, legacyEntries);
+        result.copied++;
+        continue;
+      }
+
+      const targetEntries = readEntries(targetFile);
+      const mergedEntries = [...targetEntries];
+      const seen = new Set(targetEntries);
+
+      for (const entry of legacyEntries) {
+        if (!seen.has(entry)) {
+          seen.add(entry);
+          mergedEntries.push(entry);
+        }
+      }
+
+      if (mergedEntries.length === targetEntries.length) {
+        result.skipped++;
+        continue;
+      }
+
+      writeEntries(targetFile, mergedEntries);
+      result.merged++;
+    } catch (err) {
+      result.warnings.push(`${name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  return result;
+}

package/src/tools/memory-tool.ts

@@ -179,8 +179,8 @@ export function registerMemoryTool(
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       const { action, target: rawTarget, content, old_text, category, failure_reason } = params;
 
-      // Route 'project' to projectStore (internal target 'memory')
-      const target = rawTarget as "memory" | "user" | "failure";
+      // Route 'project' to projectStore using the normal MEMORY.md target.
+      const target = rawTarget === "project" ? "memory" : rawTarget as "memory" | "user" | "failure";
       const activeStore = rawTarget === "project" ? projectStore : store;
 
       if (rawTarget === "project" && !projectStore) {