@iservu-inc/adf-cli 0.14.2 → 0.14.3

package/README.md

@@ -41,13 +41,13 @@ The interactive init process will:
 Skip interactive questions and specify workflow directly:
 
 ```bash
-# Level 1: Rapid Development (PRP)
+# Level 1: Rapid (Agent-Native)
 adf init --rapid
 
-# Level 2: Specification-Driven (Balanced)
+# Level 2: Balanced (OpenSpec)
 adf init --balanced
 
-# Level 3: BMAD Comprehensive
+# Level 3: Comprehensive (Agent-Native)
 adf init --comprehensive
 ```
 
@@ -375,7 +375,7 @@ your-project/
 │   ├── scripts/             # Helper scripts
 │   └── shared/              # Templates, agents, and resources
 │       ├── agents/          # Agent definition files
-│       ├── templates/       # PRP, BMAD, Spec-Kit templates
+│       ├── templates/       # Agent-Native and OpenSpec templates
 │       ├── mcp/             # MCP configurations
 │       └── memory/          # Framework memory/constitution
 ├── .framework/              # Deployment directory
@@ -415,23 +415,23 @@ The `.adf/context.json` file contains your workflow configuration:
 
 ## Workflow Levels
 
-### Level 1: Rapid Development (PRP)
+### Level 1: Rapid (Agent-Native)
 - **Time:** 5-15 minutes planning
 - **Agents:** dev, qa
 - **Best for:** Solo developers, simple projects, prototyping
-- **Templates:** PRP story, PRP task
+- **Templates:** Rapid story, Rapid task
 
-### Level 2: Specification-Driven (Balanced)
+### Level 2: Balanced (OpenSpec)
 - **Time:** 30-60 minutes planning
 - **Agents:** analyst, pm, dev, qa
-- **Best for:** Small teams, moderate complexity
-- **Templates:** Full PRP suite, spec templates
+- **Best for:** Small teams, moderate complexity, iterative requirements
+- **Templates:** OpenSpec proposal, Spec deltas
 
-### Level 3: BMAD Comprehensive
+### Level 3: Comprehensive (Agent-Native)
 - **Time:** 1-2+ hours planning
 - **Agents:** analyst, pm, architect, sm, dev, qa
-- **Best for:** Large teams, complex systems, strategic planning
-- **Templates:** Complete BMAD framework, governance tools
+- **Best for:** Large teams, complex systems, strategic orchestration
+- **Templates:** Complete agent-native suite, governance tools
 
 ## Examples
 
@@ -503,7 +503,7 @@ See [CHANGELOG.md](./CHANGELOG.md) for detailed version history.
 
 **Latest:** v0.14.0 (2026-01-12)
 - **Project Context Synthesis & Extended Tool Support (v0.14.0)** - Minor release
-  - ✨ **Adaptive Project Augmentation** - Synthesizes existing .adf, BMAD, OpenSpec, and Spec-Kit project files into unified context.
+  - ✨ **Adaptive Project Augmentation** - Synthesizes existing .adf, Agent-Native (BMAD), and OpenSpec project files into unified context.
   - ✨ **AI-Driven Gap Analysis** - Automatically identifies knowledge gaps and generates targeted questionnaire to fill them.
   - ✨ **Extended Tool Support** - Native generators for Kiro, Trae, and Codex CLI.
   - ✨ **Tool Audit Registry** - New `adf tools audit` command to monitor integration features across all 12+ supported tools.

package/bin/adf.js

@@ -50,17 +50,17 @@ ${chalk.cyan.bold('What is ADF?')}
   AgentDevFramework (ADF) is an AI-assisted development framework that helps
   you gather requirements through intelligent AI-guided interviews. It supports
   multiple AI providers and workflow levels, from rapid prototyping to
-  comprehensive enterprise documentation.
+  comprehensive agent-native documentation.
 
 ${chalk.cyan.bold('Key Features:')}
   • ${chalk.yellow('Multi-Provider AI')} - Anthropic, OpenAI, Google, OpenRouter
-  • ${chalk.yellow('3 Workflow Levels')} - Rapid (PRP), Balanced (Spec-Kit), Comprehensive (BMAD)
+  • ${chalk.yellow('3 Workflow Levels')} - Rapid (Agent-Native), Balanced (OpenSpec), Comprehensive (Agent-Native)
   • ${chalk.yellow('Smart Filtering')} - AI-powered question filtering based on context
   • ${chalk.yellow('Learning System')} - Adapts to your preferences over time
   • ${chalk.yellow('Session Resume')} - Pause and resume interviews anytime
-  • ${chalk.yellow('Multi-Tool Deploy')} - 10+ IDEs and CLI tools supported
-    ${chalk.gray('IDEs:')} Windsurf, Cursor, VS Code, Zed, Antigravity
-    ${chalk.gray('CLI:')} Claude Code, OpenCode, Gemini CLI, DeepAgent
+  • ${chalk.yellow('Multi-Tool Deploy')} - 12+ IDEs and CLI tools supported
+    ${chalk.gray('IDEs:')} Windsurf, Cursor, VS Code, Zed, Antigravity, Kiro, Trae
+    ${chalk.gray('CLI:')} Claude Code, OpenCode, Gemini CLI, DeepAgent, Codex CLI
 
 ${chalk.cyan.bold('Getting Help:')}
   ${chalk.gray('# Detailed help for specific commands')}
@@ -69,6 +69,7 @@ ${chalk.cyan.bold('Getting Help:')}
   $ adf guide --help
   $ adf config --help
   $ adf update --help
+  $ adf tools audit --help
 
   ${chalk.gray('# Get tool-specific setup guides')}
   $ adf guide windsurf
@@ -83,12 +84,12 @@ ${chalk.cyan.bold('Common Workflows:')}
 
   ${chalk.yellow('Standard Project:')}
     $ adf config              ${chalk.gray('# Configure AI provider once')}
-    $ adf init --balanced     ${chalk.gray('# Run interview')}
+    $ adf init --balanced     ${chalk.gray('# Run OpenSpec interview')}
     $ adf deploy cursor       ${chalk.gray('# Deploy to Cursor')}
 
   ${chalk.yellow('Enterprise Project:')}
     $ adf config              ${chalk.gray('# Configure with comprehensive mode')}
-    $ adf init --comprehensive
+    $ adf init --comprehensive ${chalk.gray('# Run Agent-Native interview')}
     $ adf deploy vscode       ${chalk.gray('# Deploy to multiple tools')}
     $ adf deploy claude-code
 
@@ -106,9 +107,9 @@ ${chalk.cyan.bold('Learn More:')}
 program
   .command('init')
   .description('Initialize AgentDevFramework in current project')
-  .option('--rapid', 'Skip questions, use Level 1 (Rapid Development)')
-  .option('--balanced', 'Skip questions, use Level 2 (Balanced)')
-  .option('--comprehensive', 'Skip questions, use Level 3 (Comprehensive)')
+  .option('--rapid', 'Skip questions, use Level 1 (Rapid (Agent-Native))')
+  .option('--balanced', 'Skip questions, use Level 2 (Balanced (OpenSpec))')
+  .option('--comprehensive', 'Skip questions, use Level 3 (Comprehensive (Agent-Native))')
   .option('--tool <tool>', 'Specify deployment tool (windsurf, cursor, etc.)')
   .addHelpText('after', `
 ${chalk.cyan.bold('Description:')}
@@ -117,20 +118,20 @@ ${chalk.cyan.bold('Description:')}
   documentation based on your chosen workflow level.
 
 ${chalk.cyan.bold('Workflow Levels:')}
-  ${chalk.yellow('Rapid (PRP)')}          - 20 core questions, fast setup
+  ${chalk.yellow('Rapid (Agent-Native)')}   - 20 core questions, fast setup
                         Agents: dev, qa
                         Output: prp.md
                         Best for: Quick prototypes, MVPs
 
-  ${chalk.yellow('Balanced (Spec-Kit)')}  - 30+ questions, detailed specs
+  ${chalk.yellow('Balanced (OpenSpec)')}    - 30+ questions, iterative spec deltas
                         Agents: analyst, pm, dev, qa
                         Output: constitution.md, specification.md, plan.md, tasks.md
-                        Best for: Standard projects with clear requirements
+                        Best for: Standard projects with iterative requirements
 
-  ${chalk.yellow('Comprehensive (BMAD)')} - 40+ questions, full documentation
+  ${chalk.yellow('Comprehensive (Agent-Native)')} - 40+ questions, full agent orchestration
                         Agents: analyst, pm, architect, sm, dev, qa
                         Output: prd.md, architecture.md, stories.md
-                        Best for: Enterprise projects, complex systems
+                        Best for: Enterprise projects, complex agent-native systems
 
 ${chalk.cyan.bold('Examples:')}
   ${chalk.gray('# Interactive mode - choose workflow interactively')}
@@ -172,26 +173,33 @@ ${chalk.cyan.bold('Command Syntax:')}
   ${chalk.white('adf deploy [tool]')}
 
   ${chalk.yellow('[tool]')} - (Optional) Target tool name
-              If omitted, you'll be prompted to select interactively
-              Supported: windsurf, cursor, vscode, claude-code, zed, generic
+              If omitted, you\'ll be prompted to select interactively
+              Supported: windsurf, cursor, vscode, zed, antigravity, kiro, trae,
+                         claude-code, opencode, gemini-cli, deepagent, codex-cli, generic
 
 ${chalk.cyan.bold('Supported Tools:')}
   ${chalk.white.bold('IDEs:')}
   ${chalk.yellow('windsurf')}      - Codeium Windsurf IDE
-                   Output: .windsurfrules
+                   Output: .windsurfrules, .windsurf/rules/
 
   ${chalk.yellow('cursor')}        - Cursor AI IDE
-                   Output: .cursorrules
+                   Output: .cursorrules, .cursor/rules/
 
   ${chalk.yellow('vscode')}        - Visual Studio Code
                    Output: .vscode/settings.json, .github/copilot-instructions.md
 
   ${chalk.yellow('zed')}           - Zed Editor
-                   Output: .zed/settings.json, .zed/rules (symlink to AGENTS.md)
+                   Output: .zed/settings.json, .zed/keymap.json
 
   ${chalk.yellow('antigravity')}   - Google Antigravity IDE
                    Output: .antigravity/agents.yaml
 
+  ${chalk.yellow('kiro')}          - Kiro AI Code Editor
+                   Output: .kiro/product.md, .kiro/technical.md
+
+  ${chalk.yellow('trae')}          - Trae AI IDE
+                   Output: .trae/config.json
+
   ${chalk.white.bold('CLI Tools:')}
   ${chalk.yellow('claude-code')}   - Anthropic Claude Code CLI
                    Output: .framework/agents/*.md
@@ -205,6 +213,9 @@ ${chalk.cyan.bold('Supported Tools:')}
   ${chalk.yellow('deepagent')}     - Abacus.ai DeepAgent CLI
                    Output: .deepagent/agents/*.md, .deepagent/README.md
 
+  ${chalk.yellow('codex-cli')}     - Codex CLI
+                   Output: .codex/config.toml, .codex/instructions.md
+
   ${chalk.white.bold('Generic:')}
   ${chalk.yellow('generic')}       - Generic AI tools (agent markdown files)
                    Output: .framework/agents/*.md
@@ -237,17 +248,20 @@ ${chalk.cyan.bold('Requirements:')}
 
 ${chalk.cyan.bold('Output Files by Tool:')}
   ${chalk.white.bold('IDEs:')}
-  Windsurf:      ${chalk.white('.windsurfrules')}
-  Cursor:        ${chalk.white('.cursorrules')}
+  Windsurf:      ${chalk.white('.windsurfrules + .windsurf/rules/')}
+  Cursor:        ${chalk.white('.cursorrules + .cursor/rules/')}
   VS Code:       ${chalk.white('.vscode/settings.json + .github/copilot-instructions.md')}
-  Zed:           ${chalk.white('.zed/settings.json + .zed/rules')}
+  Zed:           ${chalk.white('.zed/settings.json + .zed/keymap.json')}
   Antigravity:   ${chalk.white('.antigravity/agents.yaml')}
+  Kiro:          ${chalk.white('.kiro/product.md + .kiro/technical.md')}
+  Trae:          ${chalk.white('.trae/config.json')}
 
   ${chalk.white.bold('CLI Tools:')}
   Claude Code:   ${chalk.white('.framework/agents/*.md')}
   OpenCode:      ${chalk.white('.opencode.json')}
   Gemini CLI:    ${chalk.white('GEMINI.md')}
   DeepAgent:     ${chalk.white('.deepagent/agents/*.md + .deepagent/README.md')}
+  Codex CLI:     ${chalk.white('.codex/config.toml + .codex/instructions.md')}
 
   ${chalk.white.bold('Generic:')}
   Generic:       ${chalk.white('.framework/agents/*.md')}
@@ -335,10 +349,13 @@ ${chalk.cyan.bold('Available Tools:')}
   ${chalk.yellow('vscode')}        - Visual Studio Code with GitHub Copilot
   ${chalk.yellow('zed')}           - Zed Editor
   ${chalk.yellow('antigravity')}   - Google Antigravity
+  ${chalk.yellow('kiro')}          - Kiro AI Code Editor
+  ${chalk.yellow('trae')}          - Trae AI IDE
   ${chalk.yellow('claude-code')}   - Claude Code CLI
   ${chalk.yellow('opencode')}      - OpenCode CLI
   ${chalk.yellow('gemini-cli')}    - Google Gemini CLI
   ${chalk.yellow('deepagent')}     - Abacus.ai DeepAgent
+  ${chalk.yellow('codex-cli')}     - Codex CLI
 
 ${chalk.cyan.bold('What You\'ll Learn:')}
   • Which files were generated and what they do
@@ -443,18 +460,18 @@ ${chalk.cyan.bold('Performance Modes:')}
   ${chalk.yellow('Fast')}           - Minimal AI calls (~0.5s per answer)
                     Answer quality: OFF
                     Smart filtering: OFF
-                    Best for: Quick interviews, testing
+                    Best for: Level 1 Rapid (Agent-Native)
 
   ${chalk.yellow('Balanced')}       - Moderate AI usage (~2-3s per answer)
                     Answer quality: ON
                     Smart filtering: ON
-                    Best for: Most projects (recommended)
+                    Best for: Level 2 Balanced (OpenSpec) - Recommended
 
   ${chalk.yellow('Comprehensive')} - Full AI analysis (~4-6s per answer)
                     All features: ON
                     Context extraction: ON
                     Question reordering: ON
-                    Best for: Critical projects, detailed requirements
+                    Best for: Level 3 Comprehensive (Agent-Native)
 
 ${chalk.cyan.bold('Storage Locations:')}
   API Keys:           ${chalk.white('.adf/.env')} ${chalk.gray('(gitignored)')}

package/conductor/product-guidelines.md

@@ -5,7 +5,7 @@
 *   **Context-Aware:** The CLI's tone must dynamically adjust to the specific scenario, project parameters, and user intent.
 *   **Scenario-Based Adaptation:**
     *   *Quick/Rapid Projects:* Adopt a **Professional & Concise** tone. fast, direct, and efficient.
-    *   *Complex/BMAD Projects:* Shift to a **Technical & Analytical** tone, focusing on precision, data, and architectural depth.
+    *   *Complex Agent-Native Projects:* Shift to a **Technical & Analytical** tone, focusing on precision, data, and architectural depth.
     *   *Learning/New Users:* Utilize a **Collaborative & Supportive** tone to guide them through the framework.
 *   **Goal:** Maximize the "return on time investment" by matching the communication style to the user's immediate cognitive load and task requirements.
 

package/conductor/product.md

@@ -16,9 +16,8 @@ Create the definitive AI-driven requirements gathering tool that transforms vagu
 
 **Key Features:**
 *   **Dynamic Questionnaire:** AI-driven interview system that adapts questions based on answer quality, project context, and identified knowledge gaps.
-*   **Project Context Synthesis:** Adaptive project augmentation that intelligently detects existing framework indicators (.adf, BMAD, OpenSpec, Spec-Kit) and merges them into a unified context.
-*   **Learning System:** Tracks user behavior (skips, answers) to detect patterns and generate learned rules that streamline future sessions.
-*   **Artifact Generation:** Automated creation of structured documents (PRP, BMAD, Spec-Kit) and IDE configurations.
+*   **Project Context Synthesis:** Adaptive project augmentation that intelligently detects existing framework indicators (.adf, Agent-Native, OpenSpec) and merges them into a unified context.
+*   **Artifact Generation:** Automated creation of structured documents (Rapid, OpenSpec, Agent-Native) and IDE configurations.
 *   **Multi-Provider AI Support:** Integrates with Anthropic, OpenAI, Google Gemini, and OpenRouter.
 *   **Tool Integration:** Deploys directly to 12+ AI-native tools including Windsurf, Cursor, VS Code, Zed, Antigravity, Kiro, Trae, Codex CLI, and more.
 *   **Tool Audit Registry:** Built-in capability to audit supported tool features and integration status.

package/conductor/tracks/bootstrap_agents_20260111/plan.md

@@ -14,4 +14,9 @@
 - [x] Task: Verify Agent Access.
     - [x] Subtask: Simulate an agent reading `AGENTS.md` and following the references.
     - [x] Subtask: Ensure all paths in `AGENTS.md` are valid.
+- [x] Task: Verify AI Provider Integration (Dynamic Discovery & Perplexity)
+    - [x] Subtask: Upgrade Google Gemini to `@google/genai` and dynamic validation.
+    - [x] Subtask: Implement dynamic model fetching for Anthropic, OpenAI, OpenRouter.
+    - [x] Subtask: Add Perplexity provider with "connectivity check" validation.
+    - [x] Subtask: Ensure tests pass and code is committed.
 - [x] Task: Conductor - User Manual Verification 'Verification' (Protocol in workflow.md)

package/lib/ai/ai-client.js

@@ -35,8 +35,10 @@ class AIClient {
         break;
 
       case 'google':
-        const { GoogleGenerativeAI } = require('@google/generative-ai');
-        this.client = new GoogleGenerativeAI(this.apiKey);
+        const { GoogleGenAI } = require('@google/genai');
+        this.client = new GoogleGenAI({
+          apiKey: this.apiKey
+        });
         break;
 
       case 'openrouter':
@@ -47,6 +49,14 @@ class AIClient {
         });
         break;
 
+      case 'perplexity':
+        const OpenAIForPerplexity = require('openai');
+        this.client = new OpenAIForPerplexity({
+          apiKey: this.apiKey,
+          baseURL: 'https://api.perplexity.ai'
+        });
+        break;
+
       default:
         throw new Error(`Unsupported provider: ${this.provider}`);
     }
@@ -70,11 +80,13 @@ class AIClient {
         case 'google':
           return await this.googleRequest(prompt, maxTokens, temperature);
 
-        case 'openrouter':
-          return await this.openrouterRequest(prompt, maxTokens, temperature);
-
-        default:
-          throw new Error(`Provider ${this.provider} not implemented`);
+              case 'openrouter':
+                return await this.openrouterRequest(prompt, maxTokens, temperature);
+        
+              case 'perplexity':
+                return await this.perplexityRequest(prompt, maxTokens, temperature);
+        
+              default:          throw new Error(`Provider ${this.provider} not implemented`);
       }
     } catch (error) {
       throw new Error(`AI request failed: ${error.message}`);
@@ -194,39 +206,35 @@ class AIClient {
    * Google Gemini request
    */
   async googleRequest(prompt, maxTokens, temperature) {
-    const model = this.client.getGenerativeModel({
-      model: this.model,
-      generationConfig: {
-        maxOutputTokens: maxTokens,
-        temperature
-      }
-    });
+    try {
+      const response = await this.client.models.generateContent({
+        model: this.model,
+        contents: [{ parts: [{ text: prompt }] }],
+        config: {
+          maxOutputTokens: maxTokens,
+          temperature
+        }
+      });
 
-    const result = await model.generateContent(prompt);
-    const response = result.response;
+      const content = response.text;
 
-    // Validate response
-    let content;
-    try {
-      content = response.text();
+      if (!content || content.trim().length === 0) {
+        throw new Error(`Google Gemini model '${this.model}' returned empty content.`);
+      }
+
+      return {
+        content,
+        model: this.model,
+        provider: 'google',
+        usage: {
+          promptTokens: response.usageMetadata?.promptTokenCount || 0,
+          completionTokens: response.usageMetadata?.candidatesTokenCount || 0,
+          totalTokens: response.usageMetadata?.totalTokenCount || 0
+        }
+      };
     } catch (error) {
       throw new Error(`Google Gemini model '${this.model}' failed to generate text: ${error.message}`);
     }
-
-    if (!content || content.trim().length === 0) {
-      throw new Error(`Google Gemini model '${this.model}' returned empty content.`);
-    }
-
-    return {
-      content,
-      model: this.model,
-      provider: 'google',
-      usage: {
-        promptTokens: response.usageMetadata?.promptTokenCount || 0,
-        completionTokens: response.usageMetadata?.candidatesTokenCount || 0,
-        totalTokens: response.usageMetadata?.totalTokenCount || 0
-      }
-    };
   }
 
   /**
@@ -314,6 +322,43 @@ class AIClient {
     }
   }
 
+  /**
+   * Perplexity AI request (via OpenAI-compatible API)
+   */
+  async perplexityRequest(prompt, maxTokens, temperature) {
+    try {
+      // Perplexity supports standard OpenAI chat completions
+      // but has some specific recommended parameters
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        messages: [
+          {
+            role: 'user',
+            content: prompt
+          }
+        ],
+        max_tokens: maxTokens,
+        temperature: temperature,
+        // Optional: Perplexity specific headers can be passed if needed via client config
+      });
+
+      return {
+        content: response.choices[0].message.content,
+        model: this.model,
+        provider: 'perplexity',
+        usage: {
+          promptTokens: response.usage?.prompt_tokens || 0,
+          completionTokens: response.usage?.completion_tokens || 0,
+          totalTokens: response.usage?.total_tokens || 0
+        },
+        // Include search citations if available (Perplexity feature)
+        citations: response.citations || [] 
+      };
+    } catch (error) {
+      throw new Error(`Perplexity request failed: ${error.message}`);
+    }
+  }
+
   /**
    * Test connection with a simple prompt
    */