@loxia-labs/loxia-autopilot-one 1.0.1

package/src/analyzers/codeCloneDetector/detector.js

@@ -0,0 +1,203 @@
+/**
+ * Detects code clones across files
+ */
+export class CloneDetector {
+  constructor(config, parser) {
+    this.config = config;
+    this.parser = parser;
+  }
+
+  /**
+   * Find all clones in parsed files
+   * @param {Array} parsedFiles - Array of parsed file objects
+   * @returns {Array} Array of clone groups
+   */
+  detectClones(parsedFiles) {
+    console.log('Detecting clones...');
+    
+    const clones = [];
+    const allBlocks = [];
+    
+    // Collect all code blocks
+    for (const file of parsedFiles) {
+      allBlocks.push(...file.blocks);
+    }
+
+    console.log(`Analyzing ${allBlocks.length} code blocks`);
+
+    // Group blocks by hash for exact clones
+    const hashGroups = this.groupByHash(allBlocks);
+    
+    // Find exact clones
+    for (const [hash, blocks] of Object.entries(hashGroups)) {
+      if (blocks.length > 1) {
+        clones.push({
+          type: 'exact',
+          confidence: 1.0,
+          blocks,
+          tokenCount: blocks[0].tokens.length
+        });
+      }
+    }
+
+    // Find similar clones (more expensive)
+    const similarClones = this.findSimilarClones(allBlocks);
+    clones.push(...similarClones);
+
+    console.log(`Found ${clones.length} clone groups`);
+    return clones;
+  }
+
+  /**
+   * Group blocks by hash
+   */
+  groupByHash(blocks) {
+    const groups = {};
+    
+    for (const block of blocks) {
+      if (block.tokens.length < this.config.minTokens) continue;
+      
+      if (!groups[block.hash]) {
+        groups[block.hash] = [];
+      }
+      groups[block.hash].push(block);
+    }
+    
+    return groups;
+  }
+
+  /**
+   * Find similar (but not exact) clones
+   */
+  findSimilarClones(blocks) {
+    const similarClones = [];
+    const processed = new Set();
+
+    // Filter blocks that meet minimum size
+    const eligibleBlocks = blocks.filter(b => 
+      b.tokens.length >= this.config.minTokens
+    );
+
+    for (let i = 0; i < eligibleBlocks.length; i++) {
+      const block1 = eligibleBlocks[i];
+      const cloneGroup = [block1];
+      
+      if (processed.has(block1.id)) continue;
+
+      for (let j = i + 1; j < eligibleBlocks.length; j++) {
+        const block2 = eligibleBlocks[j];
+        
+        if (processed.has(block2.id)) continue;
+        
+        // Skip if already exact match
+        if (block1.hash === block2.hash) continue;
+
+        // Calculate similarity
+        const similarity = this.calculateBlockSimilarity(block1, block2);
+        
+        if (similarity >= this.config.similarityThreshold) {
+          cloneGroup.push(block2);
+          processed.add(block2.id);
+        }
+      }
+
+      if (cloneGroup.length > 1) {
+        processed.add(block1.id);
+        
+        similarClones.push({
+          type: 'similar',
+          confidence: this.calculateGroupConfidence(cloneGroup),
+          blocks: cloneGroup,
+          tokenCount: Math.max(...cloneGroup.map(b => b.tokens.length))
+        });
+      }
+    }
+
+    return similarClones;
+  }
+
+  /**
+   * Calculate similarity between two blocks
+   */
+  calculateBlockSimilarity(block1, block2) {
+    const tokens1 = block1.tokens;
+    const tokens2 = block2.tokens;
+    
+    // Length similarity
+    const lengthRatio = Math.min(tokens1.length, tokens2.length) / 
+                       Math.max(tokens1.length, tokens2.length);
+    
+    if (lengthRatio < 0.7) return 0; // Too different in size
+    
+    // Token sequence similarity using longest common subsequence
+    const lcs = this.longestCommonSubsequence(tokens1, tokens2);
+    const lcsRatio = (2 * lcs) / (tokens1.length + tokens2.length);
+    
+    return lcsRatio;
+  }
+
+  /**
+   * Longest common subsequence length
+   */
+  longestCommonSubsequence(seq1, seq2) {
+    const m = seq1.length;
+    const n = seq2.length;
+    
+    // Use space-optimized version for large sequences
+    if (m * n > 100000) {
+      return this.approximateLCS(seq1, seq2);
+    }
+    
+    const dp = Array(m + 1).fill(0).map(() => Array(n + 1).fill(0));
+    
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (seq1[i - 1] === seq2[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1] + 1;
+        } else {
+          dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+        }
+      }
+    }
+    
+    return dp[m][n];
+  }
+
+  /**
+   * Approximate LCS for large sequences
+   */
+  approximateLCS(seq1, seq2) {
+    // Use windowed approach for efficiency
+    const windowSize = 100;
+    let commonTokens = 0;
+    
+    for (let i = 0; i < seq1.length; i += windowSize) {
+      const window1 = seq1.slice(i, i + windowSize);
+      const set2 = new Set(seq2.slice(Math.max(0, i - windowSize), i + windowSize * 2));
+      
+      commonTokens += window1.filter(t => set2.has(t)).length;
+    }
+    
+    return commonTokens;
+  }
+
+  /**
+   * Calculate confidence for a clone group
+   */
+  calculateGroupConfidence(blocks) {
+    if (blocks.length === 0) return 0;
+    
+    // Calculate average pairwise similarity
+    let totalSimilarity = 0;
+    let comparisons = 0;
+    
+    for (let i = 0; i < blocks.length; i++) {
+      for (let j = i + 1; j < blocks.length; j++) {
+        totalSimilarity += this.calculateBlockSimilarity(blocks[i], blocks[j]);
+        comparisons++;
+      }
+    }
+    
+    return comparisons > 0 ? totalSimilarity / comparisons : 0;
+  }
+}

package/src/analyzers/codeCloneDetector/index.js

@@ -0,0 +1,160 @@
+// import { Command } from 'commander'; // Not needed for programmatic use
+import fs from 'fs';
+import path from 'path';
+import { FileScanner } from './scanner.js';
+import { CodeParser } from './parser.js';
+import { CloneDetector } from './detector.js';
+import { RefactoringAnalyzer } from './analyzer.js';
+import { Reporter } from './reporter.js';
+
+/**
+ * Main clone detection orchestrator
+ */
+class CloneDetectionTool {
+  constructor(config) {
+    this.config = config;
+    this.scanner = new FileScanner(config);
+    this.parser = new CodeParser(config);
+    this.detector = new CloneDetector(config, this.parser);
+    this.analyzer = new RefactoringAnalyzer(config);
+    this.reporter = new Reporter();
+  }
+
+  /**
+   * Run the complete clone detection pipeline
+   */
+  async run(projectPath, outputPath) {
+    console.log('Starting Code Clone Detection...\n');
+    console.log(`Project: ${projectPath}`);
+    console.log(`Config: minTokens=${this.config.minTokens}, minLines=${this.config.minLines}\n`);
+    
+    try {
+      // Step 1: Scan files
+      console.log('[1/5] Scanning project files...');
+      const files = await this.scanner.scanProject(projectPath);
+      
+      if (files.length === 0) {
+        console.log('No files found to analyze.');
+        return null;
+      }
+
+      // Step 2: Parse and tokenize
+      console.log('[2/5] Parsing and tokenizing code...');
+      const parsedFiles = files.map(file => this.parser.parseFile(file));
+      
+      // Step 3: Detect clones
+      console.log('[3/5] Detecting code clones...');
+      const clones = this.detector.detectClones(parsedFiles);
+      
+      if (clones.length === 0) {
+        console.log('No significant clones detected.');
+        return this.reporter.generateReport([], parsedFiles);
+      }
+
+      // Step 4: Analyze and generate refactoring advice
+      console.log('[4/5] Analyzing clones and generating refactoring advice...');
+      const analyzedClones = this.analyzer.analyzeClones(clones);
+
+      // Step 5: Generate report
+      console.log('[5/5] Generating report...');
+      const report = this.reporter.generateReport(analyzedClones, parsedFiles);
+
+      // Save report
+      if (outputPath) {
+        this.reporter.saveReport(report, outputPath);
+      }
+
+      // Print summary
+      this.reporter.printSummary(report);
+
+      // Print AI summary
+      console.log('\n📋 AI Agent Summary:');
+      console.log(this.reporter.generateAISummary(report));
+      console.log();
+
+      return report;
+    } catch (error) {
+      console.error('\n❌ Error during clone detection:', error.message);
+      console.error(error.stack);
+      throw error;
+    }
+  }
+}
+
+/**
+ * CLI Interface (disabled for now)
+ */
+async function main() {
+  // CLI functionality disabled - use CloneDetectionTool programmatically
+  console.error('CLI not available in this version. Use CloneDetectionTool programmatically.');
+  process.exit(1);
+  // const program = new Command();
+
+  program
+    .name('code-clone-detector')
+    .description('AI-powered code clone detection and refactoring advisor')
+    .version('1.0.0')
+    .argument('<project-path>', 'Path to the project directory to analyze')
+    .option('-o, --output <path>', 'Output file path for JSON report', 'clone-report.json')
+    .option('-c, --config <path>', 'Path to config file', 'config.json')
+    .option('--min-tokens <number>', 'Minimum token count for clones', parseInt)
+    .option('--min-lines <number>', 'Minimum line count for clones', parseInt)
+    .action(async (projectPath, options) => {
+      try {
+        // Load config
+        let config;
+        const configPath = path.resolve(options.config);
+        
+        if (fs.existsSync(configPath)) {
+          config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+          console.log(`Loaded config from: ${configPath}`);
+        } else {
+          console.log('Using default configuration');
+          config = {
+            minTokens: 50,
+            minLines: 5,
+            include: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx'],
+            exclude: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+            similarityThreshold: 0.85,
+            maxFileSize: 500000
+          };
+        }
+
+        // Override with CLI options
+        if (options.minTokens) config.minTokens = options.minTokens;
+        if (options.minLines) config.minLines = options.minLines;
+
+        // Resolve paths
+        const absProjectPath = path.resolve(projectPath);
+        const absOutputPath = path.resolve(options.output);
+
+        if (!fs.existsSync(absProjectPath)) {
+          console.error(`Error: Project path does not exist: ${absProjectPath}`);
+          process.exit(1);
+        }
+
+        // Run detection
+        const tool = new CloneDetectionTool(config);
+        const report = await tool.run(absProjectPath, absOutputPath);
+
+        if (report) {
+          console.log(`✅ Analysis complete! Review the report at: ${absOutputPath}`);
+          process.exit(0);
+        } else {
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error('Fatal error:', error.message);
+        process.exit(1);
+      }
+    });
+
+  program.parse();
+}
+
+// Run CLI if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export { CloneDetectionTool };

package/src/analyzers/codeCloneDetector/parser.js

@@ -0,0 +1,199 @@
+import * as parser from '@babel/parser';
+import traverse from '@babel/traverse';
+import crypto from 'crypto';
+
+/**
+ * Parses and tokenizes source code
+ */
+export class CodeParser {
+  constructor(config) {
+    this.config = config;
+  }
+
+  /**
+   * Parse file and extract tokens
+   * @param {Object} file - File object with content
+   * @returns {Object} Parsed file with tokens and AST info
+   */
+  parseFile(file) {
+    const extension = file.extension;
+    
+    // Handle JavaScript/TypeScript files
+    if (['.js', '.jsx', '.ts', '.tsx', '.vue'].includes(extension)) {
+      return this.parseJavaScript(file);
+    }
+    
+    // Fallback to simple tokenization
+    return this.simpleTokenize(file);
+  }
+
+  /**
+   * Parse JavaScript/TypeScript with Babel
+   */
+  parseJavaScript(file) {
+    try {
+      const ast = parser.parse(file.content, {
+        sourceType: 'module',
+        plugins: [
+          'jsx',
+          'typescript',
+          'decorators-legacy',
+          'classProperties',
+          'optionalChaining',
+          'nullishCoalescingOperator'
+        ],
+        errorRecovery: true
+      });
+
+      const tokens = [];
+      const blocks = [];
+      let blockId = 0;
+
+      // Extract meaningful code blocks (functions, classes, etc.)
+      traverse.default(ast, {
+        FunctionDeclaration: (path) => this.extractBlock(path, file, blocks, tokens, blockId++),
+        FunctionExpression: (path) => this.extractBlock(path, file, blocks, tokens, blockId++),
+        ArrowFunctionExpression: (path) => this.extractBlock(path, file, blocks, tokens, blockId++),
+        ClassMethod: (path) => this.extractBlock(path, file, blocks, tokens, blockId++),
+        ClassDeclaration: (path) => this.extractBlock(path, file, blocks, tokens, blockId++),
+      });
+
+      // Also create a flat token sequence for the entire file
+      const fileTokens = this.extractTokenSequence(ast);
+
+      return {
+        ...file,
+        ast,
+        tokens: fileTokens,
+        blocks,
+        parsed: true
+      };
+    } catch (error) {
+      console.error(`Parse error in ${file.path}:`, error.message);
+      return this.simpleTokenize(file);
+    }
+  }
+
+  /**
+   * Extract a code block with token sequence
+   */
+  extractBlock(path, file, blocks, tokens, blockId) {
+    const node = path.node;
+    const loc = node.loc;
+    
+    if (!loc) return;
+
+    // Get the source code for this block
+    const lines = file.content.split('\n');
+    const blockCode = lines.slice(loc.start.line - 1, loc.end.line).join('\n');
+    
+    // Create token sequence for this block
+    const blockTokens = this.tokenizeCode(blockCode);
+    
+    if (blockTokens.length < this.config.minTokens) return;
+
+    blocks.push({
+      id: `${file.path}:block${blockId}`,
+      file: file.path,
+      startLine: loc.start.line,
+      endLine: loc.end.line,
+      code: blockCode,
+      tokens: blockTokens,
+      hash: this.hashTokens(blockTokens),
+      type: node.type
+    });
+  }
+
+  /**
+   * Extract token sequence from AST
+   */
+  extractTokenSequence(ast) {
+    const tokens = [];
+    
+    traverse.default(ast, {
+      enter(path) {
+        const node = path.node;
+        
+        // Normalize identifiers but keep structure
+        if (node.type === 'Identifier') {
+          tokens.push('IDENT');
+        } else if (node.type === 'Literal' || node.type === 'StringLiteral' || 
+                   node.type === 'NumericLiteral' || node.type === 'BooleanLiteral') {
+          tokens.push('LIT');
+        } else {
+          tokens.push(node.type);
+        }
+      }
+    });
+    
+    return tokens;
+  }
+
+  /**
+   * Simple tokenization for non-JS files
+   */
+  simpleTokenize(file) {
+    const tokens = this.tokenizeCode(file.content);
+    
+    return {
+      ...file,
+      tokens,
+      blocks: [{
+        id: `${file.path}:full`,
+        file: file.path,
+        startLine: 1,
+        endLine: file.content.split('\n').length,
+        code: file.content,
+        tokens,
+        hash: this.hashTokens(tokens),
+        type: 'File'
+      }],
+      parsed: false
+    };
+  }
+
+  /**
+   * Tokenize code string (language-agnostic)
+   */
+  tokenizeCode(code) {
+    // Remove comments and normalize
+    const cleaned = code
+      .replace(/\/\*[\s\S]*?\*\//g, '') // Block comments
+      .replace(/\/\/.*/g, '') // Line comments
+      .replace(/\s+/g, ' '); // Normalize whitespace
+
+    // Simple tokenization
+    const tokens = cleaned.match(/[a-zA-Z_$][a-zA-Z0-9_$]*|[{}()\[\];,.]|[+\-*/%=<>!&|]+|"[^"]*"|'[^']*'|`[^`]*`|\d+/g) || [];
+    
+    return tokens;
+  }
+
+  /**
+   * Create hash of token sequence
+   */
+  hashTokens(tokens) {
+    return crypto
+      .createHash('md5')
+      .update(tokens.join(','))
+      .digest('hex');
+  }
+
+  /**
+   * Calculate similarity between token sequences
+   */
+  calculateSimilarity(tokens1, tokens2) {
+    const len1 = tokens1.length;
+    const len2 = tokens2.length;
+    
+    if (len1 === 0 || len2 === 0) return 0;
+    
+    // Use Jaccard similarity for token sets
+    const set1 = new Set(tokens1);
+    const set2 = new Set(tokens2);
+    
+    const intersection = new Set([...set1].filter(x => set2.has(x)));
+    const union = new Set([...set1, ...set2]);
+    
+    return intersection.size / union.size;
+  }
+}

package/src/analyzers/codeCloneDetector/reporter.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+
+/**
+ * Formats and outputs clone detection results
+ */
+export class Reporter {
+  /**
+   * Generate comprehensive report
+   * @param {Array} clones - Analyzed clones with refactoring advice
+   * @param {Array} files - Parsed files
+   * @returns {Object} Report object
+   */
+  generateReport(clones, files) {
+    const summary = this.generateSummary(clones, files);
+    
+    return {
+      summary,
+      clones: clones.map(clone => this.formatClone(clone)),
+      metadata: {
+        generatedAt: new Date().toISOString(),
+        tool: 'code-clone-detector',
+        version: '1.0.0'
+      }
+    };
+  }
+
+  /**
+   * Generate summary statistics
+   */
+  generateSummary(clones, files) {
+    const totalFiles = files.length;
+    const totalClones = clones.length;
+    
+    // Calculate total duplicated lines
+    const totalDuplicatedLines = clones.reduce((sum, clone) => 
+      sum + clone.metrics.duplicatedLines, 0
+    );
+    
+    // Calculate total lines of code
+    const totalLines = files.reduce((sum, file) => 
+      sum + file.content.split('\n').length, 0
+    );
+    
+    const duplicationPercentage = totalLines > 0 
+      ? ((totalDuplicatedLines / totalLines) * 100).toFixed(2)
+      : 0;
+    
+    // Priority breakdown
+    const priorityCounts = {
+      high: clones.filter(c => c.refactoringAdvice.priority === 'high').length,
+      medium: clones.filter(c => c.refactoringAdvice.priority === 'medium').length,
+      low: clones.filter(c => c.refactoringAdvice.priority === 'low').length
+    };
+    
+    return {
+      totalFiles,
+      totalClones,
+      totalDuplicatedLines,
+      duplicationPercentage: parseFloat(duplicationPercentage),
+      priorityCounts,
+      topRefactoringOpportunities: clones.slice(0, 5).map(c => c.id)
+    };
+  }
+
+  /**
+   * Format clone for output
+   */
+  formatClone(clone) {
+    return {
+      id: clone.id,
+      type: clone.type,
+      confidence: clone.confidence,
+      instances: clone.instances,
+      metrics: clone.metrics,
+      refactoringAdvice: clone.refactoringAdvice
+    };
+  }
+
+  /**
+   * Save report to file
+   */
+  saveReport(report, outputPath) {
+    try {
+      fs.writeFileSync(outputPath, JSON.stringify(report, null, 2));
+      console.log(`\nReport saved to: ${outputPath}`);
+      return true;
+    } catch (error) {
+      console.error('Error saving report:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Print summary to console
+   */
+  printSummary(report) {
+    const { summary } = report;
+    
+    console.log('\n' + '='.repeat(60));
+    console.log('CODE CLONE DETECTION SUMMARY');
+    console.log('='.repeat(60));
+    console.log(`Total Files Analyzed: ${summary.totalFiles}`);
+    console.log(`Total Clone Groups Found: ${summary.totalClones}`);
+    console.log(`Total Duplicated Lines: ${summary.totalDuplicatedLines}`);
+    console.log(`Duplication Percentage: ${summary.duplicationPercentage}%`);
+    console.log('\nPriority Breakdown:');
+    console.log(`  High Priority: ${summary.priorityCounts.high}`);
+    console.log(`  Medium Priority: ${summary.priorityCounts.medium}`);
+    console.log(`  Low Priority: ${summary.priorityCounts.low}`);
+    
+    if (report.clones.length > 0) {
+      console.log('\n' + '-'.repeat(60));
+      console.log('TOP REFACTORING OPPORTUNITIES');
+      console.log('-'.repeat(60));
+      
+      report.clones.slice(0, 3).forEach((clone, idx) => {
+        console.log(`\n${idx + 1}. ${clone.id} [${clone.refactoringAdvice.priority.toUpperCase()} PRIORITY]`);
+        console.log(`   Type: ${clone.type} (${(clone.confidence * 100).toFixed(0)}% confidence)`);
+        console.log(`   Instances: ${clone.metrics.instanceCount} copies across ${clone.metrics.filesCovered} files`);
+        console.log(`   Size: ${clone.metrics.lineCount} lines, ${clone.metrics.tokenCount} tokens`);
+        console.log(`   Impact Score: ${clone.metrics.impactScore}`);
+        console.log(`   Strategy: ${clone.refactoringAdvice.strategy}`);
+        console.log(`   Suggested Name: ${clone.refactoringAdvice.suggestedName}`);
+        console.log(`   Reasoning: ${clone.refactoringAdvice.reasoning}`);
+      });
+    }
+    
+    console.log('\n' + '='.repeat(60));
+  }
+
+  /**
+   * Generate AI-friendly summary
+   */
+  generateAISummary(report) {
+    const topClone = report.clones[0];
+    
+    if (!topClone) {
+      return 'No significant code duplication found in the project.';
+    }
+    
+    let summary = `Found ${report.summary.totalClones} code clone groups with ${report.summary.duplicationPercentage}% duplication. `;
+    summary += `Top priority: ${topClone.refactoringAdvice.suggestedName} appears ${topClone.metrics.instanceCount} times. `;
+    summary += `Recommended action: ${topClone.refactoringAdvice.strategy}. `;
+    summary += topClone.refactoringAdvice.reasoning;
+    
+    return summary;
+  }
+}