@iservu-inc/adf-cli 0.3.6 → 0.4.13

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

@@ -3,6 +3,8 @@ 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
@@ -12,6 +14,11 @@ const CONFIG_CATEGORIES = {
     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' },
@@ -50,6 +57,30 @@ async function isAIConfigured(projectPath = process.cwd()) {
   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
  */
@@ -62,6 +93,21 @@ function displayAIStatus(status) {
   }
 }
 
+/**
+ * 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
  */
@@ -70,8 +116,9 @@ async function config() {
 
   const cwd = process.cwd();
 
-  // Check AI configuration status
+  // Check configuration status for all categories
   const aiStatus = await isAIConfigured(cwd);
+  const learningStatus = await getLearningStatus(cwd);
 
   // Build choices with status indicators
   const choices = [
@@ -80,6 +127,11 @@ async function config() {
       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'),
@@ -108,6 +160,10 @@ async function config() {
       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'));
@@ -151,4 +207,15 @@ async function configureAIProviderCategory(cwd, aiStatus) {
   }
 }
 
+/**
+ * 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

@@ -105,28 +105,9 @@ async function init(options) {
   // Create .adf directory
   await fs.ensureDir(adfDir);
 
-  // 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, null, aiConfig);
+  // AI will be configured as first block in the interview
+  // Start interview
+  const interviewer = new Interviewer(workflow, cwd, null, null);
   const sessionPath = await interviewer.start();
 
   // Show completion message