ctxman 3.0.0

package/lib/core/ContextBuilder.js

@@ -0,0 +1,325 @@
+/**
+ * ContextBuilder - Smart Context Generation Module
+ * v3.0.0 - Modular architecture
+ *
+ * Responsibilities:
+ * - Build optimized context for LLMs
+ * - Apply smart filtering strategies
+ * - Generate context in multiple formats
+ * - Support use-case templates
+ * - Optimize for target LLM models
+ */
+
+import { LLMDetector } from '../utils/llm-detector.js';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger('ContextBuilder');
+
+export class ContextBuilder {
+  constructor(options = {}) {
+    this.options = {
+      targetModel: null,
+      targetTokens: null,
+      useCase: 'custom',
+      includeTests: true,
+      includeDocumentation: true,
+      priorityStrategy: 'balanced', // balanced, changed-first, core-first
+      ...options
+    };
+  }
+
+  /**
+   * Build context from analysis results
+   * @param {AnalysisResult} analysisResult
+   * @returns {Context}
+   */
+  build(analysisResult) {
+    logger.info('Building context...');
+
+    const { files, stats } = analysisResult;
+
+    // Apply smart filtering if target tokens specified
+    let filteredFiles = files;
+    if (this.options.targetTokens) {
+      filteredFiles = this.applySmartFiltering(files, this.options.targetTokens);
+    }
+
+    // Build context structure
+    const context = {
+      metadata: this.buildMetadata(stats),
+      files: this.buildFileList(filteredFiles),
+      methods: this.options.methodLevel ? this.buildMethodList(filteredFiles) : null,
+      statistics: stats
+    };
+
+    // Optimize for target LLM if specified
+    if (this.options.targetModel) {
+      return this.optimizeForLLM(context);
+    }
+
+    return context;
+  }
+
+  /**
+   * Build context metadata
+   * @param {object} stats
+   * @returns {object}
+   */
+  buildMetadata(stats) {
+    return {
+      generatedAt: new Date().toISOString(),
+      totalFiles: stats.totalFiles,
+      totalTokens: stats.totalTokens,
+      totalSize: stats.totalSize,
+      targetModel: this.options.targetModel,
+      useCase: this.options.useCase,
+      configuration: {
+        includeTests: this.options.includeTests,
+        includeDocumentation: this.options.includeDocumentation,
+        methodLevel: this.options.methodLevel
+      }
+    };
+  }
+
+  /**
+   * Build file list structure
+   * @param {Array<FileAnalysis>} files
+   * @returns {object}
+   */
+  buildFileList(files) {
+    const filesByDirectory = {};
+
+    for (const file of files) {
+      const dirPath = file.relativePath.includes('/')
+        ? file.relativePath.substring(0, file.relativePath.lastIndexOf('/'))
+        : '/';
+
+      if (!filesByDirectory[dirPath]) {
+        filesByDirectory[dirPath] = [];
+      }
+
+      filesByDirectory[dirPath].push({
+        name: file.name,
+        path: file.relativePath,
+        tokens: file.tokens,
+        size: file.size,
+        language: file.language
+      });
+    }
+
+    return filesByDirectory;
+  }
+
+  /**
+   * Build method list structure
+   * @param {Array<FileAnalysis>} files
+   * @returns {object}
+   */
+  buildMethodList(files) {
+    const methods = {};
+
+    for (const file of files) {
+      if (file.methods && file.methods.length > 0) {
+        methods[file.relativePath] = file.methods.map(method => ({
+          name: method.name,
+          line: method.line,
+          tokens: method.tokens || 0,
+          type: method.type || 'function'
+        }));
+      }
+    }
+
+    return methods;
+  }
+
+  /**
+   * Apply smart filtering to fit target token budget
+   * @param {Array<FileAnalysis>} files
+   * @param {number} targetTokens
+   * @returns {Array<FileAnalysis>}
+   */
+  applySmartFiltering(files, targetTokens) {
+    logger.info(`Applying smart filtering: target ${targetTokens} tokens`);
+
+    // Calculate current total
+    const currentTotal = files.reduce((sum, f) => sum + f.tokens, 0);
+
+    if (currentTotal <= targetTokens) {
+      logger.info('All files fit within target');
+      return files;
+    }
+
+    // Apply priority strategy
+    const prioritized = this.prioritizeFiles(files);
+
+    // Select files until token budget reached
+    const selected = [];
+    let runningTotal = 0;
+
+    for (const file of prioritized) {
+      if (runningTotal + file.tokens <= targetTokens) {
+        selected.push(file);
+        runningTotal += file.tokens;
+      } else {
+        // Check if we can include part of the file
+        const remainingBudget = targetTokens - runningTotal;
+        if (remainingBudget > 1000) { // Minimum 1k tokens
+          logger.info(`Partial file inclusion: ${file.relativePath} (${remainingBudget} tokens)`);
+          // Note: Actual implementation would truncate file content
+          selected.push(file);
+        }
+        break;
+      }
+    }
+
+    logger.info(`Filtered ${files.length} → ${selected.length} files (${runningTotal} tokens)`);
+    return selected;
+  }
+
+  /**
+   * Prioritize files based on strategy
+   * @param {Array<FileAnalysis>} files
+   * @returns {Array<FileAnalysis>}
+   */
+  prioritizeFiles(files) {
+    const strategy = this.options.priorityStrategy;
+
+    switch (strategy) {
+      case 'changed-first':
+        // Prioritize recently changed files (requires git metadata)
+        return files.sort((a, b) => {
+          const aModified = a.modified || 0;
+          const bModified = b.modified || 0;
+          return bModified - aModified;
+        });
+
+      case 'core-first':
+        // Prioritize core application files (heuristic-based)
+        return files.sort((a, b) => {
+          const aCoreScore = this.calculateCoreScore(a);
+          const bCoreScore = this.calculateCoreScore(b);
+          return bCoreScore - aCoreScore;
+        });
+
+      case 'balanced':
+      default:
+        // Balance between size and importance
+        return files.sort((a, b) => {
+          const aScore = this.calculateBalancedScore(a);
+          const bScore = this.calculateBalancedScore(b);
+          return bScore - aScore;
+        });
+    }
+  }
+
+  /**
+   * Calculate core importance score (heuristic)
+   * @param {FileAnalysis} file
+   * @returns {number}
+   */
+  calculateCoreScore(file) {
+    let score = 0;
+
+    const path = file.relativePath.toLowerCase();
+
+    // High priority paths
+    if (path.includes('src/') || path.includes('lib/')) score += 10;
+    if (path.includes('core/') || path.includes('main')) score += 8;
+    if (path.includes('index.') || path.includes('app.')) score += 7;
+
+    // Medium priority
+    if (path.includes('utils/') || path.includes('helpers/')) score += 5;
+    if (path.includes('components/')) score += 4;
+
+    // Lower priority
+    if (path.includes('test')) score -= 5;
+    if (path.includes('docs/') || path.includes('examples/')) score -= 3;
+
+    return score;
+  }
+
+  /**
+   * Calculate balanced score
+   * @param {FileAnalysis} file
+   * @returns {number}
+   */
+  calculateBalancedScore(file) {
+    const coreScore = this.calculateCoreScore(file);
+    const sizeScore = Math.log(file.tokens + 1); // Logarithmic to avoid dominating
+    return coreScore + sizeScore;
+  }
+
+  /**
+   * Optimize context for target LLM
+   * @param {Context} context
+   * @returns {Context}
+   */
+  optimizeForLLM(context) {
+    const profile = LLMDetector.getProfile(this.options.targetModel);
+
+    logger.info(`Optimizing for ${profile.name} (${profile.contextWindow} tokens)`);
+
+    // Apply LLM-specific optimizations
+    const optimized = { ...context };
+
+    // Recommend format
+    optimized.metadata.recommendedFormat = profile.preferredFormat;
+
+    // Check if chunking needed
+    const totalTokens = context.statistics.totalTokens;
+    optimized.metadata.fitsInContext = totalTokens <= profile.maxRecommendedInput;
+    optimized.metadata.chunksNeeded = optimized.metadata.fitsInContext
+      ? 1
+      : Math.ceil(totalTokens / profile.maxRecommendedInput);
+
+    // Add LLM-specific metadata
+    optimized.metadata.targetLLM = {
+      name: profile.name,
+      vendor: profile.vendor,
+      contextWindow: profile.contextWindow,
+      recommendedInput: profile.maxRecommendedInput
+    };
+
+    return optimized;
+  }
+
+  /**
+   * Generate compact file paths (for TOON format)
+   * @param {Context} context
+   * @returns {object}
+   */
+  generateCompactPaths(context) {
+    const compact = {};
+
+    for (const [dir, files] of Object.entries(context.files)) {
+      const fileNames = files.map(f => f.name);
+      compact[dir] = fileNames;
+    }
+
+    return compact;
+  }
+
+  /**
+   * Get context summary
+   * @param {Context} context
+   * @returns {string}
+   */
+  getSummary(context) {
+    const meta = context.metadata;
+    const stats = context.statistics;
+
+    let summary = `Context Summary:\n`;
+    summary += `  Files: ${meta.totalFiles}\n`;
+    summary += `  Tokens: ${meta.totalTokens.toLocaleString()}\n`;
+    summary += `  Size: ${(meta.totalSize / 1024).toFixed(1)} KB\n`;
+
+    if (meta.targetLLM) {
+      summary += `  Target: ${meta.targetLLM.name}\n`;
+      summary += `  Fits in context: ${meta.fitsInContext ? 'Yes' : `No (${meta.chunksNeeded} chunks)`}\n`;
+    }
+
+    return summary;
+  }
+}
+
+export default ContextBuilder;

package/lib/core/Reporter.js

@@ -0,0 +1,270 @@
+/**
+ * Reporter - Report Generation Module
+ * v3.0.0 - Modular architecture
+ *
+ * Responsibilities:
+ * - Generate reports in multiple formats
+ * - Display statistics and summaries
+ * - Export to files or clipboard
+ * - Support custom report templates
+ */
+
+import fs from 'fs';
+import path from 'path';
+import FormatRegistry from '../formatters/format-registry.js';
+import ClipboardUtils from '../utils/clipboard-utils.js';
+import { getLogger } from '../utils/logger.js';
+
+const logger = getLogger('Reporter');
+
+export class Reporter {
+  constructor(options = {}) {
+    this.options = {
+      format: 'toon',
+      outputPath: null,
+      clipboard: false,
+      verbose: true,
+      ...options
+    };
+
+    this.formatRegistry = new FormatRegistry();
+  }
+
+  /**
+   * Generate and output report
+   * @param {Context} context
+   * @param {object} stats
+   */
+  async report(context, stats) {
+    logger.info('Generating report...');
+
+    // Console output
+    if (this.options.verbose) {
+      this.printConsoleReport(stats);
+    }
+
+    // File export
+    if (this.options.outputPath) {
+      await this.exportToFile(context, this.options.outputPath);
+    }
+
+    // Clipboard
+    if (this.options.clipboard) {
+      await this.exportToClipboard(context);
+    }
+  }
+
+  /**
+   * Print console report
+   * @param {object} stats
+   */
+  printConsoleReport(stats) {
+    console.log('\n📊 ANALYSIS RESULTS');
+    console.log('═'.repeat(60));
+    console.log();
+
+    // Summary
+    console.log('📁 FILES & TOKENS:');
+    console.log(`   Total Files: ${stats.totalFiles}`);
+    console.log(`   Total Tokens: ${stats.totalTokens.toLocaleString()}`);
+    console.log(`   Total Size: ${(stats.totalSize / 1024).toFixed(1)} KB`);
+    console.log(`   Avg Tokens/File: ${this.getAverageTokens(stats)}`);
+    console.log();
+
+    // Language distribution
+    if (Object.keys(stats.byLanguage).length > 0) {
+      console.log('🌍 LANGUAGE DISTRIBUTION:');
+      const languages = Object.entries(stats.byLanguage)
+        .sort((a, b) => b[1].tokens - a[1].tokens)
+        .slice(0, 5);
+
+      for (const [lang, langStats] of languages) {
+        const percentage = (langStats.tokens / stats.totalTokens * 100).toFixed(1);
+        const bar = '▓'.repeat(Math.round(percentage / 2));
+        console.log(`   ${lang.padEnd(15)} ${percentage.padStart(5)}%  ${bar}`);
+      }
+      console.log();
+    }
+
+    // Largest files
+    if (stats.largestFiles && stats.largestFiles.length > 0) {
+      console.log('🏆 LARGEST FILES (by tokens):');
+      for (let i = 0; i < Math.min(5, stats.largestFiles.length); i++) {
+        const file = stats.largestFiles[i];
+        const percentage = (file.tokens / stats.totalTokens * 100).toFixed(1);
+        console.log(`   ${(i + 1)}. ${file.path.padEnd(40)} ${file.tokens.toLocaleString().padStart(8)} tokens (${percentage}%)`);
+      }
+      console.log();
+    }
+
+    // Method stats
+    if (stats.totalMethods > 0) {
+      console.log('🔧 METHOD ANALYSIS:');
+      console.log(`   Total Methods: ${stats.totalMethods}`);
+      if (stats.includedMethods !== undefined) {
+        console.log(`   Included Methods: ${stats.includedMethods}`);
+        console.log(`   Filtered: ${stats.totalMethods - stats.includedMethods}`);
+      }
+      console.log();
+    }
+
+    // Performance stats
+    if (stats.analysisTime) {
+      console.log('⚡ PERFORMANCE:');
+      console.log(`   Analysis Time: ${stats.analysisTime}ms`);
+      if (stats.cacheHits !== undefined) {
+        const totalCache = stats.cacheHits + stats.cacheMisses;
+        const hitRate = totalCache > 0 ? (stats.cacheHits / totalCache * 100).toFixed(1) : 0;
+        console.log(`   Cache Hit Rate: ${hitRate}% (${stats.cacheHits}/${totalCache})`);
+      }
+      console.log();
+    }
+  }
+
+  /**
+   * Export context to file
+   * @param {Context} context
+   * @param {string} outputPath
+   */
+  async exportToFile(context, outputPath) {
+    try {
+      const format = this.detectFormatFromPath(outputPath);
+      const content = this.formatRegistry.encode(format, context);
+
+      fs.writeFileSync(outputPath, content, 'utf-8');
+
+      const size = (Buffer.byteLength(content, 'utf-8') / 1024).toFixed(1);
+      logger.info(`Exported to ${outputPath} (${size} KB, ${format} format)`);
+
+      console.log(`💾 Report saved: ${outputPath}`);
+      console.log(`   Format: ${format.toUpperCase()}`);
+      console.log(`   Size: ${size} KB`);
+
+    } catch (error) {
+      logger.error(`Failed to export to file: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Export context to clipboard
+   * @param {Context} context
+   */
+  async exportToClipboard(context) {
+    try {
+      const format = this.options.format || 'toon';
+      const content = this.formatRegistry.encode(format, context);
+
+      const success = ClipboardUtils.copy(content);
+
+      if (success) {
+        const size = (Buffer.byteLength(content, 'utf-8') / 1024).toFixed(1);
+        logger.info(`Copied to clipboard (${size} KB, ${format} format)`);
+
+        console.log(`📋 Context copied to clipboard!`);
+        console.log(`   Format: ${format.toUpperCase()}`);
+        console.log(`   Size: ${size} KB`);
+      } else {
+        logger.warn('Clipboard copy failed, falling back to file export');
+        const fallbackPath = path.join(process.cwd(), `context-${Date.now()}.${format}`);
+        await this.exportToFile(context, fallbackPath);
+      }
+
+    } catch (error) {
+      logger.error(`Failed to export to clipboard: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Detect output format from file path
+   * @param {string} outputPath
+   * @returns {string}
+   */
+  detectFormatFromPath(outputPath) {
+    const ext = path.extname(outputPath).toLowerCase();
+
+    const formatMap = {
+      '.toon': 'toon',
+      '.json': 'json',
+      '.yaml': 'yaml',
+      '.yml': 'yaml',
+      '.md': 'markdown',
+      '.csv': 'csv',
+      '.xml': 'xml',
+      '.txt': 'gitingest'
+    };
+
+    return formatMap[ext] || this.options.format || 'toon';
+  }
+
+  /**
+   * Get average tokens per file
+   * @param {object} stats
+   * @returns {string}
+   */
+  getAverageTokens(stats) {
+    if (stats.totalFiles === 0) return 'N/A';
+    const avg = Math.round(stats.totalTokens / stats.totalFiles);
+    return avg.toLocaleString();
+  }
+
+  /**
+   * Generate summary text
+   * @param {Context} context
+   * @returns {string}
+   */
+  generateSummary(context) {
+    const meta = context.metadata;
+    const stats = context.statistics;
+
+    let summary = 'Ctxman Analysis Summary\n';
+    summary += '='.repeat(50) + '\n\n';
+
+    summary += `Generated: ${new Date(meta.generatedAt).toLocaleString()}\n`;
+    summary += `Files: ${meta.totalFiles}\n`;
+    summary += `Tokens: ${meta.totalTokens.toLocaleString()}\n`;
+    summary += `Size: ${(meta.totalSize / 1024).toFixed(1)} KB\n\n`;
+
+    if (meta.targetLLM) {
+      summary += `Target LLM: ${meta.targetLLM.name}\n`;
+      summary += `Fits in context: ${meta.fitsInContext ? 'Yes' : 'No'}\n`;
+      if (!meta.fitsInContext) {
+        summary += `Chunks needed: ${meta.chunksNeeded}\n`;
+      }
+      summary += '\n';
+    }
+
+    summary += `Use Case: ${meta.useCase}\n`;
+    summary += `Method Analysis: ${meta.configuration.methodLevel ? 'Enabled' : 'Disabled'}\n`;
+
+    return summary;
+  }
+
+  /**
+   * Export in multiple formats
+   * @param {Context} context
+   * @param {Array<string>} formats
+   */
+  async exportMultiple(context, formats) {
+    const results = [];
+
+    for (const format of formats) {
+      const outputPath = path.join(
+        process.cwd(),
+        `context-${Date.now()}.${format}`
+      );
+
+      try {
+        await this.exportToFile(context, outputPath);
+        results.push({ format, path: outputPath, success: true });
+      } catch (error) {
+        results.push({ format, error: error.message, success: false });
+      }
+    }
+
+    return results;
+  }
+}
+
+export default Reporter;