@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/bin/adf.js

@@ -7,6 +7,7 @@ const packageJson = require('../package.json');
 const initCommand = require('../lib/commands/init');
 const deployCommand = require('../lib/commands/deploy');
 const updateCommand = require('../lib/commands/update');
+const configCommand = require('../lib/commands/config');
 
 const program = new Command();
 
@@ -39,6 +40,12 @@ program
   .option('--check', 'Only check for updates, don\'t install')
   .action(updateCommand);
 
+// adf config
+program
+  .command('config')
+  .description('Configure ADF settings (AI provider, etc.)')
+  .action(configCommand);
+
 // Handle unknown commands
 program.on('command:*', () => {
   console.error(chalk.red(`\nInvalid command: ${program.args.join(' ')}`));

package/lib/ai/ai-client.js

@@ -0,0 +1,328 @@
+/**
+ * Unified AI Client
+ * Provides a consistent interface across multiple AI providers
+ * Supports: Anthropic, OpenAI, Google Gemini, OpenRouter
+ */
+
+class AIClient {
+  constructor(config) {
+    this.config = config;
+    this.provider = config.provider;
+    this.model = config.model;
+    this.apiKey = config.apiKey;
+    this.client = null;
+
+    this.initializeClient();
+  }
+
+  /**
+   * Initialize provider-specific client
+   */
+  initializeClient() {
+    switch (this.provider) {
+      case 'anthropic':
+        const Anthropic = require('@anthropic-ai/sdk');
+        this.client = new Anthropic({
+          apiKey: this.apiKey
+        });
+        break;
+
+      case 'openai':
+        const OpenAI = require('openai');
+        this.client = new OpenAI({
+          apiKey: this.apiKey
+        });
+        break;
+
+      case 'google':
+        const { GoogleGenerativeAI } = require('@google/generative-ai');
+        this.client = new GoogleGenerativeAI(this.apiKey);
+        break;
+
+      case 'openrouter':
+        const OpenAIForRouter = require('openai');
+        this.client = new OpenAIForRouter({
+          apiKey: this.apiKey,
+          baseURL: 'https://openrouter.ai/api/v1'
+        });
+        break;
+
+      default:
+        throw new Error(`Unsupported provider: ${this.provider}`);
+    }
+  }
+
+  /**
+   * Send a message and get a response (unified interface)
+   */
+  async sendMessage(prompt, options = {}) {
+    const maxTokens = options.maxTokens || 2048;
+    const temperature = options.temperature || 0.7;
+
+    try {
+      switch (this.provider) {
+        case 'anthropic':
+          return await this.anthropicRequest(prompt, maxTokens, temperature);
+
+        case 'openai':
+          return await this.openaiRequest(prompt, maxTokens, temperature);
+
+        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`);
+      }
+    } catch (error) {
+      throw new Error(`AI request failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Anthropic Claude request
+   */
+  async anthropicRequest(prompt, maxTokens, temperature) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      temperature,
+      messages: [
+        {
+          role: 'user',
+          content: prompt
+        }
+      ]
+    });
+
+    return {
+      content: response.content[0].text,
+      model: this.model,
+      provider: 'anthropic',
+      usage: {
+        promptTokens: response.usage.input_tokens,
+        completionTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+      }
+    };
+  }
+
+  /**
+   * OpenAI GPT request
+   */
+  async openaiRequest(prompt, maxTokens, temperature) {
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      temperature,
+      messages: [
+        {
+          role: 'user',
+          content: prompt
+        }
+      ]
+    });
+
+    return {
+      content: response.choices[0].message.content,
+      model: this.model,
+      provider: 'openai',
+      usage: {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      }
+    };
+  }
+
+  /**
+   * Google Gemini request
+   */
+  async googleRequest(prompt, maxTokens, temperature) {
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      generationConfig: {
+        maxOutputTokens: maxTokens,
+        temperature
+      }
+    });
+
+    const result = await model.generateContent(prompt);
+    const response = result.response;
+
+    return {
+      content: response.text(),
+      model: this.model,
+      provider: 'google',
+      usage: {
+        promptTokens: response.usageMetadata?.promptTokenCount || 0,
+        completionTokens: response.usageMetadata?.candidatesTokenCount || 0,
+        totalTokens: response.usageMetadata?.totalTokenCount || 0
+      }
+    };
+  }
+
+  /**
+   * OpenRouter request (uses OpenAI-compatible API)
+   */
+  async openrouterRequest(prompt, maxTokens, temperature) {
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      max_tokens: maxTokens,
+      temperature,
+      messages: [
+        {
+          role: 'user',
+          content: prompt
+        }
+      ]
+    });
+
+    return {
+      content: response.choices[0].message.content,
+      model: this.model,
+      provider: 'openrouter',
+      usage: {
+        promptTokens: response.usage?.prompt_tokens || 0,
+        completionTokens: response.usage?.completion_tokens || 0,
+        totalTokens: response.usage?.total_tokens || 0
+      }
+    };
+  }
+
+  /**
+   * Test connection with a simple prompt
+   */
+  async test() {
+    const testPrompt = 'Respond with exactly: "Connection successful"';
+
+    const response = await this.sendMessage(testPrompt, {
+      maxTokens: 50,
+      temperature: 0
+    });
+
+    if (!response.content) {
+      throw new Error('No response from AI provider');
+    }
+
+    return {
+      success: true,
+      provider: this.provider,
+      model: this.model,
+      response: response.content
+    };
+  }
+
+  /**
+   * Analyze answer quality (used by interviewer)
+   */
+  async analyzeAnswerQuality(question, answer) {
+    const prompt = `Analyze this answer to a software requirements question.
+
+Question: ${question}
+
+Answer: ${answer}
+
+Evaluate the answer based on:
+1. Specificity (is it concrete and detailed?)
+2. Completeness (does it address all aspects of the question?)
+3. Clarity (is it clear and unambiguous?)
+4. Technical depth (does it include relevant technical details?)
+
+Respond with ONLY a JSON object in this exact format:
+{
+  "score": <number 0-100>,
+  "issues": ["issue 1", "issue 2"],
+  "suggestions": ["suggestion 1", "suggestion 2"],
+  "missingElements": ["element 1", "element 2"]
+}`;
+
+    const response = await this.sendMessage(prompt, {
+      maxTokens: 500,
+      temperature: 0.3
+    });
+
+    try {
+      // Extract JSON from response (handle markdown code blocks)
+      const jsonMatch = response.content.match(/```json\n([\s\S]*?)\n```/) ||
+                        response.content.match(/{[\s\S]*}/);
+
+      if (!jsonMatch) {
+        throw new Error('No JSON found in response');
+      }
+
+      const analysis = JSON.parse(jsonMatch[1] || jsonMatch[0]);
+
+      return {
+        score: analysis.score || 0,
+        issues: analysis.issues || [],
+        suggestions: analysis.suggestions || [],
+        missingElements: analysis.missingElements || []
+      };
+    } catch (error) {
+      // Fallback if JSON parsing fails
+      return {
+        score: 50,
+        issues: ['Unable to parse AI analysis'],
+        suggestions: ['Please provide more detail'],
+        missingElements: []
+      };
+    }
+  }
+
+  /**
+   * Generate follow-up question based on answer quality
+   */
+  async generateFollowUp(originalQuestion, answer, issues) {
+    const prompt = `You are an expert software requirements analyst. Based on the user's answer, generate a helpful follow-up question.
+
+Original Question: ${originalQuestion}
+
+User's Answer: ${answer}
+
+Issues Identified: ${issues.join(', ')}
+
+Generate ONE concise follow-up question (max 20 words) to help the user provide more specific information. Focus on the most critical missing element.
+
+Respond with ONLY the follow-up question, no explanation.`;
+
+    const response = await this.sendMessage(prompt, {
+      maxTokens: 100,
+      temperature: 0.7
+    });
+
+    return response.content.trim().replace(/^["']|["']$/g, ''); // Remove quotes if present
+  }
+
+  /**
+   * Extract insights from all answers (used for final analysis)
+   */
+  async extractInsights(framework, answers) {
+    const answersText = Object.entries(answers)
+      .map(([id, answer]) => `${id}: ${answer}`)
+      .join('\n');
+
+    const prompt = `Analyze these software requirements gathered using the ${framework.toUpperCase()} framework:
+
+${answersText}
+
+Provide insights on:
+1. Key technical challenges
+2. Critical success factors
+3. Potential risks
+4. Architecture recommendations
+
+Respond with a structured analysis in markdown format.`;
+
+    const response = await this.sendMessage(prompt, {
+      maxTokens: 1500,
+      temperature: 0.5
+    });
+
+    return response.content;
+  }
+}
+
+module.exports = AIClient;