@iservu-inc/adf-cli 0.3.0 → 0.4.12

package/lib/analyzers/project-analyzer.js

@@ -0,0 +1,380 @@
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Project Analyzer - Analyzes existing project files for context
+ *
+ * This module provides intelligent project analysis to:
+ * - Detect project type (web app, CLI, library, API, etc.)
+ * - Identify tech stack and frameworks
+ * - Extract project metadata
+ * - Provide context for smart question filtering
+ */
+
+/**
+ * Project types that can be detected
+ */
+const PROJECT_TYPES = {
+  WEB_APP: 'web-app',
+  API_SERVER: 'api-server',
+  CLI_TOOL: 'cli-tool',
+  LIBRARY: 'library',
+  MOBILE_APP: 'mobile-app',
+  DESKTOP_APP: 'desktop-app',
+  FULLSTACK: 'fullstack',
+  MICROSERVICE: 'microservice',
+  UNKNOWN: 'unknown'
+};
+
+/**
+ * Analyze project and extract context
+ * @param {string} projectPath - Path to project root
+ * @returns {Promise<Object>} Project context object
+ */
+async function analyzeProject(projectPath) {
+  const context = {
+    type: PROJECT_TYPES.UNKNOWN,
+    subtype: null,
+    frameworks: [],
+    languages: [],
+    dependencies: {},
+    devDependencies: {},
+    scripts: {},
+    hasTests: false,
+    hasCI: false,
+    hasDocker: false,
+    teamSize: 'unknown',
+    description: null,
+    confidence: 0
+  };
+
+  // Analyze package.json if exists (Node.js project)
+  const packageJsonPath = path.join(projectPath, 'package.json');
+  if (await fs.pathExists(packageJsonPath)) {
+    const packageData = await analyzePackageJson(packageJsonPath);
+    Object.assign(context, packageData);
+    context.languages.push('JavaScript/TypeScript');
+  }
+
+  // Analyze Python projects
+  const requirementsTxt = path.join(projectPath, 'requirements.txt');
+  const pipfile = path.join(projectPath, 'Pipfile');
+  if (await fs.pathExists(requirementsTxt) || await fs.pathExists(pipfile)) {
+    const pythonData = await analyzePythonProject(projectPath);
+    Object.assign(context, pythonData);
+    context.languages.push('Python');
+  }
+
+  // Analyze file structure
+  const fileStructure = await analyzeFileStructure(projectPath);
+  context.hasTests = context.hasTests || fileStructure.hasTests;  // Preserve if already detected from package.json
+  context.hasCI = fileStructure.hasCI;
+  context.hasDocker = fileStructure.hasDocker;
+
+  // Try to read README for description
+  const readmePath = await findReadme(projectPath);
+  if (readmePath) {
+    context.description = await extractDescriptionFromReadme(readmePath);
+  }
+
+  // Detect project type if still unknown
+  if (context.type === PROJECT_TYPES.UNKNOWN) {
+    context.type = inferProjectType(context);
+  }
+
+  // Calculate confidence score (0-100)
+  context.confidence = calculateConfidence(context);
+
+  return context;
+}
+
+/**
+ * Analyze package.json for Node.js projects
+ */
+async function analyzePackageJson(packageJsonPath) {
+  try {
+    const packageJson = await fs.readJSON(packageJsonPath);
+    const context = {
+      dependencies: packageJson.dependencies || {},
+      devDependencies: packageJson.devDependencies || {},
+      scripts: packageJson.scripts || {},
+      frameworks: [],
+      type: PROJECT_TYPES.UNKNOWN
+    };
+
+    // Detect frameworks
+    const deps = { ...context.dependencies, ...context.devDependencies };
+
+    // Frontend frameworks
+    if (deps.react) context.frameworks.push('React');
+    if (deps.vue) context.frameworks.push('Vue');
+    if (deps.angular || deps['@angular/core']) context.frameworks.push('Angular');
+    if (deps.svelte) context.frameworks.push('Svelte');
+    if (deps.next) context.frameworks.push('Next.js');
+    if (deps.nuxt) context.frameworks.push('Nuxt');
+    if (deps.gatsby) context.frameworks.push('Gatsby');
+
+    // Backend frameworks
+    if (deps.express) context.frameworks.push('Express');
+    if (deps.koa) context.frameworks.push('Koa');
+    if (deps.fastify) context.frameworks.push('Fastify');
+    if (deps.hapi || deps['@hapi/hapi']) context.frameworks.push('Hapi');
+    if (deps.nestjs || deps['@nestjs/core']) context.frameworks.push('NestJS');
+
+    // Testing frameworks
+    if (deps.jest || deps.mocha || deps.jasmine || deps.vitest) {
+      context.hasTests = true;
+    }
+
+    // Detect project type from package.json
+    if (packageJson.bin) {
+      context.type = PROJECT_TYPES.CLI_TOOL;
+      context.subtype = 'cli';
+    } else if (packageJson.main && !packageJson.private) {
+      context.type = PROJECT_TYPES.LIBRARY;
+      context.subtype = 'npm-package';
+    } else if (context.frameworks.some(f => ['React', 'Vue', 'Angular', 'Svelte'].includes(f))) {
+      if (context.frameworks.some(f => ['Express', 'NestJS', 'Fastify'].includes(f))) {
+        context.type = PROJECT_TYPES.FULLSTACK;
+        context.subtype = 'frontend-backend';
+      } else {
+        context.type = PROJECT_TYPES.WEB_APP;
+        context.subtype = 'frontend';
+      }
+    } else if (context.frameworks.some(f => ['Express', 'NestJS', 'Fastify', 'Koa', 'Hapi'].includes(f))) {
+      // Check if it's an API server
+      if (deps.cors || packageJson.name?.includes('api') || packageJson.description?.toLowerCase().includes('api')) {
+        context.type = PROJECT_TYPES.API_SERVER;
+        context.subtype = 'rest-api';
+      } else {
+        context.type = PROJECT_TYPES.WEB_APP;
+        context.subtype = 'backend';
+      }
+    }
+
+    context.description = packageJson.description || null;
+
+    return context;
+  } catch (error) {
+    console.warn(chalk.yellow(`Warning: Could not parse package.json: ${error.message}`));
+    return {};
+  }
+}
+
+/**
+ * Analyze Python project
+ */
+async function analyzePythonProject(projectPath) {
+  const context = {
+    frameworks: [],
+    type: PROJECT_TYPES.UNKNOWN
+  };
+
+  // Check for common Python frameworks
+  const requirementsTxt = path.join(projectPath, 'requirements.txt');
+  if (await fs.pathExists(requirementsTxt)) {
+    const requirements = await fs.readFile(requirementsTxt, 'utf-8');
+
+    if (requirements.includes('django')) context.frameworks.push('Django');
+    if (requirements.includes('flask')) context.frameworks.push('Flask');
+    if (requirements.includes('fastapi')) context.frameworks.push('FastAPI');
+    if (requirements.includes('streamlit')) context.frameworks.push('Streamlit');
+
+    // Detect type
+    if (context.frameworks.some(f => ['Django', 'Flask', 'FastAPI'].includes(f))) {
+      context.type = PROJECT_TYPES.WEB_APP;
+      context.subtype = 'python-web';
+    }
+  }
+
+  return context;
+}
+
+/**
+ * Analyze file structure for indicators
+ */
+async function analyzeFileStructure(projectPath) {
+  const structure = {
+    hasTests: false,
+    hasCI: false,
+    hasDocker: false
+  };
+
+  try {
+    const files = await fs.readdir(projectPath);
+
+    // Check for test directories
+    if (files.includes('test') || files.includes('tests') || files.includes('__tests__') || files.includes('spec')) {
+      structure.hasTests = true;
+    }
+
+    // Check for CI configuration
+    if (files.includes('.github') || files.includes('.gitlab-ci.yml') || files.includes('.travis.yml') || files.includes('.circleci')) {
+      structure.hasCI = true;
+    }
+
+    // Check for Docker
+    if (files.includes('Dockerfile') || files.includes('docker-compose.yml')) {
+      structure.hasDocker = true;
+    }
+  } catch (error) {
+    // Silently fail - not critical
+  }
+
+  return structure;
+}
+
+/**
+ * Find README file (case-insensitive)
+ */
+async function findReadme(projectPath) {
+  const readmeNames = ['README.md', 'readme.md', 'README.MD', 'README', 'Readme.md'];
+
+  for (const name of readmeNames) {
+    const readmePath = path.join(projectPath, name);
+    if (await fs.pathExists(readmePath)) {
+      return readmePath;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract description from README (first paragraph)
+ */
+async function extractDescriptionFromReadme(readmePath) {
+  try {
+    const content = await fs.readFile(readmePath, 'utf-8');
+
+    // Remove title (first # line)
+    const lines = content.split('\n');
+    let description = '';
+    let foundTitle = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Skip title
+      if (!foundTitle && trimmed.startsWith('#')) {
+        foundTitle = true;
+        continue;
+      }
+
+      // Skip empty lines
+      if (!trimmed) continue;
+
+      // Stop at next heading or code block
+      if (trimmed.startsWith('#') || trimmed.startsWith('```')) break;
+
+      // Add to description
+      description += trimmed + ' ';
+
+      // Stop after first paragraph (roughly 200 chars)
+      if (description.length > 200) break;
+    }
+
+    return description.trim().substring(0, 300) || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Infer project type from context when not explicitly detected
+ */
+function inferProjectType(context) {
+  // If we have frameworks, make educated guess
+  if (context.frameworks.length > 0) {
+    const frontend = ['React', 'Vue', 'Angular', 'Svelte', 'Next.js', 'Nuxt', 'Gatsby'];
+    const backend = ['Express', 'NestJS', 'Fastify', 'Koa', 'Django', 'Flask', 'FastAPI'];
+
+    const hasFrontend = context.frameworks.some(f => frontend.includes(f));
+    const hasBackend = context.frameworks.some(f => backend.includes(f));
+
+    if (hasFrontend && hasBackend) return PROJECT_TYPES.FULLSTACK;
+    if (hasFrontend) return PROJECT_TYPES.WEB_APP;
+    if (hasBackend) return PROJECT_TYPES.API_SERVER;
+  }
+
+  // Check description for hints
+  if (context.description) {
+    const desc = context.description.toLowerCase();
+    if (desc.includes('api') || desc.includes('server')) return PROJECT_TYPES.API_SERVER;
+    if (desc.includes('cli') || desc.includes('command-line')) return PROJECT_TYPES.CLI_TOOL;
+    if (desc.includes('library') || desc.includes('package')) return PROJECT_TYPES.LIBRARY;
+    if (desc.includes('web') || desc.includes('app')) return PROJECT_TYPES.WEB_APP;
+  }
+
+  return PROJECT_TYPES.UNKNOWN;
+}
+
+/**
+ * Calculate confidence score (0-100) for the analysis
+ */
+function calculateConfidence(context) {
+  let score = 0;
+
+  // Type detection (+30)
+  if (context.type !== PROJECT_TYPES.UNKNOWN) score += 30;
+
+  // Framework detection (+20)
+  if (context.frameworks.length > 0) score += 20;
+
+  // Language detection (+15)
+  if (context.languages.length > 0) score += 15;
+
+  // Dependencies (+10)
+  if (Object.keys(context.dependencies).length > 0) score += 10;
+
+  // Description (+15)
+  if (context.description) score += 15;
+
+  // Additional indicators (+10)
+  if (context.hasTests) score += 3;
+  if (context.hasCI) score += 3;
+  if (context.hasDocker) score += 4;
+
+  return Math.min(score, 100);
+}
+
+/**
+ * Get human-readable project summary
+ */
+function getProjectSummary(context) {
+  const parts = [];
+
+  // Type
+  const typeNames = {
+    [PROJECT_TYPES.WEB_APP]: 'Web Application',
+    [PROJECT_TYPES.API_SERVER]: 'API Server',
+    [PROJECT_TYPES.CLI_TOOL]: 'CLI Tool',
+    [PROJECT_TYPES.LIBRARY]: 'Library/Package',
+    [PROJECT_TYPES.MOBILE_APP]: 'Mobile App',
+    [PROJECT_TYPES.DESKTOP_APP]: 'Desktop App',
+    [PROJECT_TYPES.FULLSTACK]: 'Full-stack Application',
+    [PROJECT_TYPES.MICROSERVICE]: 'Microservice',
+    [PROJECT_TYPES.UNKNOWN]: 'Unknown Type'
+  };
+
+  parts.push(typeNames[context.type] || 'Unknown');
+
+  // Frameworks
+  if (context.frameworks.length > 0) {
+    parts.push(`using ${context.frameworks.join(', ')}`);
+  }
+
+  // Languages
+  if (context.languages.length > 0) {
+    parts.push(`(${context.languages.join(', ')})`);
+  }
+
+  return parts.join(' ');
+}
+
+module.exports = {
+  analyzeProject,
+  getProjectSummary,
+  PROJECT_TYPES
+};

package/lib/commands/config.js

@@ -0,0 +1,221 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { configureAIProvider, getEnvFilePath, loadEnvFile } = require('../ai/ai-config');
+const LearningManager = require('../learning/learning-manager');
+const { getLearningStats, getLearningConfig } = require('../learning/storage');
+
+/**
+ * Configuration categories available in ADF CLI
+ */
+const CONFIG_CATEGORIES = {
+  AI_PROVIDER: {
+    name: 'AI Provider Setup',
+    description: 'Configure AI provider (Anthropic, OpenAI, Google Gemini, OpenRouter)',
+    value: 'ai-provider'
+  },
+  LEARNING_SYSTEM: {
+    name: 'Learning System',
+    description: 'Manage interview learning data and preferences',
+    value: 'learning'
+  }
+  // Future config categories can be added here:
+  // PROJECT_SETTINGS: { name: 'Project Settings', description: '...', value: 'project' },
+  // DEPLOYMENT: { name: 'Deployment Preferences', description: '...', value: 'deployment' },
+};
+
+/**
+ * Check if AI provider is already configured
+ */
+async function isAIConfigured(projectPath = process.cwd()) {
+  const envPath = getEnvFilePath(projectPath);
+
+  if (!await fs.pathExists(envPath)) {
+    return { configured: false };
+  }
+
+  const envVars = await loadEnvFile(envPath);
+
+  // Check if any AI provider key exists
+  const aiKeys = [
+    'ANTHROPIC_API_KEY',
+    'OPENAI_API_KEY',
+    'GOOGLE_API_KEY',
+    'OPENROUTER_API_KEY'
+  ];
+
+  for (const key of aiKeys) {
+    if (envVars[key] && envVars[key].length > 0) {
+      return {
+        configured: true,
+        provider: key.replace('_API_KEY', '').toLowerCase()
+      };
+    }
+  }
+
+  return { configured: false };
+}
+
+/**
+ * Check if Learning System has data
+ */
+async function getLearningStatus(projectPath = process.cwd()) {
+  try {
+    const stats = await getLearningStats(projectPath);
+    const config = await getLearningConfig(projectPath);
+
+    return {
+      hasData: stats.totalSessions > 0,
+      enabled: config.enabled,
+      totalSessions: stats.totalSessions,
+      totalPatterns: stats.totalPatterns
+    };
+  } catch (error) {
+    return {
+      hasData: false,
+      enabled: true,
+      totalSessions: 0,
+      totalPatterns: 0
+    };
+  }
+}
+
+/**
+ * Display configuration status for AI provider
+ */
+function displayAIStatus(status) {
+  if (status.configured) {
+    const providerName = status.provider.charAt(0).toUpperCase() + status.provider.slice(1);
+    return `${chalk.green('✓ Configured')} ${chalk.gray(`(${providerName})`)}`;
+  } else {
+    return chalk.yellow('○ Not configured');
+  }
+}
+
+/**
+ * Display configuration status for Learning System
+ */
+function displayLearningStatus(status) {
+  if (status.hasData && status.enabled) {
+    return `${chalk.green('✓ Active')} ${chalk.gray(`(${status.totalSessions} sessions, ${status.totalPatterns} patterns)`)}`;
+  } else if (status.hasData && !status.enabled) {
+    return `${chalk.yellow('○ Disabled')} ${chalk.gray(`(${status.totalSessions} sessions)`)}`;
+  } else if (!status.hasData && status.enabled) {
+    return chalk.gray('○ No data yet');
+  } else {
+    return chalk.gray('○ Not configured');
+  }
+}
+
+/**
+ * Main config command
+ */
+async function config() {
+  console.log(chalk.cyan.bold('\n⚙️  ADF Configuration\n'));
+
+  const cwd = process.cwd();
+
+  // Check configuration status for all categories
+  const aiStatus = await isAIConfigured(cwd);
+  const learningStatus = await getLearningStatus(cwd);
+
+  // Build choices with status indicators
+  const choices = [
+    {
+      name: `${CONFIG_CATEGORIES.AI_PROVIDER.name} - ${displayAIStatus(aiStatus)}`,
+      value: CONFIG_CATEGORIES.AI_PROVIDER.value,
+      short: CONFIG_CATEGORIES.AI_PROVIDER.name
+    },
+    {
+      name: `${CONFIG_CATEGORIES.LEARNING_SYSTEM.name} - ${displayLearningStatus(learningStatus)}`,
+      value: CONFIG_CATEGORIES.LEARNING_SYSTEM.value,
+      short: CONFIG_CATEGORIES.LEARNING_SYSTEM.name
+    },
+    new inquirer.Separator(),
+    {
+      name: chalk.gray('← Back'),
+      value: 'back'
+    }
+  ];
+
+  const { category } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'category',
+      message: 'Select configuration category:',
+      choices: choices,
+      pageSize: 10
+    }
+  ]);
+
+  if (category === 'back') {
+    console.log(chalk.yellow('\n✋ Configuration cancelled.\n'));
+    return;
+  }
+
+  // Handle selected category
+  switch (category) {
+    case 'ai-provider':
+      await configureAIProviderCategory(cwd, aiStatus);
+      break;
+
+    case 'learning':
+      await configureLearningCategory(cwd, learningStatus);
+      break;
+
+    // Future categories will be handled here
+    default:
+      console.log(chalk.red('\n❌ Configuration category not implemented yet.\n'));
+  }
+}
+
+/**
+ * Configure AI Provider category
+ */
+async function configureAIProviderCategory(cwd, aiStatus) {
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+
+  if (aiStatus.configured) {
+    const providerName = aiStatus.provider.charAt(0).toUpperCase() + aiStatus.provider.slice(1);
+    console.log(chalk.green(`✓ AI Provider already configured: ${providerName}\n`));
+
+    const { reconfigure } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'reconfigure',
+        message: 'Do you want to reconfigure your AI provider?',
+        default: false
+      }
+    ]);
+
+    if (!reconfigure) {
+      console.log(chalk.yellow('\n✋ Configuration unchanged.\n'));
+      return;
+    }
+  }
+
+  // Run AI provider configuration
+  console.log('');
+  const aiConfig = await configureAIProvider(cwd);
+
+  if (aiConfig) {
+    console.log(chalk.green.bold('\n✅ AI Provider configured successfully!\n'));
+    console.log(chalk.gray(`  Provider: ${aiConfig.providerName}`));
+    console.log(chalk.gray(`  Model: ${aiConfig.model}`));
+    console.log(chalk.gray(`  Config saved to: ${getEnvFilePath(cwd)}\n`));
+  }
+}
+
+/**
+ * Configure Learning System category
+ */
+async function configureLearningCategory(cwd, learningStatus) {
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+
+  // Create and show learning manager menu
+  const learningManager = new LearningManager(cwd);
+  await learningManager.showMenu();
+}
+
+module.exports = config;

package/lib/commands/init.js

@@ -10,6 +10,7 @@ const {
 const Interviewer = require('../frameworks/interviewer');
 const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
+const { configureAIProvider, loadEnvIntoProcess, getEnvFilePath } = require('../ai/ai-config');
 
 async function init(options) {
   console.log(chalk.cyan.bold('\n🚀 AgentDevFramework - Software Development Requirements\n'));
@@ -17,13 +18,41 @@ async function init(options) {
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
 
+  // Load .env file if it exists (for API keys)
+  const envPath = getEnvFilePath(cwd);
+  if (await fs.pathExists(envPath)) {
+    loadEnvIntoProcess(envPath);
+  }
+
   // Check for resumable sessions FIRST (before asking to overwrite)
   const sessionManager = new SessionManager(cwd);
   const existingSession = await sessionManager.promptToResume();
 
   if (existingSession) {
     // Resume existing session
-    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession);
+    // Check if session has AI config (from resumed session)
+    let aiConfig = existingSession.progress.aiConfig;
+
+    if (aiConfig) {
+      // We have AI config from session, but need to verify API key exists
+      const apiKey = process.env[aiConfig.envVar];
+      if (!apiKey) {
+        console.log(chalk.yellow(`\n⚠️  Previous session used ${aiConfig.providerName}`));
+        console.log(chalk.yellow(`Please configure API key to resume...\n`));
+        aiConfig = await configureAIProvider(cwd);
+      } else {
+        // Add API key to config (it's not stored in session for security)
+        aiConfig.apiKey = apiKey;
+        console.log(chalk.green(`\n✓ Resuming with ${aiConfig.providerName} (${aiConfig.model})\n`));
+      }
+    } else {
+      // Old session without AI config, configure now
+      console.log(chalk.yellow('\n⚠️  This session was created before AI provider integration.'));
+      console.log(chalk.yellow('Please configure AI provider to continue...\n'));
+      aiConfig = await configureAIProvider(cwd);
+    }
+
+    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession, aiConfig);
     const sessionPath = await interviewer.start();
 
     console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
@@ -76,17 +105,34 @@ async function init(options) {
   // Create .adf directory
   await fs.ensureDir(adfDir);
 
-  // Start AI-guided interview
+  // Configure AI Provider (OPTIONAL - can be done later with 'adf config')
+  let aiConfig = null;
+
+  const { configureAI } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureAI',
+      message: 'Configure AI provider now? (Enables intelligent follow-up questions)',
+      default: true
+    }
+  ]);
+
+  if (configureAI) {
+    aiConfig = await configureAIProvider(cwd);
+  } else {
+    console.log(chalk.yellow('\n💡 You can configure AI later by running: adf config\n'));
+  }
+
+  // Start interview (with or without AI)
   console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
 
-  const interviewer = new Interviewer(workflow, cwd);
+  const interviewer = new Interviewer(workflow, cwd, null, aiConfig);
   const sessionPath = await interviewer.start();
 
-  // Show next steps
-  console.log(chalk.cyan('📋 Next Steps:\n'));
-  console.log(chalk.gray(`  1. Review your requirements: ${sessionPath}/outputs/`));
-  console.log(chalk.gray(`  2. Share the output files with your AI coding assistant`));
-  console.log(chalk.gray(`  3. Start building based on the detailed requirements\n`));
+  // Show completion message
+  console.log(chalk.cyan('📋 Requirements Complete!\n'));
+  console.log(chalk.gray(`  ✓ Files saved to: ${sessionPath}/outputs/`));
+  console.log(chalk.gray(`  ✓ You can review your requirements anytime\n`));
 
   // Optional: Deploy to tool
   if (options.tool) {
@@ -97,8 +143,8 @@ async function init(options) {
       {
         type: 'confirm',
         name: 'deployNow',
-        message: 'Deploy framework to a development tool?',
-        default: false
+        message: 'Automatically deploy to your IDE? (I\'ll configure everything for you)',
+        default: true
       }
     ]);