@iservu-inc/adf-cli 0.17.1 → 0.18.0

package/lib/analysis/knowledge-graph.js

@@ -216,6 +216,72 @@ class KnowledgeGraph {
     };
   }
 
+  /**
+   * Export high-confidence items for handoff package (compact format)
+   */
+  toHandoffFormat(minConfidence = 70, maxContentLength = 200) {
+    const highConfidenceItems = [];
+    const typesSeen = [];
+
+    for (const [type, items] of this.knowledge.entries()) {
+      typesSeen.push(type);
+      for (const item of items) {
+        if (item.confidence >= minConfidence) {
+          highConfidenceItems.push({
+            type,
+            content: item.content.length > maxContentLength
+              ? item.content.slice(0, maxContentLength) + '...'
+              : item.content,
+            confidence: item.confidence,
+            sources: item.sources
+          });
+        }
+      }
+    }
+
+    return {
+      highConfidenceItems,
+      totalItems: this.getStats().totalItems,
+      typesSeen
+    };
+  }
+
+  /**
+   * Restore knowledge from handoff format
+   */
+  fromHandoffFormat(data) {
+    if (!data || !data.highConfidenceItems) return;
+
+    for (const item of data.highConfidenceItems) {
+      this.add([{
+        type: item.type,
+        content: item.content,
+        confidence: item.confidence,
+        source: item.sources ? item.sources[0] : 'handoff'
+      }]);
+    }
+  }
+
+  /**
+   * Get high-confidence snapshot (items at confidence >= 80)
+   */
+  getHighConfidenceSnapshot() {
+    const snapshot = {};
+
+    for (const [type, items] of this.knowledge.entries()) {
+      const highConf = items.filter(i => i.confidence >= 80);
+      if (highConf.length > 0) {
+        snapshot[type] = highConf.map(i => ({
+          content: i.content,
+          confidence: i.confidence,
+          sources: i.sources
+        }));
+      }
+    }
+
+    return snapshot;
+  }
+
   /**
    * Clear all knowledge
    */

package/lib/commands/deploy.js

@@ -2,6 +2,8 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
+const ToolDetector = require('../utils/tool-detector');
+const ToolRecommender = require('../utils/tool-recommender');
 const {
   generateAgentsMd,
   generateWindsurf,
@@ -334,6 +336,39 @@ function getAgentsForWorkflow(workflow) {
 }
 
 async function deploy(tool, options) {
+  // Show tool recommendations
+  if (options.recommend) {
+    const cwd = process.cwd();
+
+    const spinner = ora('Analyzing project and detecting tools...').start();
+    let installedTools;
+    try {
+      installedTools = await ToolDetector.detectAll(cwd);
+      spinner.succeed('Analysis complete');
+    } catch {
+      installedTools = new Map();
+      spinner.warn('Could not detect tools');
+    }
+
+    // Determine workflow from latest session if available
+    let workflow = 'balanced';
+    const sessionPath = await findLatestSession(cwd);
+    if (sessionPath) {
+      workflow = await getFrameworkFromSession(sessionPath);
+    }
+
+    const recommender = new ToolRecommender({
+      workflow,
+      projectType: 'existing',
+      workflowContext: {},
+      installedTools
+    });
+
+    const recommendation = recommender.recommend();
+    console.log(ToolRecommender.formatForDisplay(recommendation));
+    return;
+  }
+
   // List tools
   if (options.list) {
     console.log(chalk.cyan.bold('\n📋 Available Deployment Tools:\n'));

package/lib/commands/harness.js

@@ -0,0 +1,345 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const RunManager = require('../harness/run-manager');
+const ContextWindowManager = require('../harness/context-window-manager');
+const MilestoneTracker = require('../harness/milestone-tracker');
+const FeatureManifestManager = require('../harness/feature-manifest');
+const EventLogger = require('../harness/event-logger');
+const ProviderBridge = require('../harness/provider-bridge');
+const HeadlessAdapter = require('../harness/headless-adapter');
+const { getEnvFilePath, loadEnvIntoProcess, configureAIProvider } = require('../ai/ai-config');
+
+/**
+ * Harness command handlers
+ *
+ * Manages long-running AI agent sessions across context windows.
+ * Commands: start, resume, status, handoff, events, manifest
+ */
+
+async function harnessStart(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Harness Engineering Protocol\n'));
+
+  // Load env
+  const envPath = getEnvFilePath(cwd);
+  if (await fs.pathExists(envPath)) {
+    loadEnvIntoProcess(envPath);
+  }
+
+  const manager = new RunManager(cwd);
+
+  // Check for existing active run
+  const existingRun = await manager.getCurrentRun();
+  if (existingRun && existingRun.status === 'running') {
+    console.log(chalk.yellow(`Active run found: ${existingRun.id}`));
+    console.log(chalk.yellow(`Status: ${existingRun.status} | Workflow: ${existingRun.workflow}\n`));
+    console.log(chalk.gray('Use "adf harness resume" to continue or "adf harness status" for details.\n'));
+    return;
+  }
+
+  // Determine workflow
+  const workflow = options.workflow || 'balanced';
+  const mode = options.headless ? 'headless' : 'interactive';
+
+  // Configure AI provider
+  let aiConfig = null;
+  if (!options.headless) {
+    aiConfig = await configureAIProvider(cwd);
+  }
+
+  // Create run
+  const run = await manager.createRun({
+    workflow,
+    mode,
+    spec: {
+      goals: options.goals ? options.goals.split(',') : [],
+      nonGoals: [],
+      constraints: [],
+      doneWhen: []
+    },
+    provider: aiConfig ? {
+      id: aiConfig.provider,
+      model: aiConfig.model,
+      contextWindowSize: null
+    } : { id: null, model: null, contextWindowSize: null }
+  });
+
+  await manager.startRun(run.id);
+
+  console.log(chalk.green(`\n✓ Harness run created: ${run.id}`));
+  console.log(chalk.gray(`  Workflow: ${workflow}`));
+  console.log(chalk.gray(`  Mode: ${mode}`));
+
+  // Open first context window
+  const cwManager = new ContextWindowManager(manager.getRunDir(run.id), run.id);
+  const window = await cwManager.openWindow();
+
+  console.log(chalk.gray(`  Context Window: ${window.id} (sequence ${window.sequence})`));
+  console.log(chalk.cyan(`\nRun "adf init --harness --run-id ${run.id}" to start the interview.\n`));
+}
+
+async function harnessResume(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Resume Harness Run\n'));
+
+  const manager = new RunManager(cwd);
+
+  const runId = options.runId;
+  let run;
+
+  if (runId) {
+    run = await manager.loadRun(runId);
+  } else {
+    run = await manager.getCurrentRun();
+  }
+
+  if (!run) {
+    console.log(chalk.yellow('No harness run found to resume.\n'));
+    return;
+  }
+
+  if (run.status !== 'paused') {
+    console.log(chalk.yellow(`Run ${run.id} is not paused (status: ${run.status}).\n`));
+    return;
+  }
+
+  // Resume the run
+  await manager.resumeRun(run.id);
+
+  // Open new context window and consume handoff
+  const cwManager = new ContextWindowManager(manager.getRunDir(run.id), run.id);
+  const window = await cwManager.openWindow();
+  const handoff = await cwManager.consumeHandoffPackage('latest');
+
+  console.log(chalk.green(`✓ Run resumed: ${run.id}`));
+  console.log(chalk.gray(`  Context Window: ${window.id} (sequence ${window.sequence})`));
+
+  if (handoff) {
+    console.log(chalk.cyan(`\n📋 Handoff Summary:`));
+    console.log(chalk.gray(`  ${handoff.progressSummary || 'No summary'}`));
+    console.log(chalk.gray(`  Completed: ${handoff.completedWork.length} items`));
+    console.log(chalk.gray(`  Answered: ${handoff.position.answeredIds.length} questions`));
+    console.log(chalk.gray(`  Remaining: ${handoff.position.remainingIds.length} questions`));
+    console.log(chalk.gray(`  Knowledge: ${handoff.knowledgeGraph.totalItems} items`));
+  }
+
+  console.log(chalk.cyan(`\nRun "adf init --harness --run-id ${run.id}" to continue the interview.\n`));
+}
+
+async function harnessStatus(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Harness Status\n'));
+
+  const manager = new RunManager(cwd);
+
+  if (options.all) {
+    const runs = await manager.listRuns();
+    if (runs.length === 0) {
+      console.log(chalk.gray('No harness runs found.\n'));
+      return;
+    }
+
+    console.log(chalk.white(`Found ${runs.length} run(s):\n`));
+    for (const run of runs) {
+      const statusIcon = {
+        initializing: '🟡',
+        running: '🟢',
+        paused: '🟠',
+        completed: '✅',
+        failed: '❌'
+      }[run.status] || '⚪';
+
+      console.log(`  ${statusIcon} ${run.id}`);
+      console.log(chalk.gray(`     Status: ${run.status} | Workflow: ${run.workflow} | Mode: ${run.mode}`));
+      console.log(chalk.gray(`     Created: ${new Date(run.createdAt).toLocaleString()}`));
+      console.log('');
+    }
+    return;
+  }
+
+  // Show current run
+  const run = await manager.getCurrentRun();
+  if (!run) {
+    console.log(chalk.gray('No active harness run.\n'));
+    console.log(chalk.gray('Use "adf harness start" to create one.\n'));
+    return;
+  }
+
+  console.log(chalk.white(`Run: ${run.id}`));
+  console.log(chalk.gray(`Status: ${run.status}`));
+  console.log(chalk.gray(`Workflow: ${run.workflow}`));
+  console.log(chalk.gray(`Mode: ${run.mode}`));
+  console.log(chalk.gray(`Provider: ${run.provider.id || 'not set'} / ${run.provider.model || 'not set'}`));
+  console.log(chalk.gray(`Session: ${run.sessionId || 'not linked'}`));
+  console.log(chalk.gray(`Context Windows: ${run.contextWindows.length}`));
+  console.log(chalk.gray(`Created: ${new Date(run.createdAt).toLocaleString()}`));
+  console.log(chalk.gray(`Updated: ${new Date(run.updatedAt).toLocaleString()}\n`));
+
+  // Show milestone progress if available
+  const milestoneTracker = new MilestoneTracker(manager.getRunDir(run.id));
+  if (await milestoneTracker.load()) {
+    const progress = milestoneTracker.getProgress();
+    console.log(chalk.cyan('Milestones:'));
+    console.log(chalk.gray(`  Total: ${progress.total} | Completed: ${progress.completed} | Skipped: ${progress.skipped}`));
+    console.log(chalk.gray(`  Progress: ${progress.percentage}%\n`));
+  }
+
+  // Show feature manifest progress if available
+  const manifestManager = new FeatureManifestManager(manager.getRunDir(run.id));
+  if (await manifestManager.load()) {
+    const progress = manifestManager.getProgress();
+    console.log(chalk.cyan('Features:'));
+    console.log(chalk.gray(`  Total: ${progress.total} | Passed: ${progress.passed} | Remaining: ${progress.remaining}`));
+    console.log(chalk.gray(`  Progress: ${progress.percentage}%\n`));
+  }
+}
+
+async function harnessHandoff(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Generate Handoff Package\n'));
+
+  const manager = new RunManager(cwd);
+  const run = await manager.getCurrentRun();
+
+  if (!run) {
+    console.log(chalk.yellow('No active harness run.\n'));
+    return;
+  }
+
+  const cwManager = new ContextWindowManager(manager.getRunDir(run.id), run.id);
+
+  if (options.consume) {
+    // Consume latest handoff
+    const handoff = await cwManager.consumeHandoffPackage('latest');
+    if (!handoff) {
+      console.log(chalk.yellow('No handoff package found.\n'));
+      return;
+    }
+
+    console.log(chalk.green('✓ Handoff package consumed:'));
+    console.log(chalk.gray(JSON.stringify(handoff.toJSON(), null, 2)));
+    return;
+  }
+
+  // Generate handoff from current state
+  // Load progress from linked session
+  const progressSummary = `Run ${run.id} - ${run.workflow} workflow`;
+
+  const handoff = await cwManager.generateHandoffPackage({
+    progressSummary,
+    completedWork: [],
+    nextSteps: [],
+    currentMilestone: { index: run.currentMilestoneIndex, title: '', percentage: 0 }
+  });
+
+  // Pause the run
+  await manager.pauseRun(run.id);
+  await cwManager.closeWindow('completed');
+
+  console.log(chalk.green(`✓ Handoff package generated`));
+  console.log(chalk.gray(`  Source window: ${handoff.sourceWindowId}`));
+  console.log(chalk.gray(`  Run paused. Resume with: adf harness resume\n`));
+}
+
+async function harnessEvents(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Harness Events\n'));
+
+  const manager = new RunManager(cwd);
+  const run = await manager.getCurrentRun();
+
+  if (!run) {
+    console.log(chalk.yellow('No active harness run.\n'));
+    return;
+  }
+
+  const logger = manager.getEventLogger(run.id);
+
+  if (options.stats) {
+    const stats = await logger.getStats();
+    console.log(chalk.white(`Total events: ${stats.total}\n`));
+    for (const [type, count] of Object.entries(stats.byType)) {
+      console.log(chalk.gray(`  ${type}: ${count}`));
+    }
+    console.log('');
+    return;
+  }
+
+  const count = parseInt(options.tail) || 20;
+  const events = await logger.tail(count);
+
+  if (events.length === 0) {
+    console.log(chalk.gray('No events recorded.\n'));
+    return;
+  }
+
+  console.log(chalk.white(`Last ${events.length} events:\n`));
+  for (const event of events) {
+    const time = new Date(event.timestamp).toLocaleTimeString();
+    const typeColor = {
+      answer: chalk.green,
+      skip: chalk.yellow,
+      error: chalk.red,
+      handoff: chalk.cyan,
+      checkpoint: chalk.gray,
+      window_open: chalk.blue,
+      window_close: chalk.blue
+    }[event.type] || chalk.white;
+
+    console.log(`  ${chalk.gray(time)} ${typeColor(event.type.padEnd(18))} ${chalk.gray(JSON.stringify(event.data).slice(0, 80))}`);
+  }
+  console.log('');
+}
+
+async function harnessManifest(options) {
+  const cwd = process.cwd();
+
+  console.log(chalk.cyan.bold('\n🔗 Feature Manifest\n'));
+
+  const manager = new RunManager(cwd);
+  const run = await manager.getCurrentRun();
+
+  if (!run) {
+    console.log(chalk.yellow('No active harness run.\n'));
+    return;
+  }
+
+  const manifestManager = new FeatureManifestManager(manager.getRunDir(run.id));
+
+  if (!await manifestManager.load()) {
+    console.log(chalk.gray('No feature manifest generated yet.\n'));
+    console.log(chalk.gray('Complete an interview session to generate features.\n'));
+    return;
+  }
+
+  const manifest = manifestManager.getManifest();
+  const progress = manifestManager.getProgress();
+
+  console.log(chalk.white(`Features: ${progress.total} total | ${progress.passed} passed | ${progress.remaining} remaining`));
+  console.log(chalk.white(`Progress: ${progress.percentage}%\n`));
+
+  for (const feature of manifest.features) {
+    const icon = feature.passes ? chalk.green('✓') : chalk.gray('○');
+    console.log(`  ${icon} ${feature.title}`);
+    if (feature.description) {
+      console.log(chalk.gray(`    ${feature.description.slice(0, 80)}`));
+    }
+  }
+  console.log('');
+}
+
+module.exports = {
+  harnessStart,
+  harnessResume,
+  harnessStatus,
+  harnessHandoff,
+  harnessEvents,
+  harnessManifest
+};

package/lib/commands/init.js

@@ -9,6 +9,9 @@ const {
 } = require('../utils/project-detector');
 const FrameworkDetector = require('../utils/framework-detector');
 const ContextExtractor = require('../utils/context-extractor');
+const ToolDetector = require('../utils/tool-detector');
+const ToolRecommender = require('../utils/tool-recommender');
+const ToolFeatureRegistry = require('../utils/tool-feature-registry');
 const SynthesisEngine = require('../analysis/synthesis-engine');
 const HeuristicGapAnalyzer = require('../analysis/heuristic-gap-analyzer');
 const AIGapAnalyzer = require('../analysis/ai-gap-analyzer');
@@ -38,7 +41,8 @@ async function init(options) {
     const frameworkNames = {
       'agent-native': 'Agent-Native',
       'openspec': 'OpenSpec',
-      'specification-driven': 'Specification-Driven'
+      'specification-driven': 'Specification-Driven',
+      'gemini-conductor': 'Gemini CLI Conductor'
     };
 
     const displayNames = detectedFrameworks
@@ -371,6 +375,7 @@ async function init(options) {
 
   // Determine workflow/framework
   let workflow;
+  let workflowContext = {};
 
   if (options.rapid) {
     workflow = 'rapid';
@@ -382,8 +387,14 @@ async function init(options) {
     workflow = 'comprehensive';
     console.log(chalk.blue('\nUsing: Level 3: Comprehensive (Agent-Native) - from --comprehensive flag'));
   } else {
-    // Interactive workflow selection
-    workflow = await getWorkflowRecommendation(projectType);
+    // Interactive workflow selection (returns { workflow, context } or plain string for backward compat)
+    const workflowResult = await getWorkflowRecommendation(projectType);
+    if (typeof workflowResult === 'string') {
+      workflow = workflowResult;
+    } else {
+      workflow = workflowResult.workflow;
+      workflowContext = workflowResult.context || {};
+    }
   }
 
   // Create .adf directory
@@ -392,6 +403,74 @@ async function init(options) {
   // AI already configured above - pass to interviewer
   // Start interview
   const interviewer = new Interviewer(workflow, cwd, null, aiConfig);
+
+  // Harness integration (opt-in via --harness flag)
+  if (options.harness) {
+    const RunManager = require('../harness/run-manager');
+    const ContextWindowManager = require('../harness/context-window-manager');
+    const MilestoneTracker = require('../harness/milestone-tracker');
+    const EventLogger = require('../harness/event-logger');
+
+    const runManager = new RunManager(cwd);
+    let run;
+
+    if (options.runId) {
+      // Resume existing harness run
+      run = await runManager.loadRun(options.runId);
+      if (!run) {
+        console.log(chalk.red(`Harness run not found: ${options.runId}\n`));
+        return;
+      }
+    } else {
+      // Create new harness run
+      run = await runManager.createRun({
+        workflow,
+        mode: options.headless ? 'headless' : 'interactive',
+        provider: aiConfig ? {
+          id: aiConfig.provider,
+          model: aiConfig.model,
+          contextWindowSize: null
+        } : { id: null, model: null, contextWindowSize: null }
+      });
+      await runManager.startRun(run.id);
+    }
+
+    const runDir = runManager.getRunDir(run.id);
+    const cwManager = new ContextWindowManager(runDir, run.id);
+    const eventLogger = EventLogger.forRun(runDir);
+    const milestoneTracker = new MilestoneTracker(runDir);
+
+    // Open context window if not already active
+    let currentWindow = cwManager.getCurrentWindow();
+    if (!currentWindow) {
+      currentWindow = await cwManager.openWindow();
+    }
+
+    // Consume handoff if resuming
+    if (options.runId && run.status === 'running') {
+      const handoff = await cwManager.consumeHandoffPackage('latest');
+      if (handoff) {
+        interviewer.consumeHandoff(handoff);
+        console.log(chalk.green(`✓ Handoff consumed from window ${handoff.sourceWindowId}\n`));
+      }
+    }
+
+    // Link session to run
+    run.sessionId = interviewer.sessionId;
+    await runManager.saveRun(run);
+
+    // Set harness on interviewer
+    interviewer.setHarness({
+      run,
+      runManager,
+      contextWindowManager: cwManager,
+      eventLogger,
+      milestoneTracker
+    });
+
+    console.log(chalk.cyan(`🔗 Harness: ${run.id} | Window: ${currentWindow.id}\n`));
+  }
+
   const sessionPath = await interviewer.start();
 
   // Show completion message
@@ -423,18 +502,64 @@ async function init(options) {
     ]);
 
     if (deployNow) {
+      // Detect installed tools and generate recommendations
+      const detectSpinner = ora('Detecting installed tools...').start();
+      let installedTools;
+      try {
+        installedTools = await ToolDetector.detectAll(cwd);
+        const installedCount = [...installedTools.values()].filter(t => t.installed).length;
+        detectSpinner.succeed(`Detected ${installedCount} installed tool(s)`);
+      } catch {
+        installedTools = new Map();
+        detectSpinner.warn('Could not detect tools, showing all options');
+      }
+
+      const recommender = new ToolRecommender({
+        workflow,
+        projectType: projectType.type,
+        workflowContext,
+        installedTools
+      });
+      const recommendation = recommender.recommend();
+
+      // Display formatted recommendations
+      console.log(ToolRecommender.formatForDisplay(recommendation));
+
+      // Build pre-selected set from primary + complementary
+      const preSelected = new Set();
+      if (recommendation.primary) preSelected.add(recommendation.primary.toolId);
+      for (const c of recommendation.complementary) preSelected.add(c.toolId);
+
+      // Build choices for all deployable tools (exclude a2a protocol)
+      const allToolIds = Object.keys(ToolFeatureRegistry.REGISTRY).filter(id => {
+        const cfg = ToolFeatureRegistry.getDetectionConfig(id);
+        return cfg && cfg.category !== 'protocol';
+      });
+
+      const choices = allToolIds.map(id => {
+        const reg = ToolFeatureRegistry.REGISTRY[id];
+        const scored = recommendation.ranked.find(r => r.toolId === id);
+        const installStatus = installedTools.get(id);
+        const installed = installStatus && installStatus.installed;
+
+        let label = reg.name;
+        if (scored) label += chalk.gray(` (${scored.totalScore}pts)`);
+        if (installed) label += chalk.green(' *');
+        if (preSelected.has(id)) label += chalk.yellow(' (recommended)');
+
+        return {
+          name: label,
+          value: id,
+          checked: preSelected.has(id)
+        };
+      });
+
       const { tools } = await inquirer.prompt([
         {
           type: 'checkbox',
           name: 'tools',
           message: 'Select tools (space to select, enter to confirm):',
-          choices: [
-            { name: 'Windsurf', value: 'windsurf' },
-            { name: 'Cursor', value: 'cursor' },
-            { name: 'VSCode/Copilot', value: 'vscode' },
-            { name: 'Claude Code', value: 'claude-code' },
-            { name: 'Gemini CLI', value: 'gemini-cli' }
-          ],
+          choices,
           validate: (answer) => {
             if (answer.length === 0) {
               return 'You must choose at least one tool.';