@massu/core 0.4.2 → 0.5.0

package/dist/hooks/post-tool-use.js

@@ -1606,9 +1606,66 @@ function storeSecurityScore(db, sessionId, filePath, riskScore, findings) {
 }
 
 // src/hooks/post-tool-use.ts
-import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
 import { join as join2 } from "path";
+import { parse as parseYaml3 } from "yaml";
+
+// src/memory-file-ingest.ts
+import { readFileSync as readFileSync5, existsSync as existsSync6, readdirSync } from "fs";
 import { parse as parseYaml2 } from "yaml";
+function ingestMemoryFile(db, sessionId, filePath) {
+  if (!existsSync6(filePath)) return "skipped";
+  const content = readFileSync5(filePath, "utf-8");
+  const basename2 = (filePath.split("/").pop() ?? "").replace(".md", "");
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  let name = basename2;
+  let description = "";
+  let type = "discovery";
+  let confidence;
+  if (frontmatterMatch) {
+    try {
+      const fm = parseYaml2(frontmatterMatch[1]);
+      name = fm.name ?? basename2;
+      description = fm.description ?? "";
+      type = fm.type ?? "discovery";
+      confidence = fm.confidence != null ? Number(fm.confidence) : void 0;
+    } catch {
+    }
+  }
+  const obsType = mapMemoryTypeToObservationType(type);
+  const importance = confidence != null ? Math.max(1, Math.min(5, Math.round(confidence * 4 + 1))) : 4;
+  const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  const body = bodyMatch ? bodyMatch[1].trim().slice(0, 500) : "";
+  const title = `[memory-file] ${name}`;
+  const detail = description ? `${description}
+
+${body}` : body;
+  const existing = db.prepare(
+    "SELECT id FROM observations WHERE title = ? LIMIT 1"
+  ).get(title);
+  if (existing) {
+    db.prepare("UPDATE observations SET detail = ?, importance = ? WHERE id = ?").run(detail, importance, existing.id);
+    return "updated";
+  } else {
+    addObservation(db, sessionId, obsType, title, detail, { importance });
+    return "inserted";
+  }
+}
+function mapMemoryTypeToObservationType(memoryType) {
+  switch (memoryType) {
+    case "user":
+    case "feedback":
+      return "decision";
+    case "project":
+      return "feature";
+    case "reference":
+      return "discovery";
+    default:
+      return "discovery";
+  }
+}
+
+// src/hooks/post-tool-use.ts
 var seenReads = /* @__PURE__ */ new Set();
 var currentSessionId = null;
 async function main() {
@@ -1705,6 +1762,18 @@ async function main() {
         }
       } catch (_memoryErr) {
       }
+      try {
+        if (tool_name === "Edit" || tool_name === "Write") {
+          const filePath = tool_input.file_path ?? "";
+          if (filePath && filePath.includes("/memory/") && filePath.endsWith(".md")) {
+            const basename2 = filePath.split("/").pop() ?? "";
+            if (basename2 !== "MEMORY.md") {
+              ingestMemoryFile(db, session_id, filePath);
+            }
+          }
+        }
+      } catch (_memoryIngestErr) {
+      }
       try {
         if (tool_name === "Edit" || tool_name === "Write") {
           const filePath = tool_input.file_path ?? "";
@@ -1768,9 +1837,9 @@ function readConventions(cwd) {
   try {
     const projectRoot = cwd ?? process.cwd();
     const configPath = join2(projectRoot, "massu.config.yaml");
-    if (!existsSync6(configPath)) return defaults;
-    const content = readFileSync5(configPath, "utf-8");
-    const parsed = parseYaml2(content);
+    if (!existsSync7(configPath)) return defaults;
+    const content = readFileSync6(configPath, "utf-8");
+    const parsed = parseYaml3(content);
     if (!parsed || typeof parsed !== "object") return defaults;
     const conventions = parsed.conventions;
     if (!conventions || typeof conventions !== "object") return defaults;
@@ -1797,11 +1866,11 @@ function isKnowledgeSourceFile(filePath) {
 function checkMemoryFileIntegrity(filePath) {
   const issues = [];
   try {
-    if (!existsSync6(filePath)) {
+    if (!existsSync7(filePath)) {
       issues.push("MEMORY.md file does not exist after write");
       return issues;
     }
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const lines = content.split("\n");
     const MAX_LINES = 200;
     if (lines.length > MAX_LINES) {

package/dist/hooks/user-prompt.js

@@ -951,6 +951,22 @@ async function main() {
         }
       } catch (_knowledgeErr) {
       }
+      try {
+        const significantSignals = ["fix", "implement", "migrate", "refactor", "debug", "decision", "chose", "architecture", "redesign", "rewrite"];
+        const promptLower = prompt.toLowerCase();
+        const signalCount = significantSignals.filter((s) => promptLower.includes(s)).length;
+        if (signalCount >= 2) {
+          const memoryFileCount = db.prepare(
+            "SELECT COUNT(*) as count FROM observations WHERE session_id = ? AND title LIKE '[memory-file] %'"
+          ).get(session_id);
+          if (memoryFileCount.count === 0) {
+            process.stderr.write(
+              "\n[MEMORY REMINDER] Significant work detected but no memory files have been written.\nConsider saving learnings to memory/*.md files for future sessions.\n\n"
+            );
+          }
+        }
+      } catch (_memoryNagErr) {
+      }
     } finally {
       db.close();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massu/core",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "description": "AI Engineering Governance MCP Server - Session memory, knowledge system, feature registry, code intelligence, rule enforcement, tiered tooling (12 free / 72 total), 43 workflow commands",
   "main": "src/server.ts",

package/src/commands/init.ts

@@ -17,6 +17,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from
 import { resolve, basename, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
+import { backfillMemoryFiles } from '../memory-file-ingest.ts';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -588,6 +589,32 @@ export async function runInit(): Promise<void> {
     console.log('  Created initial MEMORY.md');
   }
 
+  // Step 6b: Auto-backfill existing memory files into database
+  try {
+    const claudeDirName = '.claude';
+    const encodedRoot = projectRoot.replace(/\//g, '-');
+    const computedMemoryDir = resolve(homedir(), claudeDirName, 'projects', encodedRoot, 'memory');
+
+    const memFiles = existsSync(computedMemoryDir)
+      ? readdirSync(computedMemoryDir).filter(f => f.endsWith('.md') && f !== 'MEMORY.md')
+      : [];
+
+    if (memFiles.length > 0) {
+      const { getMemoryDb } = await import('../memory-db.ts');
+      const db = getMemoryDb();
+      try {
+        const stats = backfillMemoryFiles(db, computedMemoryDir, `init-${Date.now()}`);
+        if (stats.inserted > 0 || stats.updated > 0) {
+          console.log(`  Backfilled ${stats.inserted + stats.updated} memory files into database (${stats.inserted} new, ${stats.updated} updated)`);
+        }
+      } finally {
+        db.close();
+      }
+    }
+  } catch (_backfillErr) {
+    // Best-effort: don't fail init if backfill fails
+  }
+
   // Step 7: Databases info
   console.log('  Databases will auto-create on first session');
 

package/src/hooks/post-tool-use.ts

@@ -17,6 +17,7 @@ import { scoreFileSecurity, storeSecurityScore } from '../security-scorer.ts';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { parse as parseYaml } from 'yaml';
+import { ingestMemoryFile } from '../memory-file-ingest.ts';
 
 interface HookInput {
   session_id: string;
@@ -149,6 +150,22 @@ async function main(): Promise<void> {
         // Best-effort: never block post-tool-use
       }
 
+      // Memory file auto-ingest: when Claude writes a memory/*.md file,
+      // parse frontmatter and ingest into observations table
+      try {
+        if (tool_name === 'Edit' || tool_name === 'Write') {
+          const filePath = (tool_input.file_path as string) ?? '';
+          if (filePath && filePath.includes('/memory/') && filePath.endsWith('.md')) {
+            const basename = filePath.split('/').pop() ?? '';
+            if (basename !== 'MEMORY.md') {
+              ingestMemoryFile(db, session_id, filePath);
+            }
+          }
+        }
+      } catch (_memoryIngestErr) {
+        // Best-effort: never block post-tool-use
+      }
+
       // Knowledge index staleness check on knowledge file edits
       try {
         if (tool_name === 'Edit' || tool_name === 'Write') {

package/src/hooks/user-prompt.ts

@@ -86,6 +86,27 @@ async function main(): Promise<void> {
       } catch (_knowledgeErr) {
         // Best-effort: never block prompt capture
       }
+      // 6. Memory enforcement: nag when significant work detected but no memory ingestion
+      try {
+        const significantSignals = ['fix', 'implement', 'migrate', 'refactor', 'debug', 'decision', 'chose', 'architecture', 'redesign', 'rewrite'];
+        const promptLower = prompt.toLowerCase();
+        const signalCount = significantSignals.filter(s => promptLower.includes(s)).length;
+
+        if (signalCount >= 2) {
+          const memoryFileCount = db.prepare(
+            "SELECT COUNT(*) as count FROM observations WHERE session_id = ? AND title LIKE '[memory-file] %'"
+          ).get(session_id) as { count: number };
+
+          if (memoryFileCount.count === 0) {
+            process.stderr.write(
+              '\n[MEMORY REMINDER] Significant work detected but no memory files have been written.\n' +
+              'Consider saving learnings to memory/*.md files for future sessions.\n\n'
+            );
+          }
+        }
+      } catch (_memoryNagErr) {
+        // Best-effort: never block prompt capture
+      }
     } finally {
       db.close();
     }

package/src/memory-file-ingest.ts

@@ -0,0 +1,127 @@
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+// ============================================================
+// Memory File Auto-Ingest
+// Shared module for parsing memory/*.md files and ingesting
+// their YAML frontmatter + content into the observations table.
+// Used by: post-tool-use.ts, memory-tools.ts, init.ts
+// ============================================================
+
+import type Database from 'better-sqlite3';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { addObservation } from './memory-db.ts';
+
+export type IngestResult = 'inserted' | 'updated' | 'skipped';
+
+/**
+ * Parse a memory/*.md file's YAML frontmatter and ingest it into the
+ * observations table. Deduplicates by title prefix `[memory-file] {name}`.
+ *
+ * @returns 'inserted' | 'updated' | 'skipped'
+ */
+export function ingestMemoryFile(
+  db: Database.Database,
+  sessionId: string,
+  filePath: string,
+): IngestResult {
+  if (!existsSync(filePath)) return 'skipped';
+
+  const content = readFileSync(filePath, 'utf-8');
+  const basename = (filePath.split('/').pop() ?? '').replace('.md', '');
+
+  // Parse YAML frontmatter (between first --- and second ---)
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+
+  let name = basename;
+  let description = '';
+  let type = 'discovery';
+  let confidence: number | undefined;
+
+  if (frontmatterMatch) {
+    try {
+      const fm = parseYaml(frontmatterMatch[1]) as Record<string, unknown>;
+      name = (fm.name as string) ?? basename;
+      description = (fm.description as string) ?? '';
+      type = (fm.type as string) ?? 'discovery';
+      confidence = fm.confidence != null ? Number(fm.confidence) : undefined;
+    } catch {
+      // Use defaults if YAML parsing fails
+    }
+  }
+
+  // Map memory types to observation types
+  const obsType = mapMemoryTypeToObservationType(type);
+
+  // Calculate importance from confidence (0.0-1.0 -> 1-5)
+  const importance = confidence != null
+    ? Math.max(1, Math.min(5, Math.round(confidence * 4 + 1)))
+    : 4;
+
+  // Extract body (after second ---)
+  const bodyMatch = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)/);
+  const body = bodyMatch ? bodyMatch[1].trim().slice(0, 500) : '';
+
+  const title = `[memory-file] ${name}`;
+  const detail = description ? `${description}\n\n${body}` : body;
+
+  // Deduplicate: check if this exact title exists
+  const existing = db.prepare(
+    'SELECT id FROM observations WHERE title = ? LIMIT 1'
+  ).get(title) as { id: number } | undefined;
+
+  if (existing) {
+    db.prepare('UPDATE observations SET detail = ?, importance = ? WHERE id = ?')
+      .run(detail, importance, existing.id);
+    return 'updated';
+  } else {
+    addObservation(db, sessionId, obsType, title, detail, { importance });
+    return 'inserted';
+  }
+}
+
+/**
+ * Bulk-ingest all memory/*.md files from a directory.
+ * Skips MEMORY.md (the index file).
+ *
+ * @returns { inserted, updated, skipped, total }
+ */
+export function backfillMemoryFiles(
+  db: Database.Database,
+  memoryDir: string,
+  sessionId?: string,
+): { inserted: number; updated: number; skipped: number; total: number } {
+  const stats = { inserted: 0, updated: 0, skipped: 0, total: 0 };
+
+  if (!existsSync(memoryDir)) return stats;
+
+  const files = readdirSync(memoryDir).filter(
+    f => f.endsWith('.md') && f !== 'MEMORY.md'
+  );
+  stats.total = files.length;
+
+  const sid = sessionId ?? `backfill-${Date.now()}`;
+
+  for (const file of files) {
+    const result = ingestMemoryFile(db, sid, join(memoryDir, file));
+    stats[result]++;
+  }
+
+  return stats;
+}
+
+function mapMemoryTypeToObservationType(memoryType: string): string {
+  switch (memoryType) {
+    case 'user':
+    case 'feedback':
+      return 'decision';
+    case 'project':
+      return 'feature';
+    case 'reference':
+      return 'discovery';
+    default:
+      return 'discovery';
+  }
+}

package/src/memory-tools.ts

@@ -13,7 +13,8 @@ import {
   assignImportance,
   createSession,
 } from './memory-db.ts';
-import { getConfig } from './config.ts';
+import { getConfig, getResolvedPaths } from './config.ts';
+import { backfillMemoryFiles } from './memory-file-ingest.ts';
 
 /** Prefix a base tool name with the configured tool prefix. */
 function p(baseName: string): string {
@@ -101,6 +102,16 @@ export function getMemoryToolDefinitions(): ToolDefinition[] {
         required: [],
       },
     },
+    // P4-007: memory_backfill
+    {
+      name: p('memory_backfill'),
+      description: 'Scan all memory/*.md files and ingest into database. Run after massu init or to recover from DB loss. Parses YAML frontmatter and deduplicates by title.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+      },
+    },
     // P4-006: memory_ingest
     {
       name: p('memory_ingest'),
@@ -154,6 +165,8 @@ export function handleMemoryToolCall(
         return handleFailures(args, memoryDb);
       case 'memory_ingest':
         return handleIngest(args, memoryDb);
+      case 'memory_backfill':
+        return handleBackfill(memoryDb);
       default:
         return text(`Unknown memory tool: ${name}`);
     }
@@ -374,6 +387,26 @@ function handleIngest(args: Record<string, unknown>, db: Database.Database): Too
   return text(`Observation #${id} recorded successfully.\nType: ${type}\nTitle: ${title}\nImportance: ${importance}\nSession: ${activeSession.session_id.slice(0, 8)}...`);
 }
 
+function handleBackfill(db: Database.Database): ToolResult {
+  const memoryDir = getResolvedPaths().memoryDir;
+  const stats = backfillMemoryFiles(db, memoryDir);
+
+  const lines = [
+    '## Memory Backfill Results',
+    '',
+    `- **Total files scanned**: ${stats.total}`,
+    `- **Inserted (new)**: ${stats.inserted}`,
+    `- **Updated (existing)**: ${stats.updated}`,
+    `- **Skipped (not found)**: ${stats.skipped}`,
+    '',
+    stats.total === 0
+      ? 'No memory files found in memory directory.'
+      : `Successfully processed ${stats.inserted + stats.updated} of ${stats.total} memory files.`,
+  ];
+
+  return text(lines.join('\n'));
+}
+
 // ============================================================
 // Helpers
 // ============================================================