@iservu-inc/adf-cli 0.13.0 → 0.14.1

package/lib/analysis/synthesis-engine.js

@@ -0,0 +1,142 @@
+const fs = require('fs-extra');
+const path = require('path');
+const uuid = require('uuid');
+
+/**
+ * Synthesis Engine
+ * Merges extracted context from multiple frameworks into a unified ADF session.
+ * Handles "Session Chain" versioning.
+ */
+class SynthesisEngine {
+  /**
+   * Merges an array of context objects into a single synthesized context.
+   * @param {Object[]} contexts - Array of context objects from ContextExtractor.
+   * @returns {Object} Synthesized context.
+   */
+  static merge(contexts) {
+    const synthesized = {
+      name: '',
+      version: '',
+      overview: '',
+      techStack: '',
+      architecture: '',
+      proposedChanges: ''
+    };
+
+    for (const ctx of contexts) {
+      if (ctx.name) synthesized.name = ctx.name;
+      if (ctx.version) synthesized.version = ctx.version;
+      
+      if (ctx.overview) {
+        synthesized.overview += (synthesized.overview ? '\n\n' : '') + ctx.overview;
+      }
+      if (ctx.techStack) {
+        synthesized.techStack += (synthesized.techStack ? '\n\n' : '') + ctx.techStack;
+      }
+      if (ctx.architecture) {
+        synthesized.architecture += (synthesized.architecture ? '\n\n' : '') + ctx.architecture;
+      }
+      if (ctx.proposedChanges) {
+        synthesized.proposedChanges += (synthesized.proposedChanges ? '\n\n' : '') + ctx.proposedChanges;
+      }
+    }
+
+    return synthesized;
+  }
+
+  /**
+   * Creates a new augmented session with the synthesized context.
+   * @param {string} projectDir - The project directory.
+   * @param {Object} synthesizedContext - The output of merge().
+   * @param {string} framework - The framework level (rapid, balanced, comprehensive).
+   * @returns {Promise<string>} The path to the new session directory.
+   */
+  static async createAugmentedSession(projectDir, synthesizedContext, framework = 'balanced') {
+    const adfDir = path.join(projectDir, '.adf');
+    const sessionsDir = path.join(adfDir, 'sessions');
+    await fs.ensureDir(sessionsDir);
+
+    // Generate Session ID: YYYY-MM-DD_augmentation_vX
+    const now = new Date();
+    const dateStr = now.toISOString().split('T')[0];
+    const baseId = `${dateStr}_augmentation`;
+    
+    let version = 1;
+    let sessionId = `${baseId}_v${version}`;
+    
+    while (await fs.pathExists(path.join(sessionsDir, sessionId))) {
+      version++;
+      sessionId = `${baseId}_v${version}`;
+    }
+
+    const sessionPath = path.join(sessionsDir, sessionId);
+    await fs.ensureDir(sessionPath);
+
+    // Map synthesized context to question IDs
+    const answers = {};
+    
+    if (synthesizedContext.name) {
+      answers['prp-1'] = {
+        text: synthesizedContext.name,
+        quality: { qualityScore: 80, isComprehensive: true },
+        timestamp: now.toISOString()
+      };
+      // Backward compatibility for old tests
+      answers['project-name'] = answers['prp-1'];
+    }
+
+    if (synthesizedContext.overview) {
+      answers['prp-3'] = {
+        text: synthesizedContext.overview,
+        quality: { qualityScore: 80, isComprehensive: true },
+        timestamp: now.toISOString()
+      };
+      // Backward compatibility for old tests
+      answers['project-overview'] = answers['prp-3'];
+    }
+
+    if (synthesizedContext.techStack) {
+      answers['prp-8'] = {
+        text: synthesizedContext.techStack,
+        quality: { qualityScore: 80, isComprehensive: true },
+        timestamp: now.toISOString()
+      };
+    }
+
+    if (synthesizedContext.architecture) {
+      answers['bal-37'] = {
+        text: synthesizedContext.architecture,
+        quality: { qualityScore: 80, isComprehensive: true },
+        timestamp: now.toISOString()
+      };
+    }
+
+    if (synthesizedContext.proposedChanges) {
+      answers['bal-28'] = {
+        text: synthesizedContext.proposedChanges,
+        quality: { qualityScore: 80, isComprehensive: true },
+        timestamp: now.toISOString()
+      };
+    }
+
+    const progress = {
+      sessionId,
+      framework,
+      status: 'in-progress',
+      startedAt: now.toISOString(),
+      lastUpdated: now.toISOString(),
+      totalBlocks: 0, // Will be set by Interviewer
+      completedBlocks: [],
+      skippedBlocks: [],
+      totalQuestionsAnswered: Object.keys(answers).length,
+      answers,
+      canResume: true
+    };
+
+    await fs.writeJson(path.join(sessionPath, '_progress.json'), progress, { spaces: 2 });
+
+    return sessionPath;
+  }
+}
+
+module.exports = SynthesisEngine;

package/lib/commands/deploy.js

@@ -11,7 +11,10 @@ const {
   generateAntigravity,
   generateOpenCode,
   generateGeminiCLI,
-  generateDeepAgent
+  generateDeepAgent,
+  generateKiro,
+  generateTrae,
+  generateCodexCLI
 } = require('../generators');
 const ContextManager = require('../utils/context-manager');
 
@@ -23,12 +26,15 @@ const TOOLS = {
   'vscode-insider': { name: 'VS Code Insider', configFile: '.vscode-insider/settings.json' },
   zed: { name: 'Zed Editor', configFile: '.zed/settings.json' },
   antigravity: { name: 'Google Antigravity', configFile: '.antigravity/agents.yaml' },
+  kiro: { name: 'Kiro', configFile: '.kiro/' },
+  trae: { name: 'Trae', configFile: '.trae/config.json' },
 
   // CLI Tools
   'claude-code': { name: 'Claude Code', configFile: '.framework/agents/' },
   'opencode': { name: 'OpenCode CLI', configFile: '.opencode.json' },
   'gemini-cli': { name: 'Gemini CLI', configFile: 'GEMINI.md' },
   'deepagent': { name: 'DeepAgent (Abacus.ai)', configFile: '.deepagent/agents/' },
+  'codex-cli': { name: 'Codex CLI', configFile: '.codex/config.toml' },
 
   // Generic
   generic: { name: 'Generic AI Tools', configFile: '.framework/agents/' }
@@ -202,7 +208,7 @@ async function deployToTool(tool, options = {}) {
         generatedFiles = await generateOpenCode(sessionPath, cwd, framework);
         if (!options.silent && !spinner) {
           console.log(chalk.green('✓ Generated OpenCode CLI configurations'));
-          console.log(chalk.gray(`  - .opencode.json (project config, agents, MCP servers)`));
+          console.log(chalk.gray(`  - opencode.json (project config, agents, MCP servers)`));
         }
       } else if (tool === 'gemini-cli') {
         generatedFiles = await generateGeminiCLI(sessionPath, cwd, framework);
@@ -217,6 +223,26 @@ async function deployToTool(tool, options = {}) {
           console.log(chalk.gray(`  - .deepagent/agents/ (agent markdown files)`));
           console.log(chalk.gray(`  - .deepagent/README.md (project overview)`));
         }
+      } else if (tool === 'kiro') {
+        generatedFiles = await generateKiro(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Kiro configurations'));
+          console.log(chalk.gray(`  - .kiro/product.md`));
+          console.log(chalk.gray(`  - .kiro/technical.md`));
+        }
+      } else if (tool === 'trae') {
+        generatedFiles = await generateTrae(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Trae configurations'));
+          console.log(chalk.gray(`  - .trae/config.json`));
+        }
+      } else if (tool === 'codex-cli') {
+        generatedFiles = await generateCodexCLI(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Codex CLI configurations'));
+          console.log(chalk.gray(`  - .codex/config.toml`));
+          console.log(chalk.gray(`  - .codex/instructions.md`));
+        }
       }
     } catch (error) {
       console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate ${TOOLS[tool]?.name || tool} configurations: ${error.message}`));

package/lib/commands/init.js

@@ -7,6 +7,12 @@ const {
   detectProjectType,
   getWorkflowRecommendation
 } = require('../utils/project-detector');
+const FrameworkDetector = require('../utils/framework-detector');
+const ContextExtractor = require('../utils/context-extractor');
+const SynthesisEngine = require('../analysis/synthesis-engine');
+const HeuristicGapAnalyzer = require('../analysis/heuristic-gap-analyzer');
+const AIGapAnalyzer = require('../analysis/ai-gap-analyzer');
+const DynamicQuestionGenerator = require('../analysis/dynamic-question-generator');
 const Interviewer = require('../frameworks/interviewer');
 const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
@@ -24,6 +30,94 @@ async function init(options) {
     loadEnvIntoProcess(envPath);
   }
 
+  // Detect existing frameworks for potential synthesis
+  const detectedFrameworks = await FrameworkDetector.detect(cwd);
+  const hasOtherFrameworks = detectedFrameworks.filter(f => f !== 'adf').length > 0;
+
+  if (hasOtherFrameworks) {
+    console.log(chalk.cyan('📦 Existing Development Frameworks Detected:'));
+    console.log(chalk.gray(`   ${detectedFrameworks.join(', ')}\n`));
+
+    const { action } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'How would you like to proceed?',
+        choices: [
+          {
+            name: 'Synthesize & Augment (Seamless Merge - Recommended)',
+            value: 'synthesize'
+          },
+          {
+            name: 'Start Fresh (Ignore existing frameworks)',
+            value: 'fresh'
+          },
+          new inquirer.Separator(),
+          {
+            name: chalk.gray('← Exit'),
+            value: 'exit'
+          }
+        ]
+      }
+    ]);
+
+    if (action === 'exit') return;
+
+    if (action === 'synthesize') {
+      const spinner = ora('Synthesizing project context...').start();
+      try {
+        const context = await ContextExtractor.extract(cwd, detectedFrameworks);
+        const sessionPath = await SynthesisEngine.createAugmentedSession(cwd, context, 'balanced');
+        spinner.succeed(chalk.green(`✓ Project synthesized into new session: ${path.basename(sessionPath)}`));
+        
+        console.log(chalk.yellow('\n💡 Starting Adaptive Augmentation Interview to fill knowledge gaps...\n'));
+        
+        // Load AI config for the interviewer
+        const aiConfig = await configureAIProvider(cwd);
+        const sessionProgress = await fs.readJson(path.join(sessionPath, '_progress.json'));
+
+        // Perform Knowledge Gap Analysis
+        console.log(chalk.cyan('🔍 Analyzing for knowledge gaps...'));
+        const hGaps = HeuristicGapAnalyzer.analyze(context, 'balanced');
+        
+        let aiGaps = [];
+        if (aiConfig) {
+          const AIClient = require('../ai/ai-client');
+          const aiClient = new AIClient(aiConfig);
+          const aiAnalyzer = new AIGapAnalyzer(aiClient);
+          aiGaps = await aiAnalyzer.analyze(context);
+        }
+
+        const dynamicQuestions = DynamicQuestionGenerator.generate(hGaps, aiGaps);
+
+        if (dynamicQuestions.length === 0) {
+          console.log(chalk.green('✓ Context is comprehensive. No additional questions needed.'));
+          const interviewer = new Interviewer('balanced', cwd, {
+            sessionId: path.basename(sessionPath),
+            sessionPath,
+            progress: sessionProgress
+          }, aiConfig);
+          await interviewer.generateOutputs();
+          return;
+        }
+
+        console.log(chalk.yellow(`\n💡 Identified ${dynamicQuestions.length} gaps. Starting targeted interview...\n`));
+        
+        const interviewer = new Interviewer('balanced', cwd, {
+          sessionId: path.basename(sessionPath),
+          sessionPath,
+          progress: sessionProgress
+        }, aiConfig, dynamicQuestions);
+        
+        await interviewer.start();
+        return;
+      } catch (error) {
+        spinner.fail(chalk.red(`Synthesis failed: ${error.message}`));
+        console.log(chalk.yellow('Falling back to standard initialization...\n'));
+      }
+    }
+  }
+
   // Check for resumable sessions FIRST (before asking to overwrite)
   const sessionManager = new SessionManager(cwd);
   const existingSession = await sessionManager.promptToResume();

package/lib/commands/tools.js

@@ -0,0 +1,38 @@
+const chalk = require('chalk');
+const ToolFeatureRegistry = require('../utils/tool-feature-registry');
+
+/**
+ * Tools Audit Command
+ * Displays a report of supported tools and their features.
+ */
+async function audit() {
+  const report = ToolFeatureRegistry.audit();
+
+  console.log(chalk.cyan.bold('\n🛠️  ADF Tool Support Audit\n'));
+  console.log(chalk.gray(`Total Tools: ${report.totalCount}`));
+  console.log(chalk.gray(`Timestamp:   ${new Date(report.timestamp).toLocaleString()}\n`));
+
+  console.log(chalk.white.bold('ID'.padEnd(15)) + chalk.white.bold('Name'.padEnd(20)) + chalk.white.bold('Status'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  for (const [id, tool] of Object.entries(report.tools)) {
+    let statusColor = chalk.green;
+    if (tool.status === 'partial') statusColor = chalk.yellow;
+    if (tool.status === 'deprecated') statusColor = chalk.red;
+
+    console.log(
+      chalk.cyan(id.padEnd(15)) + 
+      chalk.white(tool.name.padEnd(20)) + 
+      statusColor(tool.status)
+    );
+    
+    if (tool.features && tool.features.length > 0) {
+      console.log(chalk.gray(`   Features: ${tool.features.join(', ')}`));
+    }
+    console.log('');
+  }
+
+  console.log(chalk.yellow('💡 Use "adf deploy <tool>" to configure any of these targets.\n'));
+}
+
+module.exports = audit;

package/lib/frameworks/interviewer.js

@@ -21,10 +21,11 @@ const DynamicPipeline = require('../analysis/dynamic-pipeline');
  */
 
 class Interviewer {
-  constructor(framework, projectPath, existingSession = null, aiConfig = null) {
+  constructor(framework, projectPath, existingSession = null, aiConfig = null, customQuestions = null) {
     this.framework = framework;
     this.projectPath = projectPath;
     this.aiConfig = aiConfig;  // Store AI configuration
+    this.customQuestions = customQuestions; // Dynamic questions for augmentation
 
     if (existingSession) {
       // Resuming existing session
@@ -293,8 +294,8 @@ class Interviewer {
       projectContext = { type: 'unknown', frameworks: [], languages: [], confidence: 0 };
     }
 
-    // Get questions for framework
-    let questions = getQuestionsForFramework(this.framework);
+    // Get questions for framework (or use custom ones if provided)
+    let questions = this.customQuestions || getQuestionsForFramework(this.framework);
 
     // Apply smart filtering if enabled
     let filteringResult = null;

package/lib/generators/codex-cli-generator.js

@@ -0,0 +1,41 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+const path = require('path');
+const fs = require('fs-extra');
+
+/**
+ * Generator for Codex CLI
+ */
+class CodexCLIGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+    await this.ensureDir('.codex');
+
+    const projectContext = await this.getProjectContext();
+
+    const config = `# Codex CLI Configuration
+# AgentDevFramework
+
+[framework]
+name = "AgentDevFramework"
+version = "1.0.0"
+project = "${projectContext.name}"
+
+[project_structure]
+framework = ".adf/"
+docs = "docs/"
+specs = "specs/"
+`;
+
+    await this.writeToProject('.codex/config.toml', config);
+
+    const instructions = `# Codex Instructions - ${projectContext.name}
+Follow AgentDevFramework standards for all development.
+Always prioritize TDD and high code coverage.
+`;
+    await this.writeToProject('.codex/instructions.md', instructions);
+
+    return { config: '.codex/config.toml' };
+  }
+}
+
+module.exports = CodexCLIGenerator;

package/lib/generators/index.js

@@ -12,6 +12,9 @@ const AntigravityGenerator = require('./antigravity-generator');
 const OpenCodeGenerator = require('./opencode-generator');
 const GeminiCLIGenerator = require('./gemini-cli-generator');
 const DeepAgentGenerator = require('./deepagent-generator');
+const KiroGenerator = require('./kiro-generator');
+const TraeGenerator = require('./trae-generator');
+const CodexCLIGenerator = require('./codex-cli-generator');
 const ToolConfigGenerator = require('./tool-config-generator');
 
 /**
@@ -129,6 +132,30 @@ async function generateDeepAgent(sessionPath, projectPath, framework) {
   return await generator.generate();
 }
 
+/**
+ * Generate Kiro configurations
+ */
+async function generateKiro(sessionPath, projectPath, framework) {
+  const generator = new KiroGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Trae configurations
+ */
+async function generateTrae(sessionPath, projectPath, framework) {
+  const generator = new TraeGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Codex CLI configurations
+ */
+async function generateCodexCLI(sessionPath, projectPath, framework) {
+  const generator = new CodexCLIGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
 module.exports = {
   generateAll,
   generateAgentsMd,
@@ -140,6 +167,9 @@ module.exports = {
   generateOpenCode,
   generateGeminiCLI,
   generateDeepAgent,
+  generateKiro,
+  generateTrae,
+  generateCodexCLI,
   AgentsMdGenerator,
   WindsurfGenerator,
   CursorGenerator,
@@ -149,5 +179,8 @@ module.exports = {
   OpenCodeGenerator,
   GeminiCLIGenerator,
   DeepAgentGenerator,
+  KiroGenerator,
+  TraeGenerator,
+  CodexCLIGenerator,
   ToolConfigGenerator
 };

package/lib/generators/kiro-generator.js

@@ -0,0 +1,49 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+const path = require('path');
+const fs = require('fs-extra');
+
+/**
+ * Generator for Kiro (AI Code Editor)
+ */
+class KiroGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+    await this.ensureDir('.kiro');
+
+    const projectContext = await this.getProjectContext();
+    const frameworkContext = await this.getFrameworkContext();
+
+    // Generate product.md
+    const productContent = `# Kiro Product Configuration - ${projectContext.name}
+
+## Project Overview
+${projectContext.overview || 'AI-assisted development project.'}
+
+## Key Requirements
+${frameworkContext.keyPoints || 'Follow ADF standards.'}
+
+## Session Context
+- Framework: ${this.framework}
+- Session ID: ${this.getSessionId()}
+`;
+    await this.writeToProject('.kiro/product.md', productContent);
+
+    // Generate technical.md
+    const technicalContent = `# Kiro Technical Configuration - ${projectContext.name}
+
+## Tech Stack
+- Build: ${projectContext.buildCommand}
+- Test: ${projectContext.testCommand}
+- Lint: ${projectContext.lintCommand}
+
+## Structure
+- Source: ${projectContext.sourceDir}
+- Tests: ${projectContext.testDir}
+`;
+    await this.writeToProject('.kiro/technical.md', technicalContent);
+
+    return { config: '.kiro/' };
+  }
+}
+
+module.exports = KiroGenerator;