grimoire-framework 1.0.8 → 1.0.10

package/.grimoire/install-manifest.yaml

@@ -7,8 +7,8 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.0.8
-generated_at: "2026-02-22T11:36:51.196Z"
+version: 1.0.10
+generated_at: "2026-02-22T12:13:30.092Z"
 generator: scripts/generate-install-manifest.js
 file_count: 1011
 files:

package/bin/commands/update.js

@@ -0,0 +1,251 @@
+'use strict';
+
+/**
+ * grimoire Smart Update Command
+ * Updates grimoire-framework preserving project customizations.
+ *
+ * Strategy:
+ *  1. Check installed vs latest version on npm
+ *  2. npm install grimoire-framework@latest
+ *  3. Selectively copy framework files (agents, rules, hooks)
+ *     - OVERWRITE files that are part of the framework source
+ *     - PRESERVE files that only exist in the project (custom agents, etc.)
+ *  4. Report what was updated/preserved
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+
+// Framework source directories (relative to node_modules/grimoire-framework)
+const FRAMEWORK_SYNC_DIRS = [
+    { src: '.codex/agents', dest: '.codex/agents' },
+    { src: '.gemini/rules/grimoire', dest: '.gemini/rules/grimoire' },
+    { src: '.cursor/rules/agents', dest: '.cursor/rules/agents' },
+    { src: '.claude/commands/grimoire', dest: '.claude/commands/grimoire' },
+];
+
+/**
+ * Fetch latest version from npm registry
+ */
+function getLatestVersion() {
+    return new Promise((resolve) => {
+        const req = https.get(
+            'https://registry.npmjs.org/grimoire-framework/latest',
+            { timeout: 10000 },
+            (res) => {
+                let data = '';
+                res.on('data', (chunk) => { data += chunk; });
+                res.on('end', () => {
+                    try { resolve(JSON.parse(data).version || null); }
+                    catch { resolve(null); }
+                });
+            }
+        );
+        req.on('error', () => resolve(null));
+        req.on('timeout', () => { req.destroy(); resolve(null); });
+    });
+}
+
+/**
+ * Get installed version from node_modules
+ */
+function getInstalledVersion(cwd) {
+    const pkgPath = path.join(cwd, 'node_modules', 'grimoire-framework', 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try { return JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version; }
+        catch { /* ignore */ }
+    }
+    // Fallback: check project package.json dependencies
+    const projPkg = path.join(cwd, 'package.json');
+    if (fs.existsSync(projPkg)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(projPkg, 'utf8'));
+            return (pkg.dependencies || {})['grimoire-framework'] ||
+                (pkg.devDependencies || {})['grimoire-framework'] || null;
+        } catch { /* ignore */ }
+    }
+    return null;
+}
+
+/**
+ * Compare semver strings. Returns: -1 (v1<v2), 0 (equal), 1 (v1>v2)
+ */
+function compareVersions(v1, v2) {
+    const parse = (v) => v.replace(/[^0-9.]/g, '').split('.').map(Number);
+    const [a, b] = [parse(v1), parse(v2)];
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0)) return 1;
+        if ((a[i] || 0) < (b[i] || 0)) return -1;
+    }
+    return 0;
+}
+
+/**
+ * Recursively get all .md files in a directory
+ */
+function listMdFiles(dir) {
+    if (!fs.existsSync(dir)) return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) results.push(...listMdFiles(full));
+        else if (entry.name.endsWith('.md')) results.push(full);
+    }
+    return results;
+}
+
+/**
+ * Sync a directory from framework source to project destination.
+ * - Overwrites files that exist in source (framework files)
+ * - Preserves files that only exist in destination (custom files)
+ * Returns stats: { updated, preserved, added }
+ */
+function syncDir(srcDir, destDir) {
+    const stats = { updated: [], preserved: [], added: [] };
+
+    if (!fs.existsSync(srcDir)) return stats;
+    fs.mkdirSync(destDir, { recursive: true });
+
+    // Get files in both dirs
+    const srcFiles = new Set(
+        fs.readdirSync(srcDir).filter(f => f.endsWith('.md') || f.endsWith('.json') || f.endsWith('.yaml'))
+    );
+    const destFiles = new Set(
+        fs.existsSync(destDir)
+            ? fs.readdirSync(destDir).filter(f => f.endsWith('.md') || f.endsWith('.json') || f.endsWith('.yaml'))
+            : []
+    );
+
+    // Copy/overwrite source files to dest
+    for (const file of srcFiles) {
+        const srcFile = path.join(srcDir, file);
+        const destFile = path.join(destDir, file);
+        const existed = destFiles.has(file);
+        fs.copyFileSync(srcFile, destFile);
+        if (existed) stats.updated.push(file);
+        else stats.added.push(file);
+    }
+
+    // Files in dest but NOT in source = custom files → preserve (do nothing)
+    for (const file of destFiles) {
+        if (!srcFiles.has(file)) {
+            stats.preserved.push(file);
+        }
+    }
+
+    return stats;
+}
+
+/**
+ * Main run function called by the CLI
+ */
+async function run(args = []) {
+    const cwd = process.cwd();
+    const dryRun = args.includes('--dry-run') || args.includes('--check');
+    const force = args.includes('--force');
+    const verbose = args.includes('--verbose') || args.includes('-v');
+
+    console.log('\n🔮 Grimoire Smart Update\n' + '='.repeat(40));
+
+    // 1. Get versions
+    const installed = getInstalledVersion(cwd);
+    process.stdout.write('📡 Checking latest version on npm...');
+    const latest = await getLatestVersion();
+    console.log(latest ? ` v${latest}` : ' (offline)');
+
+    console.log(`📦 Installed: ${installed ? `v${installed}` : '❌ not found in node_modules'}`);
+    console.log(`📦 Latest:    ${latest ? `v${latest}` : '❌ could not fetch'}\n`);
+
+    if (!installed) {
+        console.log('⚠️  grimoire-framework not found in this project.\n   Run: npx grimoire-framework install\n');
+        return;
+    }
+
+    if (!latest) {
+        console.log('⚠️  Could not reach npm registry. Check your internet connection.\n');
+        return;
+    }
+
+    const cmp = compareVersions(installed.replace(/[\^~><=]/g, ''), latest);
+
+    if (cmp >= 0 && !force) {
+        console.log('✅ Already up to date! No update needed.\n');
+        console.log('   Use --force to reinstall anyway.\n');
+        return;
+    }
+
+    if (dryRun) {
+        console.log(`🔍 DRY RUN — would update v${installed} → v${latest}\n`);
+        console.log('   Directories that would be synced:');
+        for (const { dest } of FRAMEWORK_SYNC_DIRS) {
+            console.log(`   • ${dest}`);
+        }
+        console.log('\n   Custom files (only in project) would be PRESERVED.');
+        console.log('   Run without --dry-run to apply.\n');
+        return;
+    }
+
+    // 2. Update npm package
+    console.log(`⬇️  Updating grimoire-framework v${installed} → v${latest}...`);
+    try {
+        execSync('npm install grimoire-framework@latest', {
+            cwd,
+            stdio: verbose ? 'inherit' : 'pipe',
+            timeout: 120000,
+        });
+        console.log('✅ npm package updated.\n');
+    } catch (err) {
+        console.error(`❌ npm install failed: ${err.message}\n`);
+        return;
+    }
+
+    // 3. Sync framework files selectively
+    const frameworkRoot = path.join(cwd, 'node_modules', 'grimoire-framework');
+
+    if (!fs.existsSync(frameworkRoot)) {
+        console.log('❌ Could not find grimoire-framework in node_modules after install.\n');
+        return;
+    }
+
+    console.log('🔄 Syncing framework files...\n');
+
+    const totalStats = { updated: 0, added: 0, preserved: 0 };
+    const report = [];
+
+    for (const { src, dest } of FRAMEWORK_SYNC_DIRS) {
+        const srcPath = path.join(frameworkRoot, src);
+        const destPath = path.join(cwd, dest);
+
+        if (!fs.existsSync(srcPath)) {
+            if (verbose) console.log(`  ⏭️  Skip (not in source): ${src}`);
+            continue;
+        }
+
+        const stats = syncDir(srcPath, destPath);
+        totalStats.updated += stats.updated.length;
+        totalStats.added += stats.added.length;
+        totalStats.preserved += stats.preserved.length;
+
+        report.push({ dir: dest, stats });
+
+        if (stats.updated.length || stats.added.length || stats.preserved.length) {
+            console.log(`  📁 ${dest}`);
+            if (stats.updated.length) console.log(`     ✅ Updated:   ${stats.updated.join(', ')}`);
+            if (stats.added.length) console.log(`     ➕ Added:     ${stats.added.join(', ')}`);
+            if (stats.preserved.length) console.log(`     🔒 Preserved: ${stats.preserved.join(', ')} (custom)`);
+        }
+    }
+
+    // 4. Summary
+    console.log('\n' + '='.repeat(40));
+    console.log(`✅ Updated to v${latest}\n`);
+    console.log(`   📝 Files updated:   ${totalStats.updated}`);
+    console.log(`   ➕ Files added:     ${totalStats.added}`);
+    console.log(`   🔒 Files preserved: ${totalStats.preserved} (custom — untouched)\n`);
+    console.log('   Run: grimoire status   to verify the framework is healthy.');
+    console.log('   Run: grimoire doctor   for full diagnostics.\n');
+}
+
+module.exports = { run };

package/bin/grimoire-cli.js

@@ -27,11 +27,19 @@ async function main() {
     case 'agents':
       handleAgents(args.slice(1));
       break;
+    case 'status':
+      handleStatus();
+      break;
+    case 'whoami':
+      handleWhoami();
+      break;
+    case 'update':
+      await require('./commands/update').run(args.slice(1));
+      break;
     case 'doctor':
-      console.log('🏥 Grimoire Doctor: Everything looks good!');
+      handleDoctor();
       break;
     case 'install':
-    case 'update':
     case 'validate':
     case 'info':
       console.log(`Delegating ${command} to core logic...`);
@@ -92,6 +100,14 @@ function handleAgents(args) {
   const fallbackDir = path.join(baseDir, 'node_modules', 'grimoire-framework', '.codex', 'agents');
   const dir = fs.existsSync(agentsDir) ? agentsDir : fs.existsSync(fallbackDir) ? fallbackDir : null;
 
+  // Agent name map (id -> art persona)
+  const agentNames = {
+    'dev': 'Da Vinci', 'qa': 'Dürer', 'sm': 'Monet', 'devops': 'Boccioni',
+    'ux-design-expert': 'Matisse', 'grimoire-master': 'Michelangelo',
+    'analyst': 'Vermeer', 'architect': 'Gaudí', 'data-engineer': 'Escher',
+    'pm': 'Raphael', 'po': 'Velázquez', 'squad-creator': 'Rodin',
+  };
+
   if (sub === 'list' || !sub) {
     if (!dir) {
       console.log('\n⚠️  No agents found. Run "npx grimoire-framework install" first.');
@@ -101,26 +117,214 @@ function handleAgents(args) {
       .filter(f => f.endsWith('.md'))
       .map(f => f.replace('.md', ''));
     console.log('\n🧙 Grimoire Agents:');
-    list.forEach(a => console.log(`  - ${a}`));
-    console.log(`\n  Total: ${list.length} agents`);
+    list.forEach(a => {
+      const persona = agentNames[a] ? ` (${agentNames[a]})` : '';
+      console.log(`  @${a}${persona}`);
+    });
+    console.log(`\n  Total: ${list.length} agents | Invoke with @agentname in your IDE chat`);
   } else {
     console.log('Usage: grimoire agents list');
   }
 }
 
+function handleStatus() {
+  const cwd = process.cwd();
+  const check = (p) => fs.existsSync(p);
+  const icon = (v) => v ? '✅' : '❌';
+
+  // Detect project root (has .codex or .grimoire)
+  const hasCodex = check(path.join(cwd, '.codex'));
+  const hasGrimoire = check(path.join(cwd, '.grimoire'));
+  const hasGemini = check(path.join(cwd, '.gemini'));
+  const hasCursor = check(path.join(cwd, '.cursor'));
+  const hasClaude = check(path.join(cwd, '.claude'));
+
+  // Hooks check
+  const settingsPath = path.join(cwd, '.gemini', 'settings.json');
+  let hooks = [];
+  let hooksActive = false;
+  if (check(settingsPath)) {
+    try {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      const h = settings.hooks || {};
+      hooks = Object.values(h).flat().filter(hook => hook && hook.command).map(h => h.command);
+      hooksActive = hooks.length > 0;
+    } catch (e) { /* ignore */ }
+  }
+
+  // Agents count
+  const agentsDir = path.join(cwd, '.codex', 'agents');
+  const agentCount = check(agentsDir)
+    ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).length
+    : 0;
+
+  // Memory check
+  const memDir = path.join(cwd, '.grimoire', 'memory');
+  const hasMemory = check(memDir);
+
+  // Session log (last agent used)
+  const sessionLog = path.join(cwd, '.grimoire', 'logs', 'session.log');
+  let lastAgent = null;
+  if (check(sessionLog)) {
+    try {
+      const lines = fs.readFileSync(sessionLog, 'utf8').trim().split('\n');
+      const last = lines.filter(l => l.includes('agent:')).pop();
+      if (last) lastAgent = last.split('agent:')[1]?.trim();
+    } catch (e) { /* ignore */ }
+  }
+
+  console.log(`
+🔮 Grimoire Framework Status
+${'='.repeat(40)}
+📎  Version:   v${packageJson.version}
+📁  Project:   ${cwd}
+
+🔧 Core
+  ${icon(hasCodex)}  .codex         (agents & config)
+  ${icon(hasGrimoire)}  .grimoire      (memory & metrics)
+  ${icon(agentCount > 0)}  Agents:   ${agentCount} loaded
+
+🪝 Hooks (Gemini CLI)
+  ${icon(check(settingsPath))}  settings.json
+  ${icon(hooksActive)}  Hooks active:   ${hooksActive ? hooks.length + ' configured' : 'none found'}
+
+💻 IDE Integration
+  ${icon(hasGemini)}  .gemini        (Gemini CLI rules)
+  ${icon(hasCursor)}  .cursor        (Cursor rules)
+  ${icon(hasClaude)}  .claude        (Claude commands)
+
+💾 Memory Layer
+  ${icon(hasMemory)}  Memory store   ${hasMemory ? '(active)' : '(not initialized)'}
+${lastAgent ? `
+🧙 Last Agent:  @${lastAgent}` : ''}
+
+  Run 'grimoire agents list' to see all agents.
+  Run 'grimoire whoami'     to see session context.
+`);
+}
+
+function handleWhoami() {
+  const cwd = process.cwd();
+
+  // Detect IDE from environment
+  const inCursor = process.env.CURSOR_TRACE_ID || process.env.VSCODE_PID;
+  const inVSCode = process.env.VSCODE_PID && !inCursor;
+  const inGemini = process.env.GEMINI_CLI || process.env.CLOUD_SHELL;
+  const inClaude = process.env.CLAUDE_AGENT;
+  let ide = 'Unknown IDE';
+  if (inCursor) ide = 'Cursor';
+  else if (inVSCode) ide = 'VS Code';
+  else if (inGemini) ide = 'Gemini CLI';
+  else if (inClaude) ide = 'Claude';
+
+  // Detect project name
+  const projectPkg = path.join(cwd, 'package.json');
+  let projectName = path.basename(cwd);
+  if (fs.existsSync(projectPkg)) {
+    try { projectName = JSON.parse(fs.readFileSync(projectPkg, 'utf8')).name || projectName; } catch (e) { }
+  }
+
+  // Read grimoire config if exists
+  const configPath = path.join(cwd, '.grimoire', 'config.json');
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (e) { }
+  }
+
+  // Available agents with personas
+  const agentNames = {
+    'dev': 'Da Vinci', 'qa': 'Dürer', 'sm': 'Monet', 'devops': 'Boccioni',
+    'ux-design-expert': 'Matisse', 'grimoire-master': 'Michelangelo',
+    'analyst': 'Vermeer', 'architect': 'Gaudí', 'data-engineer': 'Escher',
+    'pm': 'Raphael', 'po': 'Velázquez', 'squad-creator': 'Rodin',
+  };
+
+  const agentsDir = path.join(cwd, '.codex', 'agents');
+  const availableAgents = fs.existsSync(agentsDir)
+    ? fs.readdirSync(agentsDir).filter(f => f.endsWith('.md')).map(f => f.replace('.md', ''))
+    : [];
+
+  const agentList = availableAgents
+    .map(a => agentNames[a] ? `@${a} (${agentNames[a]})` : `@${a}`)
+    .join(', ');
+
+  console.log(`
+🧙 Grimoire — Who Am I?
+${'='.repeat(40)}
+📌  You are:      ${process.env.USER || process.env.USERNAME || 'unknown user'}
+📂  Project:      ${projectName}
+📍  Directory:    ${cwd}
+💻  IDE:          ${ide}
+🔮  Framework:    Grimoire v${packageJson.version}
+${config.squad ? `👥  Squad:        ${config.squad}` : ''}
+
+🧙 Available Agents:
+  ${agentList || '(none found — run grimoire install)'}
+
+💡 How to activate an agent:
+  In your IDE chat, type:  @dev  or  @qa  or  @grimoire-master
+  The agent will greet you by their persona name (Da Vinci, Dürer, etc.)
+
+🔧 Framework vs CLI:
+  CLI commands  → Run in terminal:    grimoire status | grimoire agents list
+  Agent chat    → Activate in IDE:    @agentname (e.g. @dev, @qa)
+  These are DIFFERENT interfaces — the CLI manages the framework,
+  agents respond inside your IDE's AI chat window.
+`);
+}
+
+function handleDoctor() {
+  const cwd = process.cwd();
+  const check = (p) => fs.existsSync(p);
+  const ok = (v, msg) => console.log(`  ${v ? '✅' : '❌'}  ${msg}`);
+
+  console.log('\n🏥 Grimoire Doctor\n' + '='.repeat(40));
+
+  ok(check(path.join(cwd, '.codex', 'agents')), '.codex/agents directory exists');
+  ok(check(path.join(cwd, '.grimoire')), '.grimoire directory exists');
+  ok(check(path.join(cwd, '.gemini', 'settings.json')), '.gemini/settings.json (hooks configured)');
+  ok(check(path.join(cwd, '.gemini', 'rules')), '.gemini/rules (agent rules installed)');
+  ok(check(path.join(cwd, '.cursor', 'rules')), '.cursor/rules (Cursor integration)');
+
+  // Check package.json has grimoire
+  const pkgPath = path.join(cwd, 'package.json');
+  if (check(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      ok(!!deps['grimoire-framework'], 'grimoire-framework in package.json');
+    } catch (e) { ok(false, 'package.json readable'); }
+  } else {
+    ok(false, 'package.json found');
+  }
+
+  console.log('\n  Run \'grimoire status\' for full framework state.\n');
+}
+
 function showHelp() {
   console.log(`
-📊 Grimoire Pro CLI v${packageJson.version}
+🔮 Grimoire Framework CLI v${packageJson.version}
+
+  The CLI manages your framework. Agents live in your IDE chat.
+  (These are DIFFERENT — CLI = terminal, Agents = @agentname in IDE chat)
 
 USAGE:
+  grimoire status           # ✨ Framework health & what's active
+  grimoire whoami           # 🧙 Session context & how to use agents
   grimoire install          # Install/Reset setup
-  grimoire agents list      # List available agents
+  grimoire agents list      # List available agents (with personas)
   grimoire squads list      # List installed squads
   grimoire memory [sub]     # Manage persistent memory
   grimoire metrics          # View productivity metrics
-  grimoire doctor           # Run diagnostics
+  grimoire doctor           # Run diagnostics (checks + tips)
   grimoire --version        # Show version
   grimoire --help           # Show this help
+
+QUICK START:
+  npx grimoire-framework install    # Set up in a new project
+  grimoire status                   # Check everything is working
+  grimoire whoami                   # See available agents
+  Then in your IDE chat: @dev  or  @qa  or  @grimoire-master
 `);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grimoire-framework",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Grimoire: AI-Orchestrated System for Full Stack Development - Core Framework",
   "publishConfig": {
     "access": "public"