grimoire-framework 1.0.0

package/.grimoire/cli/commands/generate/index.js

@@ -0,0 +1,222 @@
+/**
+ * Generate Command
+ *
+ * CLI command for generating documents using the Template Engine.
+ * Supports: prd, adr, pmdr, dbdr, story, epic, task
+ *
+ * @module cli/commands/generate
+ * @version 1.0.0
+ * @story 3.9 - Template PMDR (AC3.9.8)
+ */
+
+'use strict';
+
+const { Command } = require('commander');
+const path = require('path');
+
+// Lazy load TemplateEngine to avoid startup overhead
+let TemplateEngine = null;
+
+/**
+ * Get TemplateEngine instance (lazy loaded)
+ * @returns {Object} TemplateEngine class
+ */
+function getTemplateEngine() {
+  if (!TemplateEngine) {
+    const enginePath = path.join(__dirname, '..', '..', '..', 'product', 'templates', 'engine');
+    const engine = require(enginePath);
+    TemplateEngine = engine.TemplateEngine;
+  }
+  return TemplateEngine;
+}
+
+/**
+ * Generate a document from template
+ * @param {string} templateType - Template type (prd, adr, pmdr, etc.)
+ * @param {Object} options - Command options
+ */
+async function generateDocument(templateType, options) {
+  const Engine = getTemplateEngine();
+
+  const engine = new Engine({
+    interactive: !options.nonInteractive,
+    baseDir: options.baseDir || process.cwd(),
+  });
+
+  // Validate template type
+  if (!engine.supportedTypes.includes(templateType)) {
+    console.error(`❌ Unsupported template type: ${templateType}`);
+    console.log(`\nSupported types: ${engine.supportedTypes.join(', ')}`);
+    process.exit(1);
+  }
+
+  try {
+    console.log(`\n📝 Generating ${templateType.toUpperCase()} document...\n`);
+
+    // Build context from options
+    const context = {};
+    if (options.title) context.title = options.title;
+    if (options.number) context.number = parseInt(options.number, 10);
+    if (options.status) context.status = options.status;
+    if (options.owner) context.owner = options.owner;
+
+    // Generate document
+    const result = await engine.generate(templateType, context, {
+      validate: !options.skipValidation,
+      save: options.save,
+      outputPath: options.output,
+    });
+
+    // Output result
+    if (options.save && result.savedTo) {
+      console.log(`\n✅ Document saved to: ${result.savedTo}`);
+    } else if (!options.save) {
+      console.log('\n--- Generated Document ---\n');
+      console.log(result.content);
+      console.log('\n--- End Document ---\n');
+    }
+
+    // Show validation warnings
+    if (result.validation && !result.validation.isValid) {
+      console.warn('\n⚠️  Validation warnings:');
+      result.validation.errors.forEach(err => console.warn(`   - ${err}`));
+    }
+
+    // Show metadata
+    if (options.verbose) {
+      console.log('\n📊 Metadata:');
+      console.log(`   Template: ${result.templateType}`);
+      console.log(`   Generated: ${result.generatedAt}`);
+      if (result.savedTo) console.log(`   Saved to: ${result.savedTo}`);
+    }
+
+  } catch (error) {
+    console.error(`\n❌ Generation failed: ${error.message}`);
+    if (options.verbose) {
+      console.error('\nStack trace:', error.stack);
+    }
+    process.exit(1);
+  }
+}
+
+/**
+ * List available templates
+ * @param {Object} options - Command options
+ */
+async function listTemplates(options) {
+  const Engine = getTemplateEngine();
+  const engine = new Engine({ interactive: false });
+
+  try {
+    const templates = await engine.listTemplates();
+
+    console.log('\n📋 Available Templates:\n');
+
+    if (options.json) {
+      console.log(JSON.stringify(templates, null, 2));
+    } else {
+      templates.forEach(t => {
+        const status = t.status === 'missing' ? '⚠️  (missing)' : '✅';
+        console.log(`  ${status} ${t.type.padEnd(10)} - ${t.name} v${t.version}`);
+
+        if (options.verbose && t.variables.length > 0) {
+          console.log('     Variables:');
+          t.variables.forEach(v => {
+            const req = v.required ? '*' : ' ';
+            console.log(`       ${req}${v.name} (${v.type})`);
+          });
+        }
+      });
+    }
+
+    console.log('');
+  } catch (error) {
+    console.error(`❌ Error listing templates: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Show template info
+ * @param {string} templateType - Template type
+ * @param {Object} options - Command options
+ */
+async function showTemplateInfo(templateType, options) {
+  const Engine = getTemplateEngine();
+  const engine = new Engine({ interactive: false });
+
+  try {
+    const info = await engine.getTemplateInfo(templateType);
+
+    if (options.json) {
+      console.log(JSON.stringify(info, null, 2));
+    } else {
+      console.log(`\n📝 Template: ${info.name}`);
+      console.log(`   Type: ${info.type}`);
+      console.log(`   Version: ${info.version}`);
+      console.log('\n   Variables:');
+      info.variables.forEach(v => {
+        const req = v.required ? '(required)' : '(optional)';
+        console.log(`     - ${v.name}: ${v.type} ${req}`);
+        if (v.description) console.log(`       ${v.description}`);
+      });
+      console.log('');
+    }
+  } catch (error) {
+    console.error(`❌ Error getting template info: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Create the generate command
+ * @returns {Command} Commander command instance
+ */
+function createGenerateCommand() {
+  const generate = new Command('generate')
+    .description('Generate documents from templates (prd, adr, pmdr, dbdr, story, epic, task)')
+    .argument('[type]', 'Template type to generate')
+    .option('-t, --title <title>', 'Document title')
+    .option('-n, --number <number>', 'Document number')
+    .option('-s, --status <status>', 'Initial status')
+    .option('-o, --owner <owner>', 'Document owner')
+    .option('--output <path>', 'Output file path')
+    .option('--save', 'Save to file (default location if --output not specified)')
+    .option('--non-interactive', 'Disable interactive prompts')
+    .option('--skip-validation', 'Skip schema validation')
+    .option('--base-dir <dir>', 'Base directory for paths')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('--json', 'Output as JSON')
+    .action(async (type, options) => {
+      if (!type) {
+        // No type specified - show help
+        generate.help();
+        return;
+      }
+      await generateDocument(type, options);
+    });
+
+  // Add list subcommand
+  generate
+    .command('list')
+    .description('List available templates')
+    .option('-v, --verbose', 'Show variable details')
+    .option('--json', 'Output as JSON')
+    .action(listTemplates);
+
+  // Add info subcommand
+  generate
+    .command('info <type>')
+    .description('Show template information')
+    .option('--json', 'Output as JSON')
+    .action(showTemplateInfo);
+
+  return generate;
+}
+
+module.exports = {
+  createGenerateCommand,
+  generateDocument,
+  listTemplates,
+  showTemplateInfo,
+};

package/.grimoire/cli/commands/manifest/index.js

@@ -0,0 +1,47 @@
+/**
+ * Manifest Command Module
+ *
+ * Entry point for all manifest-related CLI commands.
+ * Includes validate and regenerate subcommands.
+ *
+ * @module cli/commands/manifest
+ * @version 1.0.0
+ * @story 2.13 - Manifest System
+ */
+
+const { Command } = require('commander');
+const { createValidateCommand } = require('./validate');
+const { createRegenerateCommand } = require('./regenerate');
+
+/**
+ * Create the manifest command with all subcommands
+ * @returns {Command} Commander command instance
+ */
+function createManifestCommand() {
+  const manifest = new Command('manifest');
+
+  manifest
+    .description('Manage grimoire manifest files for agents, workers, and tasks')
+    .addHelpText('after', `
+Commands:
+  validate          Validate all manifest files
+  regenerate        Regenerate manifests from source files
+
+Examples:
+  $ grimoire manifest validate
+  $ grimoire manifest validate --verbose
+  $ grimoire manifest regenerate
+  $ grimoire manifest regenerate --force
+`);
+
+  // Add subcommands
+  manifest.addCommand(createValidateCommand());
+  manifest.addCommand(createRegenerateCommand());
+
+  return manifest;
+}
+
+module.exports = {
+  createManifestCommand,
+};
+

package/.grimoire/cli/commands/manifest/regenerate.js

@@ -0,0 +1,97 @@
+/**
+ * Manifest Regenerate Command
+ *
+ * CLI command to regenerate all manifest files from source.
+ *
+ * @module cli/commands/manifest/regenerate
+ * @version 1.0.0
+ * @story 2.13 - Manifest System
+ */
+
+const { Command } = require('commander');
+const path = require('path');
+const { createManifestGenerator } = require('../../../core/manifest/manifest-generator');
+
+/**
+ * Create the regenerate subcommand
+ * @returns {Command} Commander command instance
+ */
+function createRegenerateCommand() {
+  const regenerate = new Command('regenerate');
+
+  regenerate
+    .description('Regenerate all manifest files from source files')
+    .option('-f, --force', 'Force regeneration even if manifests exist')
+    .option('--json', 'Output results as JSON')
+    .option('--dry-run', 'Show what would be generated without writing files')
+    .action(async (options) => {
+      try {
+        const generator = createManifestGenerator({
+          basePath: process.cwd(),
+        });
+
+        if (!options.dryRun) {
+          console.log('Scanning .grimoire/...\n');
+        } else {
+          console.log('[DRY RUN] Would generate:\n');
+        }
+
+        const results = await generator.generateAll();
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+          return;
+        }
+
+        // Format output
+        const formatResult = (name, result) => {
+          if (result.success) {
+            const verb = options.dryRun ? 'Would generate' : 'Generated';
+            console.log(`✓ ${verb} ${name}.csv (${result.count} entries)`);
+            if (result.errors.length > 0) {
+              result.errors.forEach(e => console.log(`  ⚠ ${e}`));
+            }
+          } else {
+            console.log(`✗ Failed to generate ${name}.csv`);
+            result.errors.forEach(e => console.log(`  ✗ ${e}`));
+          }
+        };
+
+        formatResult('agents', results.agents);
+        formatResult('workers', results.workers);
+        formatResult('tasks', results.tasks);
+
+        console.log('');
+
+        if (results.errors.length > 0) {
+          console.log('❌ Errors during generation:');
+          results.errors.forEach(e => console.log(`  ✗ ${e}`));
+          process.exit(1);
+        }
+
+        const allSuccess = results.agents.success &&
+                          results.workers.success &&
+                          results.tasks.success;
+
+        if (allSuccess) {
+          const verb = options.dryRun ? 'Would be generated' : 'regenerated';
+          console.log(`✅ Manifests ${verb}!`);
+          console.log(`   Duration: ${results.duration}ms`);
+        } else {
+          console.log('❌ Some manifests failed to generate');
+          process.exit(1);
+        }
+
+      } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  return regenerate;
+}
+
+module.exports = {
+  createRegenerateCommand,
+};
+

package/.grimoire/cli/commands/manifest/validate.js

@@ -0,0 +1,66 @@
+/**
+ * Manifest Validate Command
+ *
+ * CLI command to validate all manifest files.
+ *
+ * @module cli/commands/manifest/validate
+ * @version 1.0.0
+ * @story 2.13 - Manifest System
+ */
+
+const { Command } = require('commander');
+const path = require('path');
+const { createManifestValidator } = require('../../../core/manifest/manifest-validator');
+
+/**
+ * Create the validate subcommand
+ * @returns {Command} Commander command instance
+ */
+function createValidateCommand() {
+  const validate = new Command('validate');
+
+  validate
+    .description('Validate all manifest files for integrity and file existence')
+    .option('-v, --verbose', 'Show detailed validation information')
+    .option('--json', 'Output results as JSON')
+    .option('--strict', 'Treat warnings as errors')
+    .action(async (options) => {
+      try {
+        const validator = createManifestValidator({
+          basePath: process.cwd(),
+          verbose: options.verbose,
+        });
+
+        console.log('Validating manifests...\n');
+
+        const results = await validator.validateAll();
+
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          console.log(validator.formatResults(results));
+        }
+
+        // Exit with error code if validation failed
+        const hasErrors = results.summary.invalid > 0;
+        const hasWarningsAsErrors = options.strict && (
+          results.summary.missing.length > 0 ||
+          results.summary.orphan.length > 0
+        );
+
+        if (hasErrors || hasWarningsAsErrors) {
+          process.exit(1);
+        }
+
+      } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+      }
+    });
+
+  return validate;
+}
+
+module.exports = {
+  createValidateCommand,
+};

package/.grimoire/cli/commands/mcp/add.js

@@ -0,0 +1,235 @@
+/**
+ * MCP Add Command
+ *
+ * Adds a server to the global MCP configuration.
+ *
+ * @module cli/commands/mcp/add
+ * @version 1.0.0
+ * @story 2.11 - MCP System Global
+ */
+
+const { Command } = require('commander');
+const {
+  addServer,
+  removeServer,
+  setServerEnabled,
+  globalConfigExists,
+  getAvailableTemplates,
+  getServerTemplate,
+  listServers,
+} = require('../../../core/mcp/global-config-manager');
+const { getGlobalConfigPath } = require('../../../core/mcp/os-detector');
+
+/**
+ * Create the add command
+ * @returns {Command} Commander command instance
+ */
+function createAddCommand() {
+  const add = new Command('add');
+
+  add
+    .description('Add a server to global MCP configuration')
+    .argument('[server]', 'Server name to add (uses template if available)')
+    .option('--type <type>', 'Server type: sse or command')
+    .option('--url <url>', 'Server URL (for SSE type)')
+    .option('--command <cmd>', 'Command to run (for command type)')
+    .option('--args <args>', 'Comma-separated command arguments')
+    .option('--env <env>', 'Environment variables (KEY=value,KEY2=value2)')
+    .option('--disable', 'Add server in disabled state')
+    .option('--remove', 'Remove server instead of adding')
+    .option('--enable', 'Enable an existing server')
+    .option('--list-templates', 'List available server templates')
+    .option('-v, --verbose', 'Show detailed output')
+    .action(async (server, options) => {
+      await executeAdd(server, options);
+    });
+
+  return add;
+}
+
+/**
+ * Execute the add command
+ * @param {string} server - Server name
+ * @param {Object} options - Command options
+ */
+async function executeAdd(server, options) {
+  // Handle list templates
+  if (options.listTemplates) {
+    console.log('Available server templates:\n');
+    const templates = getAvailableTemplates();
+
+    for (const name of templates) {
+      const template = getServerTemplate(name);
+      const type = template.type || 'command';
+      console.log(`  ${name}`);
+      console.log(`    Type: ${type}`);
+      if (template.url) {
+        console.log(`    URL: ${template.url}`);
+      }
+      if (template.command) {
+        console.log(`    Command: ${template.command} ${(template.args || []).join(' ')}`);
+      }
+      console.log('');
+    }
+
+    console.log('Usage: grimoire mcp add <server-name>');
+    console.log('Example: grimoire mcp add context7');
+    return;
+  }
+
+  // Check global config exists
+  if (!globalConfigExists()) {
+    console.error('❌ Global MCP config not found.');
+    console.log('Run "grimoire mcp setup" first to create global configuration.');
+    process.exit(1);
+  }
+
+  // Server name required for most operations
+  if (!server) {
+    console.error('❌ Server name required.');
+    console.log('Usage: grimoire mcp add <server-name>');
+    console.log('');
+    console.log('Available templates:');
+    for (const name of getAvailableTemplates()) {
+      console.log(`  - ${name}`);
+    }
+    console.log('');
+    console.log('Or provide custom config:');
+    console.log('  grimoire mcp add myserver --type sse --url https://example.com/mcp');
+    console.log('  grimoire mcp add myserver --command npx --args "-y,@scope/mcp-server"');
+    process.exit(1);
+  }
+
+  // Handle remove
+  if (options.remove) {
+    console.log(`Removing server "${server}"...\n`);
+
+    const result = removeServer(server);
+    if (result.success) {
+      console.log(`✅ Server "${server}" removed from global config`);
+    } else {
+      console.error(`❌ ${result.error}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle enable/disable existing server
+  // --enable enables an existing server, --disable (without other add options) disables it
+  const isToggleOperation = options.enable || (options.disable && !options.type && !options.url && !options.command);
+  if (isToggleOperation) {
+    const enabled = Boolean(options.enable);
+    console.log(`${enabled ? 'Enabling' : 'Disabling'} server "${server}"...\n`);
+
+    const result = setServerEnabled(server, enabled);
+    if (result.success) {
+      console.log(`✅ Server "${server}" ${enabled ? 'enabled' : 'disabled'}`);
+    } else {
+      console.error(`❌ ${result.error}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Build server config
+  let serverConfig = null;
+
+  // Check if custom config provided
+  if (options.type || options.url || options.command) {
+    serverConfig = {
+      enabled: !options.disable,
+    };
+
+    if (options.type === 'sse' || options.url) {
+      if (!options.url) {
+        console.error('❌ SSE type requires --url');
+        process.exit(1);
+      }
+      serverConfig.type = 'sse';
+      serverConfig.url = options.url;
+    } else {
+      if (!options.command) {
+        console.error('❌ Command type requires --command');
+        process.exit(1);
+      }
+      serverConfig.command = options.command;
+
+      if (options.args) {
+        serverConfig.args = options.args.split(',').map(a => a.trim());
+      }
+
+      if (options.env) {
+        serverConfig.env = {};
+        const envPairs = options.env.split(',');
+        for (const pair of envPairs) {
+          const [key, ...valueParts] = pair.split('=');
+          if (key) {
+            serverConfig.env[key.trim()] = valueParts.join('=').trim();
+          }
+        }
+      }
+    }
+  }
+
+  // Add server
+  console.log(`Adding "${server}" to global config...\n`);
+
+  const result = addServer(server, serverConfig);
+
+  if (result.success) {
+    console.log(`✅ Added to ${getGlobalConfigPath()}`);
+
+    // Show server details
+    if (options.verbose) {
+      const servers = listServers();
+      const added = servers.servers.find(s => s.name === server);
+      if (added) {
+        console.log('\nServer details:');
+        console.log(`  Name: ${added.name}`);
+        console.log(`  Type: ${added.type}`);
+        console.log(`  Enabled: ${added.enabled}`);
+        if (added.url) console.log(`  URL: ${added.url}`);
+        if (added.command) console.log(`  Command: ${added.command}`);
+      }
+    }
+
+    console.log(`\n✅ Server "${server}" added!`);
+
+    // Check if template was used
+    const template = getServerTemplate(server);
+    if (template && !serverConfig) {
+      console.log('\nNote: Used built-in template.');
+      if (template.env) {
+        const envVars = Object.keys(template.env).filter(k => template.env[k].startsWith('${'));
+        if (envVars.length > 0) {
+          console.log('Required environment variables:');
+          for (const varName of envVars) {
+            const envKey = template.env[varName].replace(/\$\{|\}/g, '');
+            console.log(`  - ${envKey}`);
+          }
+        }
+      }
+    }
+  } else {
+    console.error(`❌ ${result.error}`);
+
+    // Suggest alternatives
+    if (result.error.includes('No template available')) {
+      console.log('\nAvailable templates:');
+      for (const name of getAvailableTemplates()) {
+        console.log(`  - ${name}`);
+      }
+      console.log('\nOr provide custom config:');
+      console.log(`  grimoire mcp add ${server} --type sse --url <url>`);
+      console.log(`  grimoire mcp add ${server} --command npx --args "-y,@scope/server"`);
+    }
+
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  createAddCommand,
+  executeAdd,
+};
+