@iservu-inc/adf-cli 0.12.12 → 0.14.0

package/lib/utils/context-extractor.js

@@ -0,0 +1,157 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Utility to extract project context from existing markdown files
+ * generated by different frameworks.
+ */
+class ContextExtractor {
+  /**
+   * Finds files matching a pattern recursively.
+   * @param {string} dir - Directory to search.
+   * @param {RegExp} pattern - Regex to match against relative path.
+   * @returns {Promise<string[]>} List of absolute paths.
+   */
+  static async findFiles(dir, pattern) {
+    let results = [];
+    if (!(await fs.pathExists(dir))) {
+      return results;
+    }
+
+    try {
+      const list = await fs.readdir(dir);
+      for (const file of list) {
+        const fullPath = path.resolve(dir, file);
+        const stat = await fs.stat(fullPath);
+        if (stat && stat.isDirectory()) {
+          results = results.concat(await this.findFiles(fullPath, pattern));
+        } else if (pattern.test(file)) {
+          results.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Ignore errors reading directories
+    }
+    return results;
+  }
+
+  /**
+   * Extracts context from existing framework files.
+   * @param {string} projectDir - The project directory.
+   * @param {string[]} frameworks - List of detected frameworks.
+   * @returns {Promise<Object>} Synthesized context object.
+   */
+  static async extract(projectDir, frameworks) {
+    let context = {
+      name: null,
+      version: null,
+      overview: '',
+      techStack: '',
+      architecture: '',
+      proposedChanges: ''
+    };
+
+    if (frameworks.includes('bmad')) {
+      context = await this.extractFromBMAD(projectDir, context);
+    }
+
+    if (frameworks.includes('openspec')) {
+      context = await this.extractFromOpenSpec(projectDir, context);
+    }
+
+    if (frameworks.includes('spec-kit')) {
+      context = await this.extractFromSpecKit(projectDir, context);
+    }
+
+    return context;
+  }
+
+  static async extractFromBMAD(projectDir, context) {
+    const prdDir = path.join(projectDir, 'docs/prd');
+    const prdFiles = await this.findFiles(prdDir, /\.md$/);
+    
+    if (prdFiles.length > 0) {
+      const content = await fs.readFile(prdFiles[0], 'utf-8');
+      
+      const nameMatch = content.match(/\*\*Project\*\*:\s*(.*)/i);
+      if (nameMatch) context.name = nameMatch[1].trim();
+
+      const versionMatch = content.match(/\*\*Version\*\*:\s*(.*)/i);
+      if (versionMatch) context.version = versionMatch[1].trim();
+
+      const summary = this.extractSection(content, 'Executive Summary');
+      if (summary) context.overview += (context.overview ? '\n\n' : '') + summary;
+    }
+    return context;
+  }
+
+  static async extractFromOpenSpec(projectDir, context) {
+    const specsDir = path.join(projectDir, 'specs');
+    const openspecDir = path.join(projectDir, 'openspec');
+    
+    const specFiles = [
+      ...(await this.findFiles(specsDir, /\.md$/)),
+      ...(await this.findFiles(openspecDir, /\.md$/))
+    ];
+
+    for (const file of specFiles) {
+      const content = await fs.readFile(file, 'utf-8');
+      
+      const purpose = this.extractSection(content, 'Purpose');
+      if (purpose) context.overview += (context.overview ? '\n\n' : '') + purpose;
+
+      const changes = this.extractSection(content, 'Proposed Changes');
+      if (changes) context.proposedChanges += (context.proposedChanges ? '\n\n' : '') + changes;
+    }
+    return context;
+  }
+
+  static async extractFromSpecKit(projectDir, context) {
+    const specFile = path.join(projectDir, 'specification.md');
+    if (await fs.pathExists(specFile)) {
+      const content = await fs.readFile(specFile, 'utf-8');
+      
+      const techStack = this.extractSection(content, 'Tech Stack');
+      if (techStack) context.techStack += (context.techStack ? '\n\n' : '') + techStack;
+
+      const architecture = this.extractSection(content, 'Architecture');
+      if (architecture) context.architecture += (context.architecture ? '\n\n' : '') + architecture;
+    }
+    return context;
+  }
+
+  /**
+   * Extracts content under a specific heading.
+   * Supports both # and ## and emojis.
+   */
+  static extractSection(content, headingName) {
+    const lines = content.split(/\r?\n/);
+    let inSection = false;
+    let sectionContent = [];
+
+    // Use a more flexible regex for headings
+    // Matches lines starting with #, followed by optional whitespace/emojis, then the heading name
+    const headingRegex = new RegExp(`^#+\\s+.*${headingName}.*`, 'i');
+
+    for (let line of lines) {
+      const trimmedLine = line.trim();
+      
+      if (headingRegex.test(trimmedLine)) {
+        inSection = true;
+        continue;
+      }
+      
+      if (inSection && trimmedLine.startsWith('#')) {
+        break;
+      }
+      
+      if (inSection) {
+        sectionContent.push(line);
+      }
+    }
+
+    return sectionContent.join('\n').trim();
+  }
+}
+
+module.exports = ContextExtractor;

package/lib/utils/framework-detector.js

@@ -0,0 +1,54 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Utility to detect the presence of different development frameworks
+ * in a project directory.
+ */
+class FrameworkDetector {
+  /**
+   * Detects which frameworks are present in the given project directory.
+   * @param {string} projectDir - The project directory to scan.
+   * @returns {Promise<string[]>} Array of detected framework IDs ('adf', 'bmad', 'openspec', 'spec-kit').
+   */
+  static async detect(projectDir) {
+    const detected = [];
+
+    // 1. Detect .adf
+    if (await fs.pathExists(path.join(projectDir, '.adf'))) {
+      detected.push('adf');
+    }
+
+    // 2. Detect BMAD
+    // Indicators: docs/prd, docs/architecture, stories/
+    if (
+      await fs.pathExists(path.join(projectDir, 'docs/prd')) ||
+      await fs.pathExists(path.join(projectDir, 'docs/architecture')) ||
+      await fs.pathExists(path.join(projectDir, 'stories'))
+    ) {
+      detected.push('bmad');
+    }
+
+    // 3. Detect OpenSpec
+    // Indicators: specs/, openspec/
+    if (
+      await fs.pathExists(path.join(projectDir, 'specs')) ||
+      await fs.pathExists(path.join(projectDir, 'openspec'))
+    ) {
+      detected.push('openspec');
+    }
+
+    // 4. Detect Spec-Kit
+    // Indicators: constitution.md, specification.md
+    if (
+      await fs.pathExists(path.join(projectDir, 'constitution.md')) ||
+      await fs.pathExists(path.join(projectDir, 'specification.md'))
+    ) {
+      detected.push('spec-kit');
+    }
+
+    return detected;
+  }
+}
+
+module.exports = FrameworkDetector;

package/lib/utils/tool-feature-registry.js

@@ -0,0 +1,102 @@
+/**
+ * Tool Feature Registry
+ * Centralized database of supported AI tools and their integration features.
+ */
+class ToolFeatureRegistry {
+  static get REGISTRY() {
+    return {
+      kiro: {
+        name: 'Kiro',
+        status: 'supported',
+        configFiles: ['.kiro/product.md', '.kiro/technical.md'],
+        features: ['Product Context', 'Technical Guidelines', 'TDD Support']
+      },
+      trae: {
+        name: 'Trae',
+        status: 'supported',
+        configFiles: ['.trae/config.json'],
+        features: ['Project Structure', 'Framework Identity']
+      },
+      'codex-cli': {
+        name: 'Codex CLI',
+        status: 'supported',
+        configFiles: ['.codex/config.toml', '.codex/instructions.md'],
+        features: ['TOML Config', 'Custom Instructions']
+      },
+      windsurf: {
+        name: 'Windsurf',
+        status: 'supported',
+        configFiles: ['.windsurfrules', '.windsurf/rules/'],
+        features: ['Legacy Rules', 'Modern Rules', 'Workflows']
+      },
+      cursor: {
+        name: 'Cursor',
+        status: 'supported',
+        configFiles: ['.cursorrules', '.cursor/rules/'],
+        features: ['Context Rules']
+      },
+      vscode: {
+        name: 'VS Code',
+        status: 'supported',
+        configFiles: ['.vscode/settings.json', '.github/copilot-instructions.md'],
+        features: ['Copilot Instructions', 'Custom Chat Modes']
+      },
+      zed: {
+        name: 'Zed Editor',
+        status: 'supported',
+        configFiles: ['.zed/settings.json', '.zed/keymap.json'],
+        features: ['MCP Config', 'Keymaps']
+      },
+      antigravity: {
+        name: 'Antigravity',
+        status: 'supported',
+        configFiles: ['.antigravity/agents.yaml'],
+        features: ['YAML Agents']
+      },
+      'claude-code': {
+        name: 'Claude Code',
+        status: 'supported',
+        configFiles: ['.framework/agents/'],
+        features: ['Direct Agent Access']
+      },
+      opencode: {
+        name: 'OpenCode CLI',
+        status: 'supported',
+        configFiles: ['opencode.json'],
+        features: ['JSON Config']
+      },
+      'gemini-cli': {
+        name: 'Gemini CLI',
+        status: 'supported',
+        configFiles: ['GEMINI.md'],
+        features: ['Markdown Context']
+      },
+      deepagent: {
+        name: 'DeepAgent (Abacus.ai)',
+        status: 'supported',
+        configFiles: ['.deepagent/'],
+        features: ['Full Agent Suite']
+      }
+    };
+  }
+
+  static listTools() {
+    return Object.keys(this.REGISTRY);
+  }
+
+  static getFeatures(toolId) {
+    const tool = this.REGISTRY[toolId];
+    return tool ? { supported: true, ...tool } : { supported: false };
+  }
+
+  static audit() {
+    const tools = this.REGISTRY;
+    return {
+      totalCount: Object.keys(tools).length,
+      timestamp: new Date().toISOString(),
+      tools
+    };
+  }
+}
+
+module.exports = ToolFeatureRegistry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.12.12",
+  "version": "0.14.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {

package/tests/ai-gap-analyzer.test.js

@@ -0,0 +1,38 @@
+const AIGapAnalyzer = require('../lib/analysis/ai-gap-analyzer');
+
+describe('AI Gap Analyzer', () => {
+  let mockAIClient;
+
+  beforeEach(() => {
+    mockAIClient = {
+      sendMessage: jest.fn()
+    };
+  });
+
+  test('should parse gaps from AI response', async () => {
+    const aiResponse = {
+      content: `Here is the analysis of knowledge gaps:
+- [GAP] Authentication flow is mentioned but not defined
+- [GAP] No mention of database schema for users
+- [GAP] API error handling strategy is missing`
+    };
+    mockAIClient.sendMessage.mockResolvedValue(aiResponse);
+
+    const analyzer = new AIGapAnalyzer(mockAIClient);
+    const context = { overview: 'We are building a login system.' };
+    const gaps = await analyzer.analyze(context);
+
+    expect(gaps).toContain('Authentication flow is mentioned but not defined');
+    expect(gaps).toContain('No mention of database schema for users');
+    expect(gaps).toContain('API error handling strategy is missing');
+  });
+
+  test('should handle empty or invalid AI response', async () => {
+    mockAIClient.sendMessage.mockResolvedValue({ content: 'No gaps found.' });
+
+    const analyzer = new AIGapAnalyzer(mockAIClient);
+    const gaps = await analyzer.analyze({ overview: 'Complete' });
+
+    expect(gaps).toEqual([]);
+  });
+});

package/tests/codex-cli-generator.test.js

@@ -0,0 +1,29 @@
+const fs = require('fs-extra');
+const path = require('path');
+const CodexCLIGenerator = require('../lib/generators/codex-cli-generator');
+
+describe('Codex CLI Generator', () => {
+  const tempDir = path.join(__dirname, 'temp-codex-test');
+  const sessionPath = path.join(tempDir, '.adf/sessions/test-session');
+
+  beforeEach(async () => {
+    await fs.ensureDir(path.join(sessionPath, 'outputs'));
+    await fs.writeJson(path.join(sessionPath, '_metadata.json'), { projectName: 'Test Project' });
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should generate config.toml and instructions.md', async () => {
+    const generator = new CodexCLIGenerator(sessionPath, tempDir, 'balanced');
+    await generator.generate();
+
+    expect(await fs.pathExists(path.join(tempDir, '.codex/config.toml'))).toBe(true);
+    expect(await fs.pathExists(path.join(tempDir, '.codex/instructions.md'))).toBe(true);
+    
+    const tomlContent = await fs.readFile(path.join(tempDir, '.codex/config.toml'), 'utf-8');
+    expect(tomlContent).toContain('name = "AgentDevFramework"');
+    expect(tomlContent).toContain('project = "Test Project"');
+  });
+});

package/tests/context-extractor.test.js

@@ -0,0 +1,70 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ContextExtractor = require('../lib/utils/context-extractor');
+
+describe('Context Extractor', () => {
+  const tempDir = path.join(__dirname, 'temp-extractor-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should extract metadata from BMAD PRD', async () => {
+    const prdContent = `# Product Requirements Document (PRD)
+
+**Project**: Test Project
+**Version**: 2.1
+**Date**: 2026-01-12
+
+## Executive Summary
+
+This is a summary of the test project.
+`;
+    await fs.ensureDir(path.join(tempDir, 'docs/prd'));
+    await fs.writeFile(path.join(tempDir, 'docs/prd/prd.md'), prdContent);
+
+    const context = await ContextExtractor.extract(tempDir, ['bmad']);
+    expect(context.name).toBe('Test Project');
+    expect(context.version).toBe('2.1');
+    expect(context.overview).toContain('summary of the test project');
+  });
+
+  test('should extract purpose from OpenSpec proposal', async () => {
+    const proposalContent = `# OpenSpec Change Proposal: New Feature
+
+## 🎯 Purpose
+To solve the problem of missing features.
+
+## 📝 Proposed Changes
+Add many cool features.
+`;
+    await fs.ensureDir(path.join(tempDir, 'specs'));
+    await fs.writeFile(path.join(tempDir, 'specs/proposal.md'), proposalContent);
+
+    const context = await ContextExtractor.extract(tempDir, ['openspec']);
+    expect(context.overview).toContain('solve the problem of missing features');
+    expect(context.proposedChanges).toContain('Add many cool features');
+  });
+
+  test('should extract tech stack and architecture from Spec-Kit', async () => {
+    const specContent = `# Specification: App Core
+
+## Tech Stack
+- Node.js
+- React
+
+## Architecture
+Clean architecture with domain-driven design.
+`;
+    await fs.writeFile(path.join(tempDir, 'specification.md'), specContent);
+
+    const context = await ContextExtractor.extract(tempDir, ['spec-kit']);
+    expect(context.techStack).toContain('Node.js');
+    expect(context.techStack).toContain('React');
+    expect(context.architecture).toContain('Clean architecture');
+  });
+});

package/tests/deploy-integration.test.js

@@ -0,0 +1,36 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { deployToTool } = require('../lib/commands/deploy');
+
+describe('Multi-Tool Deployment (Integration)', () => {
+  const tempDir = path.join(__dirname, 'temp-deploy-integration');
+  const adfDir = path.join(tempDir, '.adf');
+  const sessionPath = path.join(adfDir, 'sessions/2026-01-12_augmentation_v1');
+
+  beforeEach(async () => {
+    await fs.ensureDir(path.join(sessionPath, 'outputs'));
+    // Mock successful session
+    await fs.writeJson(path.join(sessionPath, '_progress.json'), { status: 'completed' });
+    await fs.writeJson(path.join(sessionPath, '_metadata.json'), { framework: 'balanced' });
+    await fs.writeFile(path.join(sessionPath, 'outputs/specification.md'), '## Architecture\nTest');
+    
+    // Change current directory to tempDir for deploy command
+    jest.spyOn(process, 'cwd').mockReturnValue(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+    jest.restoreAllMocks();
+  });
+
+  test('should deploy to Kiro, Trae, and Codex CLI', async () => {
+    // These should work once we update deploy.js
+    await deployToTool('kiro', { silent: true });
+    await deployToTool('trae', { silent: true });
+    await deployToTool('codex-cli', { silent: true });
+
+    expect(await fs.pathExists(path.join(tempDir, '.kiro/product.md'))).toBe(true);
+    expect(await fs.pathExists(path.join(tempDir, '.trae/config.json'))).toBe(true);
+    expect(await fs.pathExists(path.join(tempDir, '.codex/config.toml'))).toBe(true);
+  });
+});

package/tests/deploy.test.js

@@ -0,0 +1,57 @@
+const fs = require('fs-extra');
+const path = require('path');
+const deploy = require('../lib/commands/deploy');
+const { deployToTool } = require('../lib/commands/deploy');
+
+// Mock generators
+jest.mock('../lib/generators', () => ({
+  generateAgentsMd: jest.fn(),
+  generateWindsurf: jest.fn(),
+  generateCursor: jest.fn(),
+  generateVSCode: jest.fn(),
+  generateZed: jest.fn(),
+  generateAntigravity: jest.fn(),
+  generateOpenCode: jest.fn().mockResolvedValue({ config: 'opencode.json' }),
+  generateGeminiCLI: jest.fn(),
+  generateDeepAgent: jest.fn()
+}));
+
+const TEST_DIR = path.join(__dirname, 'test-deploy-opencode');
+const ADF_DIR = path.join(TEST_DIR, '.adf');
+
+describe('Deploy Command - OpenCode', () => {
+  beforeEach(async () => {
+    await fs.remove(TEST_DIR);
+    await fs.ensureDir(TEST_DIR);
+    await fs.ensureDir(ADF_DIR);
+    
+    // Create mock session
+    const sessionDir = path.join(ADF_DIR, 'sessions', 'test-session');
+    await fs.ensureDir(path.join(sessionDir, 'outputs'));
+    await fs.writeFile(path.join(sessionDir, 'outputs', 'prp.md'), 'test content');
+    
+    // Mock process.cwd
+    jest.spyOn(process, 'cwd').mockReturnValue(TEST_DIR);
+    // Mock console.log/error to suppress output
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+    jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(async () => {
+    await fs.remove(TEST_DIR);
+    jest.restoreAllMocks();
+  });
+
+  it('should deploy to opencode with correct filename', async () => {
+    await deployToTool('opencode', { silent: true });
+    
+    // Verify opencode.json was created (by the mock generator, 
+    // but the deploy command also writes a fallback config if generator fails or for simple tools.
+    // In this case, we rely on the generator which we mocked.
+    // However, deploy.js writes a fallback/wrapper config at the end.
+    
+    // The key check here is that it didn't crash and tried to write to opencode.json
+    const configPath = path.join(TEST_DIR, 'opencode.json');
+    expect(await fs.pathExists(configPath)).toBe(true);
+  });
+});

package/tests/dynamic-question-generator.test.js

@@ -0,0 +1,29 @@
+const DynamicQuestionGenerator = require('../lib/analysis/dynamic-question-generator');
+
+describe('Dynamic Question Generator', () => {
+  test('should generate questions from heuristic and AI gaps', () => {
+    const heuristicGaps = {
+      missingFields: ['architecture'],
+      missingQuestions: ['bal-37']
+    };
+    const aiGaps = [
+      'Authentication flow is mentioned but not defined',
+      'API error handling strategy is missing'
+    ];
+
+    const questions = DynamicQuestionGenerator.generate(heuristicGaps, aiGaps);
+
+    // Heuristic questions (existing ones)
+    expect(questions.some(q => q.id === 'bal-37')).toBe(true);
+
+    // Dynamic AI questions (new ones)
+    expect(questions.some(q => q.text.includes('Authentication flow'))).toBe(true);
+    expect(questions.some(q => q.text.includes('API error handling'))).toBe(true);
+    expect(questions.every(q => q.phase === 'augmentation')).toBe(true);
+  });
+
+  test('should handle empty gaps', () => {
+    const questions = DynamicQuestionGenerator.generate({ missingQuestions: [] }, []);
+    expect(questions).toEqual([]);
+  });
+});

package/tests/framework-detector.test.js

@@ -0,0 +1,55 @@
+const fs = require('fs-extra');
+const path = require('path');
+const FrameworkDetector = require('../lib/utils/framework-detector');
+
+describe('Framework Detector', () => {
+  const tempDir = path.join(__dirname, 'temp-detector-test');
+
+  beforeEach(async () => {
+    await fs.ensureDir(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tempDir);
+  });
+
+  test('should detect .adf project', async () => {
+    await fs.ensureDir(path.join(tempDir, '.adf'));
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('adf');
+  });
+
+  test('should detect BMAD project', async () => {
+    await fs.ensureDir(path.join(tempDir, 'docs/prd'));
+    await fs.ensureDir(path.join(tempDir, 'docs/architecture'));
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('bmad');
+  });
+
+  test('should detect OpenSpec project', async () => {
+    await fs.ensureDir(path.join(tempDir, 'specs'));
+    await fs.ensureDir(path.join(tempDir, 'openspec'));
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('openspec');
+  });
+
+  test('should detect Spec-Kit project', async () => {
+    await fs.writeFile(path.join(tempDir, 'constitution.md'), '# Constitution');
+    await fs.writeFile(path.join(tempDir, 'specification.md'), '# Specification');
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('spec-kit');
+  });
+
+  test('should detect multiple frameworks', async () => {
+    await fs.ensureDir(path.join(tempDir, '.adf'));
+    await fs.ensureDir(path.join(tempDir, 'specs'));
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toContain('adf');
+    expect(detected).toContain('openspec');
+  });
+
+  test('should return empty array for no frameworks', async () => {
+    const detected = await FrameworkDetector.detect(tempDir);
+    expect(detected).toEqual([]);
+  });
+});

package/tests/heuristic-gap-analyzer.test.js

@@ -0,0 +1,46 @@
+const FrameworkDetector = require('../lib/utils/framework-detector');
+const HeuristicGapAnalyzer = require('../lib/analysis/heuristic-gap-analyzer');
+
+describe('Heuristic Gap Analyzer', () => {
+  test('should identify missing architecture in balanced framework', () => {
+    const context = {
+      name: 'Test Project',
+      overview: 'Summary',
+      techStack: 'Node.js'
+      // Missing architecture
+    };
+
+    const gaps = HeuristicGapAnalyzer.analyze(context, 'balanced');
+    
+    expect(gaps.missingFields).toContain('architecture');
+    expect(gaps.missingQuestions).toContain('bal-37');
+  });
+
+  test('should identify missing tech stack in rapid framework', () => {
+    const context = {
+      name: 'Test Project',
+      overview: 'Summary'
+      // Missing tech stack
+    };
+
+    const gaps = HeuristicGapAnalyzer.analyze(context, 'rapid');
+    
+    expect(gaps.missingFields).toContain('techStack');
+    expect(gaps.missingQuestions).toContain('prp-8');
+  });
+
+  test('should find no gaps when context is complete', () => {
+    const context = {
+      name: 'Test Project',
+      overview: 'Summary',
+      techStack: 'Node.js',
+      architecture: 'Microservices',
+      proposedChanges: 'Auth'
+    };
+
+    const gaps = HeuristicGapAnalyzer.analyze(context, 'balanced');
+    
+    expect(gaps.missingFields.length).toBe(0);
+    expect(gaps.missingQuestions.length).toBe(0);
+  });
+});