@massu/core 0.4.2 → 0.6.0

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/commands/install-commands.ts

@@ -2,15 +2,16 @@
 // Licensed under BSL 1.1 - see LICENSE file for details.
 
 /**
- * `massu install-commands` — Install massu slash commands into a project.
+ * `massu install-commands` — Install massu slash commands, agents, patterns,
+ * protocols, and reference files into a project.
  *
- * Copies all massu command .md files from the package's commands/ directory
- * into the project's .claude/commands/ directory. Existing massu commands
- * are updated; non-massu commands are preserved.
+ * Copies all massu assets from the npm package into the project's .claude/
+ * directory. Existing massu files are updated; non-massu files are preserved.
+ * Handles subdirectories recursively (e.g., golden-path/references/).
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';
-import { resolve, dirname } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, statSync } from 'fs';
+import { resolve, dirname, relative, join } from 'path';
 import { fileURLToPath } from 'url';
 import { getConfig } from '../config.ts';
 
@@ -18,30 +19,43 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // ============================================================
-// Command Installation
+// Asset Types
+// ============================================================
+
+/** Asset categories distributed by massu */
+const ASSET_TYPES = [
+  { name: 'commands', targetSubdir: 'commands', description: 'slash commands' },
+  { name: 'agents', targetSubdir: 'agents', description: 'agent definitions' },
+  { name: 'patterns', targetSubdir: 'patterns', description: 'pattern files' },
+  { name: 'protocols', targetSubdir: 'protocols', description: 'protocol files' },
+  { name: 'reference', targetSubdir: 'reference', description: 'reference files' },
+] as const;
+
+// ============================================================
+// Directory Resolution
 // ============================================================
 
 /**
- * Resolve the path to the bundled commands directory.
+ * Resolve the path to a bundled asset directory.
  * Handles both npm-installed and local development scenarios.
  */
-export function resolveCommandsDir(): string | null {
+export function resolveAssetDir(assetName: string): string | null {
   const cwd = process.cwd();
 
-  // 1. npm-installed: node_modules/@massu/core/commands
-  const nodeModulesPath = resolve(cwd, 'node_modules/@massu/core/commands');
+  // 1. npm-installed: node_modules/@massu/core/{assetName}
+  const nodeModulesPath = resolve(cwd, 'node_modules/@massu/core', assetName);
   if (existsSync(nodeModulesPath)) {
     return nodeModulesPath;
   }
 
-  // 2. Relative to compiled dist/cli.js → ../commands
-  const distRelPath = resolve(__dirname, '../commands');
+  // 2. Relative to compiled dist/cli.js → ../{assetName}
+  const distRelPath = resolve(__dirname, '..', assetName);
   if (existsSync(distRelPath)) {
     return distRelPath;
   }
 
-  // 3. Relative to source src/commands/ → ../../commands
-  const srcRelPath = resolve(__dirname, '../../commands');
+  // 3. Relative to source src/commands/ → ../../{assetName}
+  const srcRelPath = resolve(__dirname, '../..', assetName);
   if (existsSync(srcRelPath)) {
     return srcRelPath;
   }
@@ -49,6 +63,70 @@ export function resolveCommandsDir(): string | null {
   return null;
 }
 
+/** Legacy alias for backwards compatibility */
+export function resolveCommandsDir(): string | null {
+  return resolveAssetDir('commands');
+}
+
+// ============================================================
+// Recursive File Sync
+// ============================================================
+
+interface SyncStats {
+  installed: number;
+  updated: number;
+  skipped: number;
+}
+
+/**
+ * Recursively sync all .md files from sourceDir to targetDir.
+ * Creates subdirectories as needed. Preserves non-massu files.
+ */
+function syncDirectory(sourceDir: string, targetDir: string): SyncStats {
+  const stats: SyncStats = { installed: 0, updated: 0, skipped: 0 };
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  const entries = readdirSync(sourceDir);
+
+  for (const entry of entries) {
+    const sourcePath = resolve(sourceDir, entry);
+    const targetPath = resolve(targetDir, entry);
+    const entryStat = statSync(sourcePath);
+
+    if (entryStat.isDirectory()) {
+      // Recurse into subdirectories
+      const subStats = syncDirectory(sourcePath, targetPath);
+      stats.installed += subStats.installed;
+      stats.updated += subStats.updated;
+      stats.skipped += subStats.skipped;
+    } else if (entry.endsWith('.md')) {
+      const sourceContent = readFileSync(sourcePath, 'utf-8');
+
+      if (existsSync(targetPath)) {
+        const existingContent = readFileSync(targetPath, 'utf-8');
+        if (existingContent === sourceContent) {
+          stats.skipped++;
+          continue;
+        }
+        writeFileSync(targetPath, sourceContent, 'utf-8');
+        stats.updated++;
+      } else {
+        writeFileSync(targetPath, sourceContent, 'utf-8');
+        stats.installed++;
+      }
+    }
+  }
+
+  return stats;
+}
+
+// ============================================================
+// Install Commands (legacy API — preserved for backwards compat)
+// ============================================================
+
 export interface InstallCommandsResult {
   installed: number;
   updated: number;
@@ -60,48 +138,58 @@ export function installCommands(projectRoot: string): InstallCommandsResult {
   const claudeDirName = getConfig().conventions?.claudeDirName ?? '.claude';
   const targetDir = resolve(projectRoot, claudeDirName, 'commands');
 
-  // Ensure .claude/commands directory exists
   if (!existsSync(targetDir)) {
     mkdirSync(targetDir, { recursive: true });
   }
 
-  // Find source commands
-  const sourceDir = resolveCommandsDir();
+  const sourceDir = resolveAssetDir('commands');
   if (!sourceDir) {
     console.error('  ERROR: Could not find massu commands directory.');
     console.error('  Try reinstalling: npm install @massu/core');
     return { installed: 0, updated: 0, skipped: 0, commandsDir: targetDir };
   }
 
-  // Read all command files from source
-  const sourceFiles = readdirSync(sourceDir).filter(f => f.endsWith('.md'));
+  const stats = syncDirectory(sourceDir, targetDir);
+  return { ...stats, commandsDir: targetDir };
+}
 
-  let installed = 0;
-  let updated = 0;
-  let skipped = 0;
+// ============================================================
+// Install All Assets
+// ============================================================
 
-  for (const file of sourceFiles) {
-    const sourcePath = resolve(sourceDir, file);
-    const targetPath = resolve(targetDir, file);
-    const sourceContent = readFileSync(sourcePath, 'utf-8');
+export interface InstallAllResult {
+  assets: Record<string, SyncStats>;
+  totalInstalled: number;
+  totalUpdated: number;
+  totalSkipped: number;
+  claudeDir: string;
+}
 
-    if (existsSync(targetPath)) {
-      const existingContent = readFileSync(targetPath, 'utf-8');
-      if (existingContent === sourceContent) {
-        skipped++;
-        continue;
-      }
-      // Update existing command
-      writeFileSync(targetPath, sourceContent, 'utf-8');
-      updated++;
-    } else {
-      // Install new command
-      writeFileSync(targetPath, sourceContent, 'utf-8');
-      installed++;
+export function installAll(projectRoot: string): InstallAllResult {
+  const claudeDirName = getConfig().conventions?.claudeDirName ?? '.claude';
+  const claudeDir = resolve(projectRoot, claudeDirName);
+
+  const assets: Record<string, SyncStats> = {};
+  let totalInstalled = 0;
+  let totalUpdated = 0;
+  let totalSkipped = 0;
+
+  for (const assetType of ASSET_TYPES) {
+    const sourceDir = resolveAssetDir(assetType.name);
+    if (!sourceDir) {
+      continue;
     }
+
+    const targetDir = resolve(claudeDir, assetType.targetSubdir);
+    const stats = syncDirectory(sourceDir, targetDir);
+
+    assets[assetType.name] = stats;
+    totalInstalled += stats.installed;
+    totalUpdated += stats.updated;
+    totalSkipped += stats.skipped;
   }
 
-  return { installed, updated, skipped, commandsDir: targetDir };
+  return { assets, totalInstalled, totalUpdated, totalSkipped, claudeDir };
 }
 
 // ============================================================
@@ -112,25 +200,33 @@ export async function runInstallCommands(): Promise<void> {
   const projectRoot = process.cwd();
 
   console.log('');
-  console.log('Massu AI - Install Slash Commands');
+  console.log('Massu AI - Install Project Assets');
   console.log('==================================');
   console.log('');
 
-  const result = installCommands(projectRoot);
+  const result = installAll(projectRoot);
 
-  if (result.installed > 0) {
-    console.log(`  Installed ${result.installed} new commands`);
-  }
-  if (result.updated > 0) {
-    console.log(`  Updated ${result.updated} existing commands`);
-  }
-  if (result.skipped > 0) {
-    console.log(`  ${result.skipped} commands already up to date`);
+  // Report per-asset-type
+  for (const assetType of ASSET_TYPES) {
+    const stats = result.assets[assetType.name];
+    if (!stats) {
+      continue;
+    }
+    const total = stats.installed + stats.updated + stats.skipped;
+    if (total === 0) continue;
+
+    const parts: string[] = [];
+    if (stats.installed > 0) parts.push(`${stats.installed} new`);
+    if (stats.updated > 0) parts.push(`${stats.updated} updated`);
+    if (stats.skipped > 0) parts.push(`${stats.skipped} current`);
+
+    const description = assetType.description;
+    console.log(`  ${description}: ${parts.join(', ')} (${total} total)`);
   }
 
-  const total = result.installed + result.updated + result.skipped;
+  const grandTotal = result.totalInstalled + result.totalUpdated + result.totalSkipped;
   console.log('');
-  console.log(`  ${total} slash commands available in ${result.commandsDir}`);
+  console.log(`  ${grandTotal} total files synced to ${result.claudeDir}`);
   console.log('');
   console.log('  Restart your Claude Code session to use them.');
   console.log('');

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
 // ============================================================