docs-rag/src/cli/parser-commands.ts

#!/usr/bin/env node

import { Command } from 'commander';
import { ParseService } from '../services/parseService';
import { existsSync } from 'fs';
import { resolve } from 'path';

const parseService = new ParseService();

export const parserCommands = (program: Command) => {
  program
    .command('parse')
    .description('Generate documentation from source code comments')
    .requiredOption('-i, --input <path>', 'Input directory containing source files')
    .requiredOption('-o, --output <path>', 'Output directory for generated documentation')
    .option('-l, --languages <languages>', 'Comma-separated list of languages to parse', 'cpp')
    .option('-c, --config <config>', 'Configuration file path')
    .option('-w, --watch', 'Watch for file changes and regenerate', false)
    .option('--incremental', 'Only process changed files', false)
    .option('--include-private', 'Include private members', false)
    .option('--dry-run', 'Show what would be parsed without generating files', false)
    .action(async (options) => {
      if (!existsSync(options.input)) {
        console.error(`Error: Input directory '${options.input}' does not exist`);
        process.exit(1);
      }

      try {
        const result = await parseService.generateDocumentation({
          inputPath: resolve(options.input),
          outputPath: resolve(options.output),
          languages: options.languages.split(',').map((l: string) => l.trim()),
          configPath: options.config ? resolve(options.config) : undefined,
          watch: options.watch,
          incremental: options.incremental,
          includePrivate: options.includePrivate,
          dryRun: options.dryRun
        });

        if (options.dryRun) {
          console.log('Dry run results:');
          console.log(`  Files to process: ${result.filesToProcess.length}`);
          console.log(`  Estimated output files: ${result.estimatedFiles}`);
          result.filesToProcess.forEach((file: string) => console.log(`    - ${file}`));
        } else {
          console.log(`Documentation generated successfully!`);
          console.log(`  Processed ${result.processedFiles} files`);
          console.log(`  Generated ${result.generatedFiles} documentation files`);
          console.log(`  Output directory: ${options.output}`);
          
          if (result.errors.length > 0) {
            console.log(`  Warnings/Errors: ${result.errors.length}`);
            result.errors.forEach((error: string) => console.log(`    - ${error}`));
          }
        }
      } catch (error: any) {
        console.error('Error:', error);
        process.exit(1);
      }
    });

  program
    .command('parse-list-languages')
    .description('List all supported parser languages')
    .action(() => {
      const languages = parseService.getSupportedLanguages();
      console.log('Supported languages:');
      languages.forEach(lang => {
        console.log(`  ${lang.name}: ${lang.description}`);
        console.log(`    Extensions: ${lang.extensions.join(', ')}`);
        console.log();
      });
    });

  program
    .command('parse-validate')
    .description('Validate configuration and source files')
    .requiredOption('-i, --input <path>', 'Input directory to validate')
    .option('-c, --config <config>', 'Configuration file to validate')
    .action(async (options) => {
      if (!existsSync(options.input)) {
        console.error(`Error: Input directory '${options.input}' does not exist`);
        process.exit(1);
      }

      try {
        const validation = await parseService.validateConfiguration({
          inputPath: resolve(options.input),
          configPath: options.config ? resolve(options.config) : undefined
        });

        console.log('Validation results:');
        console.log(`  Input directory: ${validation.inputValid ? '✓' : '✗'}`);
        console.log(`  Configuration: ${validation.configValid ? '✓' : '✗'}`);
        console.log(`  Supported files: ${validation.supportedFiles.length}`);
        
        if (validation.unsupportedFiles.length > 0) {
          console.log(`  Unsupported files: ${validation.unsupportedFiles.length}`);
          validation.unsupportedFiles.forEach((file: string) => console.log(`    - ${file}`));
        }
        
        if (validation.warnings.length > 0) {
          console.log(`  Warnings: ${validation.warnings.length}`);
          validation.warnings.forEach((warning: string) => console.log(`    - ${warning}`));
        }
      } catch (error: any) {
        console.error('Error:', error);
        process.exit(1);
      }
    });
};