cadr-cli 0.0.1 → 1.9.1

package/src/commands/analyze.ts

@@ -0,0 +1,56 @@
+/**
+ * Analyze Command
+ * 
+ * Triggers LLM-powered analysis of code changes.
+ * Thin wrapper around analysis orchestration module.
+ */
+
+import { runAnalysis } from '../analysis';
+import { DiffOptions } from '../git';
+import { loggerInstance as logger } from '../logger';
+
+/**
+ * Execute the analyze command
+ * Analyzes code changes for architectural significance
+ * 
+ * @param args - Command line arguments (e.g., ['--staged'], ['--all'])
+ */
+export async function analyzeCommand(args: string[] = []): Promise<void> {
+  try {
+    // Parse command line flags to determine diff options
+    const diffOptions: DiffOptions = { mode: 'all' }; // Default to all uncommitted
+    
+    // Check for --base flag (implies branch-diff mode)
+    const baseIndex = args.indexOf('--base');
+    if (baseIndex !== -1 && baseIndex + 1 < args.length) {
+      diffOptions.mode = 'branch-diff';
+      diffOptions.base = args[baseIndex + 1];
+      
+      // Check for optional --head flag
+      const headIndex = args.indexOf('--head');
+      if (headIndex !== -1 && headIndex + 1 < args.length) {
+        diffOptions.head = args[headIndex + 1];
+      }
+    } else if (args.includes('--staged')) {
+      diffOptions.mode = 'staged';
+    } else if (args.includes('--all')) {
+      diffOptions.mode = 'all';
+    }
+    
+    logger.info('Analyze command started', { 
+      mode: diffOptions.mode,
+      base: diffOptions.base,
+      head: diffOptions.head
+    });
+    await runAnalysis(diffOptions);
+    logger.info('Analyze command completed');
+  } catch (error) {
+    // Fail-open: log error but don't throw
+    logger.error('Analyze command failed', { error });
+    // eslint-disable-next-line no-console
+    console.error('\n❌ Analysis command failed');
+    // eslint-disable-next-line no-console
+    console.error('Please check the logs for more details.\n');
+  }
+}
+

package/src/commands/init.test.ts

@@ -0,0 +1,27 @@
+import { initCommand } from './init';
+import * as config from '../config';
+
+// Mock dependencies
+jest.mock('../config');
+
+describe('Init Command', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('initCommand', () => {
+    test('calls createConfig when no config exists', async () => {
+      (config.createConfig as jest.Mock).mockResolvedValue({ provider: 'openai' });
+      
+      await initCommand();
+      
+      expect(config.createConfig).toHaveBeenCalled();
+    });
+
+    test('handles config creation errors gracefully', async () => {
+      (config.createConfig as jest.Mock).mockRejectedValue(new Error('Permission denied'));
+      
+      await expect(initCommand()).resolves.not.toThrow();
+    });
+  });
+});

package/src/commands/init.ts

@@ -0,0 +1,99 @@
+/**
+ * Init Command
+ * 
+ * Interactive command to create cadr.yaml configuration file.
+ * Handles user prompts and configuration creation.
+ */
+
+import { createConfig, getDefaultConfigPath, validateConfig } from '../config';
+import { loggerInstance as logger } from '../logger';
+import { existsSync } from 'fs';
+
+/**
+ * Execute the init command
+ * Creates configuration file interactively
+ */
+export async function initCommand(): Promise<void> {
+  try {
+    const configPath = getDefaultConfigPath();
+
+    // Check if config already exists
+    if (existsSync(configPath)) {
+      // eslint-disable-next-line no-console
+      console.log(`\nℹ️  Configuration file already exists: ${configPath}`);
+      // eslint-disable-next-line no-console
+      console.log('💡 To reconfigure, delete the file and run `cadr init` again.\n');
+      return;
+    }
+
+    // Create configuration interactively
+    const config = await createConfig(configPath);
+
+    if (!config) {
+      // eslint-disable-next-line no-console
+      console.error('\n❌ Failed to create configuration');
+      // eslint-disable-next-line no-console
+      console.error('Please try again or check file permissions.\n');
+      return;
+    }
+
+    // Validate the created config
+    const validation = validateConfig(config);
+    if (!validation.valid) {
+      logger.warn('Created config has validation warnings', {
+        errors: validation.errors,
+      });
+    }
+
+    // Display next steps
+    // eslint-disable-next-line no-console
+    console.log('📋 Configuration Summary:');
+    // eslint-disable-next-line no-console
+    console.log(`   Provider: ${config.provider}`);
+    // eslint-disable-next-line no-console
+    console.log(`   Model: ${config.analysis_model}`);
+    // eslint-disable-next-line no-console
+    console.log(`   API Key Env: ${config.api_key_env}`);
+    // eslint-disable-next-line no-console
+    console.log(`   Timeout: ${config.timeout_seconds}s`);
+    if (config.ignore_patterns && config.ignore_patterns.length > 0) {
+      // eslint-disable-next-line no-console
+      console.log(`   Ignore Patterns: ${config.ignore_patterns.join(', ')}`);
+    }
+
+    // Check if API key is set
+    if (!process.env[config.api_key_env]) {
+      // eslint-disable-next-line no-console
+      console.warn(`\n⚠️  Warning: ${config.api_key_env} is not set in your environment`);
+      // eslint-disable-next-line no-console
+      console.warn('Set it before using analysis:');
+      // eslint-disable-next-line no-console
+      console.warn(`   export ${config.api_key_env}="your-api-key-here"`);
+      // eslint-disable-next-line no-console
+      const providerLink = config.provider === 'gemini'
+        ? 'https://aistudio.google.com/app/apikey'
+        : 'https://platform.openai.com/api-keys';
+      // eslint-disable-next-line no-console
+      console.warn(`\n   Get your API key from: ${providerLink}`);
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('\n🎉 Ready to analyze!');
+    // eslint-disable-next-line no-console
+    console.log('Next steps:');
+    // eslint-disable-next-line no-console
+    console.log('   1. Stage your changes: git add <files>');
+    // eslint-disable-next-line no-console
+    console.log('   2. Run analysis: cadr --analyze\n');
+
+    logger.info('Init command completed successfully');
+  } catch (error) {
+    // Fail-open: log error but don't throw
+    logger.error('Init command failed', { error });
+    // eslint-disable-next-line no-console
+    console.error('\n❌ An unexpected error occurred during initialization');
+    // eslint-disable-next-line no-console
+    console.error('Please check the logs for more details.\n');
+  }
+}
+

package/src/config.test.ts

@@ -0,0 +1,79 @@
+import { loadConfig, validateConfig, AnalysisConfig } from './config';
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+
+// Mock fs and yaml modules
+jest.mock('fs');
+jest.mock('js-yaml');
+
+describe('Configuration Module', () => {
+  const mockConfig: AnalysisConfig = {
+    provider: 'openai',
+    analysis_model: 'gpt-4',
+    api_key_env: 'OPENAI_API_KEY',
+    timeout_seconds: 15
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('loadConfig', () => {
+    test('loads valid configuration successfully', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('provider: openai\nanalysis_model: gpt-4');
+      (yaml.load as jest.Mock).mockReturnValue(mockConfig);
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toEqual(mockConfig);
+      expect(fs.existsSync).toHaveBeenCalledWith('/test/cadr.yaml');
+      expect(fs.readFileSync).toHaveBeenCalledWith('/test/cadr.yaml', 'utf-8');
+    });
+
+    test('returns null when config file does not exist', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+    });
+
+    test('returns null when config file is invalid', async () => {
+      (fs.existsSync as jest.Mock).mockReturnValue(true);
+      (fs.readFileSync as jest.Mock).mockReturnValue('invalid yaml');
+      (yaml.load as jest.Mock).mockImplementation(() => {
+        throw new Error('Invalid YAML');
+      });
+
+      const result = await loadConfig('/test/cadr.yaml');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('validateConfig', () => {
+    test('validates correct configuration', () => {
+      const result = validateConfig(mockConfig);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test('rejects invalid provider', () => {
+      const invalidConfig = { ...mockConfig, provider: 'invalid' };
+      const result = validateConfig(invalidConfig);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.join('\n')).toMatch(/provider must be one of the following values: openai, gemini/);
+    });
+
+    test('rejects missing required fields', () => {
+      const invalidConfig = { provider: 'openai' };
+      const result = validateConfig(invalidConfig);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/config.ts

@@ -0,0 +1,214 @@
+import * as yaml from 'js-yaml';
+import * as yup from 'yup';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import * as readline from 'readline';
+import { loggerInstance as logger } from './logger';
+
+/**
+ * Configuration schema for LLM analysis
+ */
+export interface AnalysisConfig {
+  provider: 'openai' | 'gemini';
+  analysis_model: string;
+  api_key_env: string;
+  timeout_seconds: number;
+  ignore_patterns?: string[];
+}
+
+/**
+ * Configuration validation result
+ */
+export interface ConfigValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+/**
+ * Yup validation schema for configuration
+ */
+const configSchema = yup.object({
+  provider: yup
+    .string()
+    .oneOf(['openai', 'gemini'])
+    .required('Provider must be one of: "openai", "gemini"'),
+  analysis_model: yup.string().required('Analysis model is required'),
+  api_key_env: yup.string().required('API key environment variable name is required'),
+  timeout_seconds: yup
+    .number()
+    .min(1, 'timeout_seconds must be at least 1 second')
+    .max(60, 'timeout_seconds must not exceed 60 seconds')
+    .required('timeout_seconds is required'),
+  ignore_patterns: yup.array().of(yup.string()).optional(),
+});
+
+/**
+ * Load and validate configuration from YAML file
+ * @param configPath - Path to configuration file
+ * @returns Promise resolving to validated config or null on error
+ */
+export async function loadConfig(configPath: string): Promise<AnalysisConfig | null> {
+  try {
+    // Check if config file exists
+    if (!existsSync(configPath)) {
+      logger.warn('Configuration file not found', { configPath });
+      return null;
+    }
+
+    // Read and parse YAML
+    const fileContent = readFileSync(configPath, 'utf-8');
+    const parsedConfig = yaml.load(fileContent);
+
+    if (!parsedConfig || typeof parsedConfig !== 'object') {
+      logger.error('Invalid YAML configuration', { configPath });
+      return null;
+    }
+
+    // Validate configuration
+    const validationResult = validateConfig(parsedConfig);
+    if (!validationResult.valid) {
+      logger.error('Configuration validation failed', {
+        configPath,
+        errors: validationResult.errors,
+      });
+      return null;
+    }
+
+    const config = parsedConfig as AnalysisConfig;
+
+    // Warn if API key environment variable is not set
+    if (!process.env[config.api_key_env]) {
+      logger.warn('API key environment variable is not set', {
+        api_key_env: config.api_key_env,
+      });
+    }
+
+    logger.info('Configuration loaded successfully', { configPath, provider: config.provider });
+    return config;
+  } catch (error) {
+    logger.error('Failed to load configuration', { error, configPath });
+    return null;
+  }
+}
+
+/**
+ * Validate configuration object against schema
+ * @param config - Configuration object to validate
+ * @returns Validation result with errors if any
+ */
+export function validateConfig(config: unknown): ConfigValidationResult {
+  try {
+    configSchema.validateSync(config, { abortEarly: false });
+    return { valid: true, errors: [] };
+  } catch (error) {
+    if (error instanceof yup.ValidationError) {
+      return {
+        valid: false,
+        errors: error.errors,
+      };
+    }
+    return {
+      valid: false,
+      errors: ['Unknown validation error'],
+    };
+  }
+}
+
+/**
+ * Prompt user for input with default value
+ */
+function prompt(rl: readline.Interface, question: string, defaultValue?: string): Promise<string> {
+  return new Promise((resolve) => {
+    const promptText = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(promptText, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+/**
+ * Create configuration interactively
+ * @param configPath - Path where config should be created
+ * @returns Promise resolving to created config or null on error
+ */
+export async function createConfig(configPath: string): Promise<AnalysisConfig | null> {
+  try {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    // eslint-disable-next-line no-console
+    console.log('\n🔧 cADR Configuration Setup\n');
+
+    // Prompt for configuration values
+    const provider = await prompt(rl, 'LLM Provider', 'openai');
+
+    // Choose sensible defaults based on provider
+    const defaultModel = provider === 'gemini' ? 'gemini-1.5-pro' : 'gpt-4';
+    const defaultApiKeyEnv = provider === 'gemini' ? 'GEMINI_API_KEY' : 'OPENAI_API_KEY';
+
+    const analysis_model = await prompt(rl, 'Analysis Model', defaultModel);
+    const api_key_env = await prompt(rl, 'API Key Environment Variable', defaultApiKeyEnv);
+    const timeoutInput = await prompt(rl, 'Timeout (seconds)', '15');
+    const timeout_seconds = parseInt(timeoutInput, 10) || 15;
+
+    const ignorePatternsInput = await prompt(
+      rl,
+      'Ignore Patterns (comma-separated, optional)',
+      '*.md,package-lock.json'
+    );
+    const ignore_patterns =
+      ignorePatternsInput
+        .split(',')
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0) || undefined;
+
+    rl.close();
+
+    // Build configuration object
+    const config: AnalysisConfig = {
+      provider: provider as 'openai' | 'gemini',
+      analysis_model,
+      api_key_env,
+      timeout_seconds,
+      ...(ignore_patterns && ignore_patterns.length > 0 ? { ignore_patterns } : {}),
+    };
+
+    // Validate configuration
+    const validationResult = validateConfig(config);
+    if (!validationResult.valid) {
+      // eslint-disable-next-line no-console
+      console.error('\n❌ Configuration validation failed:');
+      // eslint-disable-next-line no-console
+      validationResult.errors.forEach((error) => console.error(`  - ${error}`));
+      return null;
+    }
+
+    // Convert to YAML
+    const yamlContent = yaml.dump(config, {
+      indent: 2,
+      lineWidth: -1,
+      noRefs: true,
+    });
+
+    // Write to file
+    writeFileSync(configPath, yamlContent, 'utf-8');
+
+    logger.info('Configuration file created successfully', { configPath });
+    // eslint-disable-next-line no-console
+    console.log(`\n✅ Configuration saved to: ${configPath}\n`);
+
+    return config;
+  } catch (error) {
+    logger.error('Failed to create configuration', { error, configPath });
+    return null;
+  }
+}
+
+/**
+ * Get default configuration file path
+ */
+export function getDefaultConfigPath(): string {
+  return 'cadr.yaml';
+}
+