@iservu-inc/adf-cli 0.13.0 → 0.14.1

package/lib/templates/scripts/validate.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+
+/**
+ * AgentDevFramework Configuration Validator
+ * Validates framework configuration, tools, agents, templates, and structure
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const FRAMEWORK_ROOT = path.join(__dirname, '..');
+
+// Expected structure
+const EXPECTED_STRUCTURE = {
+  tools: [
+    'windsurf',
+    'cursor',
+    'vscode',
+    'vscode-insider',
+    'kiro',
+    'trae',
+    'claude-code',
+    'gemini-cli',
+    'codex-cli'
+  ],
+  agents: [
+    'analyst.md',
+    'pm.md',
+    'architect.md',
+    'sm.md',
+    'dev.md',
+    'qa.md'
+  ],
+  templates: [
+    'prp-template.md',
+    'prp_base.md',
+    'prp_story.md',
+    'prp_task.md',
+    'prp_spec.md',
+    'prp_planning.md',
+    'prd-template.md',
+    'spec-template.md',
+    'plan-template.md',
+    'tasks-template.md',
+    'story-template.md'
+  ],
+  scripts: [
+    'deploy.js',
+    'init-docs.js',
+    'validate.js',
+    'validate-env.js',
+    'validate-mcp.js'
+  ],
+  core: [
+    'README.md',
+    'package.json',
+    '.env.template',
+    'QUICK-START.md',
+    'AGENTDEVFRAMEWORK-CLAUDE.md'
+  ]
+};
+
+const TOOL_CONFIGS = {
+  windsurf: { file: '.windsurfrules', required: true },
+  cursor: { files: ['.cursorrules', '.cursor/rules/dev.md'], required: true },
+  vscode: { files: ['.github/copilot-instructions.md', '.vscode/settings.json'], required: true },
+  'vscode-insider': { files: ['.github/copilot-instructions.md', '.vscode/settings.json'], required: true },
+  kiro: { files: ['product.md', 'technical.md', 'style.md'], required: true },
+  trae: { file: 'config.json', required: true },
+  'claude-code': { files: ['CLAUDE.md', '.claude/commands'], required: true },
+  'gemini-cli': { file: 'GEMINI.md', required: true },
+  'codex-cli': { files: ['instructions.md', 'config.toml'], required: true }
+};
+
+class FrameworkValidator {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  log(message, type = 'info') {
+    const symbols = {
+      success: chalk.green('✓'),
+      error: chalk.red('✗'),
+      warning: chalk.yellow('⚠'),
+      info: chalk.blue('ℹ')
+    };
+    console.log(`${symbols[type]} ${message}`);
+  }
+
+  addError(message) {
+    this.errors.push(message);
+    this.failed++;
+  }
+
+  addWarning(message) {
+    this.warnings.push(message);
+  }
+
+  checkFileExists(filePath, description) {
+    const fullPath = path.join(FRAMEWORK_ROOT, filePath);
+    if (fs.existsSync(fullPath)) {
+      this.passed++;
+      return true;
+    } else {
+      this.addError(`Missing ${description}: ${filePath}`);
+      return false;
+    }
+  }
+
+  checkDirExists(dirPath, description) {
+    const fullPath = path.join(FRAMEWORK_ROOT, dirPath);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      this.passed++;
+      return true;
+    } else {
+      this.addError(`Missing ${description} directory: ${dirPath}`);
+      return false;
+    }
+  }
+
+  validateCoreFiles() {
+    console.log(chalk.bold('\n📁 Validating Core Files...'));
+
+    EXPECTED_STRUCTURE.core.forEach(file => {
+      this.checkFileExists(file, 'core file');
+    });
+
+    // Check package.json validity
+    try {
+      const pkgPath = path.join(FRAMEWORK_ROOT, 'package.json');
+      const pkg = require(pkgPath);
+
+      if (!pkg.name || !pkg.version || !pkg.scripts) {
+        this.addError('package.json is missing required fields');
+      } else {
+        this.log('package.json is valid', 'success');
+      }
+
+      // Check required scripts
+      const requiredScripts = ['deploy', 'validate', 'init-docs'];
+      requiredScripts.forEach(script => {
+        if (!pkg.scripts[script]) {
+          this.addWarning(`Missing script in package.json: ${script}`);
+        }
+      });
+    } catch (error) {
+      this.addError(`Failed to parse package.json: ${error.message}`);
+    }
+  }
+
+  validateDirectoryStructure() {
+    console.log(chalk.bold('\n📂 Validating Directory Structure...'));
+
+    const dirs = [
+      { path: 'shared', desc: 'Shared resources' },
+      { path: 'shared/agents', desc: 'Agents' },
+      { path: 'shared/templates', desc: 'Templates' },
+      { path: 'shared/memory', desc: 'Memory/Constitution' },
+      { path: 'shared/mcp', desc: 'MCP configuration' },
+      { path: 'tools', desc: 'Tool configurations' },
+      { path: 'scripts', desc: 'Scripts' },
+      { path: 'docs', desc: 'Documentation' },
+      { path: 'examples', desc: 'Examples' }
+    ];
+
+    dirs.forEach(({ path: dirPath, desc }) => {
+      this.checkDirExists(dirPath, desc);
+    });
+  }
+
+  validateAgents() {
+    console.log(chalk.bold('\n🤖 Validating Agent Definitions...'));
+
+    EXPECTED_STRUCTURE.agents.forEach(agent => {
+      const agentPath = path.join('shared', 'agents', agent);
+      if (this.checkFileExists(agentPath, `agent ${agent}`)) {
+        // Validate agent content
+        try {
+          const content = fs.readFileSync(
+            path.join(FRAMEWORK_ROOT, agentPath),
+            'utf-8'
+          );
+
+          // Check for required sections
+          const requiredSections = [
+            'Your Role',
+            'Context Engineering',
+            'Constitutional'
+          ];
+
+          const missingSections = requiredSections.filter(
+            section => !content.includes(section)
+          );
+
+          if (missingSections.length > 0) {
+            this.addWarning(
+              `Agent ${agent} missing sections: ${missingSections.join(', ')}`
+            );
+          }
+        } catch (error) {
+          this.addError(`Failed to read agent ${agent}: ${error.message}`);
+        }
+      }
+    });
+  }
+
+  validateTemplates() {
+    console.log(chalk.bold('\n📝 Validating Templates...'));
+
+    EXPECTED_STRUCTURE.templates.forEach(template => {
+      const templatePath = path.join('shared', 'templates', template);
+      if (this.checkFileExists(templatePath, `template ${template}`)) {
+        // Validate template content
+        try {
+          const content = fs.readFileSync(
+            path.join(FRAMEWORK_ROOT, templatePath),
+            'utf-8'
+          );
+
+          // Check for META section in PRP templates
+          if (template.startsWith('prp')) {
+            if (!content.includes('META')) {
+              this.addWarning(`PRP template ${template} missing META section`);
+            }
+          }
+        } catch (error) {
+          this.addError(`Failed to read template ${template}: ${error.message}`);
+        }
+      }
+    });
+  }
+
+  validateToolConfigs() {
+    console.log(chalk.bold('\n🔧 Validating Tool Configurations...'));
+
+    EXPECTED_STRUCTURE.tools.forEach(tool => {
+      const toolDir = path.join('tools', tool);
+
+      if (!this.checkDirExists(toolDir, `tool ${tool}`)) {
+        return;
+      }
+
+      const config = TOOL_CONFIGS[tool];
+
+      if (config.file) {
+        // Single file configuration
+        this.checkFileExists(
+          path.join(toolDir, config.file),
+          `${tool} config file`
+        );
+      } else if (config.files) {
+        // Multiple files configuration
+        config.files.forEach(file => {
+          const filePath = path.join(toolDir, file);
+          this.checkFileExists(filePath, `${tool} config file`);
+        });
+      }
+
+      // Special validation for Claude Code slash commands
+      if (tool === 'claude-code') {
+        const commandsDir = path.join(FRAMEWORK_ROOT, toolDir, '.claude', 'commands');
+        if (fs.existsSync(commandsDir)) {
+          const commands = fs.readdirSync(commandsDir).filter(f => f.endsWith('.md'));
+          if (commands.length > 0) {
+            this.log(`Found ${commands.length} Claude Code slash commands`, 'success');
+          } else {
+            this.addWarning('No slash commands found for Claude Code');
+          }
+        }
+      }
+    });
+  }
+
+  validateScripts() {
+    console.log(chalk.bold('\n📜 Validating Scripts...'));
+
+    EXPECTED_STRUCTURE.scripts.forEach(script => {
+      const scriptPath = path.join('scripts', script);
+      if (this.checkFileExists(scriptPath, `script ${script}`)) {
+        // Check if script is executable (has shebang)
+        try {
+          const content = fs.readFileSync(
+            path.join(FRAMEWORK_ROOT, scriptPath),
+            'utf-8'
+          );
+
+          if (!content.startsWith('#!/usr/bin/env node')) {
+            this.addWarning(`Script ${script} missing shebang`);
+          }
+        } catch (error) {
+          this.addError(`Failed to read script ${script}: ${error.message}`);
+        }
+      }
+    });
+  }
+
+  validateConstitution() {
+    console.log(chalk.bold('\n📜 Validating Constitution...'));
+
+    const constitutionPath = path.join('shared', 'memory', 'constitution.md');
+
+    if (this.checkFileExists(constitutionPath, 'constitution')) {
+      try {
+        const content = fs.readFileSync(
+          path.join(FRAMEWORK_ROOT, constitutionPath),
+          'utf-8'
+        );
+
+        // Check for 9 articles
+        const articles = content.match(/## Article \d+:/g);
+        if (articles && articles.length === 9) {
+          this.log('Constitution has all 9 articles', 'success');
+        } else {
+          this.addError(
+            `Constitution should have 9 articles, found ${articles ? articles.length : 0}`
+          );
+        }
+
+        // Check for required principles
+        const requiredPrinciples = [
+          'Specification-First',
+          'Test-First',
+          'Simplicity First',
+          'Context-Engineered',
+          'Memory Management',
+          'Modular Agent',
+          'Constitutional Checks',
+          'Security by Design',
+          'Performance as Requirement'
+        ];
+
+        requiredPrinciples.forEach(principle => {
+          if (!content.includes(principle)) {
+            this.addWarning(`Constitution missing principle: ${principle}`);
+          }
+        });
+      } catch (error) {
+        this.addError(`Failed to validate constitution: ${error.message}`);
+      }
+    }
+  }
+
+  validateMCPConfig() {
+    console.log(chalk.bold('\n🔌 Validating MCP Configuration...'));
+
+    const mcpPath = path.join('shared', 'mcp', 'mcp-config.json');
+
+    if (this.checkFileExists(mcpPath, 'MCP config')) {
+      try {
+        const config = require(path.join(FRAMEWORK_ROOT, mcpPath));
+
+        // Check for required MCP tools
+        const requiredTools = [
+          'context7',
+          'brave-search',
+          'mem0',
+          'clear-thought',
+          'archon',
+          'openmemory',
+          'deepwiki'
+        ];
+
+        const configuredTools = Object.keys(config.mcpServers || {});
+
+        requiredTools.forEach(tool => {
+          if (configuredTools.includes(tool)) {
+            this.passed++;
+          } else {
+            this.addWarning(`MCP tool not configured: ${tool}`);
+          }
+        });
+
+        this.log(`MCP configuration valid with ${configuredTools.length} tools`, 'success');
+      } catch (error) {
+        this.addError(`Failed to parse MCP config: ${error.message}`);
+      }
+    }
+  }
+
+  generateReport() {
+    console.log(chalk.bold('\n\n📊 Validation Report\n'));
+    console.log(chalk.bold('━'.repeat(50)));
+
+    // Summary
+    console.log(chalk.bold('\nSummary:'));
+    console.log(`  ${chalk.green('✓')} Passed: ${chalk.bold(this.passed)}`);
+    console.log(`  ${chalk.red('✗')} Failed: ${chalk.bold(this.failed)}`);
+    console.log(`  ${chalk.yellow('⚠')} Warnings: ${chalk.bold(this.warnings.length)}`);
+
+    // Errors
+    if (this.errors.length > 0) {
+      console.log(chalk.bold('\n\nErrors:'));
+      this.errors.forEach((error, i) => {
+        console.log(`  ${i + 1}. ${chalk.red(error)}`);
+      });
+    }
+
+    // Warnings
+    if (this.warnings.length > 0) {
+      console.log(chalk.bold('\n\nWarnings:'));
+      this.warnings.forEach((warning, i) => {
+        console.log(`  ${i + 1}. ${chalk.yellow(warning)}`);
+      });
+    }
+
+    console.log(chalk.bold('\n' + '━'.repeat(50)));
+
+    // Overall status
+    const total = this.passed + this.failed;
+    const percentage = total > 0 ? Math.round((this.passed / total) * 100) : 0;
+
+    console.log(chalk.bold('\nOverall Status:'));
+    if (this.failed === 0) {
+      console.log(chalk.green(`  ✓ All checks passed (${percentage}%)`));
+      console.log(chalk.green('\n  Framework is valid and ready for deployment!\n'));
+    } else if (percentage >= 80) {
+      console.log(chalk.yellow(`  ⚠ Mostly valid (${percentage}%)`));
+      console.log(chalk.yellow(`\n  Framework has ${this.failed} issues that should be addressed.\n`));
+    } else {
+      console.log(chalk.red(`  ✗ Validation failed (${percentage}%)`));
+      console.log(chalk.red(`\n  Framework has ${this.failed} critical issues.\n`));
+    }
+
+    return this.failed === 0;
+  }
+
+  async run() {
+    console.log(chalk.bold.cyan('\n🔍 AgentDevFramework Configuration Validator\n'));
+
+    const spinner = ora('Starting validation...').start();
+
+    try {
+      spinner.text = 'Validating core files...';
+      this.validateCoreFiles();
+
+      spinner.text = 'Validating directory structure...';
+      this.validateDirectoryStructure();
+
+      spinner.text = 'Validating agents...';
+      this.validateAgents();
+
+      spinner.text = 'Validating templates...';
+      this.validateTemplates();
+
+      spinner.text = 'Validating tool configurations...';
+      this.validateToolConfigs();
+
+      spinner.text = 'Validating scripts...';
+      this.validateScripts();
+
+      spinner.text = 'Validating constitution...';
+      this.validateConstitution();
+
+      spinner.text = 'Validating MCP configuration...';
+      this.validateMCPConfig();
+
+      spinner.succeed('Validation complete');
+
+      return this.generateReport();
+    } catch (error) {
+      spinner.fail('Validation failed');
+      console.error(chalk.red(`\nError: ${error.message}`));
+      console.error(error.stack);
+      return false;
+    }
+  }
+}
+
+// Run validation if called directly
+if (require.main === module) {
+  const validator = new FrameworkValidator();
+  validator.run().then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}
+
+module.exports = FrameworkValidator;

package/lib/templates/shared/agents/analyst.md

@@ -535,5 +535,5 @@ Brief ready for PM to create PRD.
 ---
 
 **Agent Version**: 1.0.0
-**Framework**: AgentDevFramework-Claude
+**Framework**: AgentDevFramework
 **Methodology**: BMAD-METHOD + Market Research Best Practices

package/lib/templates/shared/agents/architect.md

@@ -227,27 +227,23 @@ Document all key decisions:
 
 ...
 
-## OpenSpec Brownfield Workflow
+## Path B: OpenSpec Deltas (Iterative)
 
-Use this workflow when modifying existing systems (1 -> n) to maintain a source of truth.
+Use this workflow for iterative changes, focusing on defining technical deltas rather than full architecture docs.
 
 ```
-1. Initialize OpenSpec (if first time)
-   npx openspec init
+1. Analyze Change Proposal
+   - Read `openspec/changes/<feature-name>/proposal.md`
+   - Understand the functional requirements
 
-2. Create Change Proposal
-   - Create directory: openspec/changes/<feature-name>/
-   - Create proposal.md using openspec-proposal.md template
-   - Create tasks.md using openspec-tasks.md template
+2. Create Spec Deltas
+   - Identify which existing specs in `openspec/specs/` are affected
+   - Create `openspec/changes/<feature-name>/specs/delta.md`
+   - Use `## ADDED Requirements`, `## MODIFIED Requirements`, `## REMOVED Requirements`
 
-3. Create Spec Deltas
-   - Identify existing specs in openspec/specs/
-   - Create delta files in openspec/changes/<feature-name>/specs/
-   - Use ## ADDED / ## MODIFIED / ## REMOVED markers
-
-4. Review & Align
-   - Present proposal and deltas to the team/user
-   - Iterate based on feedback until agreed
+3. Define Technical Tasks
+   - Break down the implementation of these deltas
+   - Create `openspec/changes/<feature-name>/tasks.md` (or handoff to SM)
 ```
 
 ## Architecture Patterns
@@ -554,4 +550,4 @@ Ready for SM to create stories.
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: BMAD-METHOD + Software Architecture Best Practices
+**Methodology**: BMAD-METHOD + Software Architecture Best Practices

package/lib/templates/shared/agents/dev.md

@@ -623,7 +623,7 @@ Before marking story complete:
 
 ## Remember
 
-You work from detailed story files with complete context. Your job is **disciplined execution**, not interpretation. When ambiguity exists, ask for clarification rather than assuming intent.  
+You work from detailed story files with complete context. Your job is **disciplined execution**, not interpretation. When ambiguity exists, ask for clarification rather than assuming intent.
 
 **Success Metrics**:
 - Tests pass on first QA review
@@ -636,4 +636,4 @@ You work from detailed story files with complete context. Your job is **discipli
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Last Updated**: 2025-01-XX
+**Last Updated**: 2025-01-XX

package/lib/templates/shared/agents/pm.md

@@ -672,4 +672,4 @@ PRD complete. Ready for architect review.
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: BMAD-METHOD + Agile Best Practices
+**Methodology**: BMAD-METHOD + Agile Best Practices

package/lib/templates/shared/agents/qa.md

@@ -536,5 +536,5 @@ Recommendation: Implement rate limiting and CAPTCHA before beginning development
 ---
 
 **Agent Version**: 1.0.0
-**Framework**: AgentDevFramework-Claude
+**Framework**: AgentDevFramework
 **Methodology**: BMAD-METHOD QA + Risk-Based Testing Best Practices

package/lib/templates/shared/agents/sm.md

@@ -726,7 +726,7 @@ test('complete login flow', async () => {
 - [ ] Risk assessment included
 - [ ] Dependencies identified
 - [ ] Performance requirements defined
-- [ ] Security requirements defined
+- [ ] Security requirements included
 - [ ] Definition of Done complete
 - [ ] Story points estimated
 - [ ] Constitutional compliance verified
@@ -785,4 +785,4 @@ Would you like me to:
 
 **Agent Version**: 1.0.0
 **Framework**: AgentDevFramework
-**Methodology**: BMAD-METHOD + Context Engineering + Agile Best Practices
+**Methodology**: BMAD-METHOD + Context Engineering + Agile Best Practices

package/lib/templates/shared/templates/README.md

@@ -1,6 +1,6 @@
 # Template Library
 
-This directory contains all templates for the AgentDevFramework-Claude, synthesizing best practices from BMAD-METHOD, Spec-Kit, Context Engineering, and PRPs Agentic Engineering.
+This directory contains all templates for the AgentDevFramework, synthesizing best practices from BMAD-METHOD, Spec-Kit, Context Engineering, and PRPs Agentic Engineering.
 
 ## Template Categories
 
@@ -194,6 +194,6 @@ bandit -r src/
 
 ---
 
-**Framework**: AgentDevFramework-Claude
+**Framework**: AgentDevFramework
 **Version**: 1.0.0
 **Last Updated**: 2024-10-01

package/lib/templates/shared/templates/openspec-proposal.md

@@ -6,12 +6,12 @@ Briefly describe WHY this change is needed and what problem it solves.
 ## 📝 Proposed Changes
 High-level summary of the functional changes.
 
-## 🗄️ Technical Approach
+## 🏗️ Technical Approach
 - Architecture decisions
 - Impacted components
 - New dependencies (if any)
 
-## 🚧 Verification Plan
+## 🚦 Verification Plan
 - [ ] Syntax check
 - [ ] Unit tests
 - [ ] Integration tests

package/lib/templates/shared/templates/prd-template.md

@@ -558,6 +558,6 @@ So that [benefit]
 
 ---
 
-**Framework**: AgentDevFramework-Claude
+**Framework**: AgentDevFramework
 **Template Version**: 1.0.0
 **Methodology**: BMAD-METHOD + Product Management Best Practices

package/lib/templates/shared/templates/story-template.md

@@ -1184,7 +1184,7 @@ logger.error('[Feature] operation failed', {
 
 ---
 
-**Framework**: AgentDevFramework-Claude
+**Framework**: AgentDevFramework
 **Template Version**: 1.0.0
 **Methodology**: Story-Driven Development + Context Engineering
 **Workflow**: Implement phase with complete embedded context