onbuzz 4.9.13 → 4.10.0

package/src/tools/cloneDetectionTool.js

@@ -1,581 +1,576 @@
-/**
- * CloneDetectionTool - Detect duplicated code (code clones) for refactoring
- *
- * Purpose:
- * - Identify exact and similar code clones across the codebase
- * - Provide refactoring recommendations with priorities
- * - Help reduce technical debt and improve maintainability
- * - Support JavaScript, TypeScript, JSX, TSX, Vue files
- */
-
-import { BaseTool } from './baseTool.js';
-import TagParser from '../utilities/tagParser.js';
-import DirectoryAccessManager from '../utilities/directoryAccessManager.js';
-import path from 'path';
-
-import {
-  TOOL_STATUS,
-  SYSTEM_DEFAULTS
-} from '../utilities/constants.js';
-
-class CloneDetectionTool extends BaseTool {
-  constructor(config = {}, logger = null) {
-    super(config, logger);
-
-    // Tool metadata
-    this.requiresProject = true;
-    this.isAsync = true; // Run async to avoid blocking the event loop
-    this.timeout = config.timeout || 300000; // 5 minutes default (increased for large projects)
-    this.maxConcurrentOperations = config.maxConcurrentOperations || 1;
-
-    // Clone detection settings
-    this.defaultMinTokens = config.defaultMinTokens || 50;
-    this.defaultMinLines = config.defaultMinLines || 5;
-    this.defaultSimilarityThreshold = config.defaultSimilarityThreshold || 0.85;
-    this.maxFileSize = config.maxFileSize || 500000; // 500KB per file
-
-    // Directory access manager
-    this.directoryAccessManager = new DirectoryAccessManager(config, logger);
-
-    // Clone detector will be initialized lazily when needed
-    this.cloneDetector = null;
-  }
-
-  /**
-   * Get tool description for LLM consumption
-   * @returns {string} Tool description
-   */
-  getDescription() {
-    return `
-Code Clone Detection Tool: Find duplicated code for refactoring opportunities
-
-This tool identifies exact and similar code patterns (code clones) across your codebase to help reduce duplication, improve maintainability, and identify refactoring opportunities.
-
-WHAT IT DETECTS:
-- Exact Clones (Type 1): Identical code with different formatting/comments
-- Similar Clones (Type 2/3): Structurally similar code with minor variations
-
-SUPPORTED LANGUAGES:
-- JavaScript (.js, .jsx, .mjs, .cjs)
-- TypeScript (.ts, .tsx)
-- Vue (.vue)
-
-USAGE:
-\`\`\`json
-{
-  "toolId": "clonedetection",
-  "actions": [
-    {
-      "type": "detect-clones",
-      "directory": "src",
-      "minTokens": 50,
-      "minLines": 5,
-      "similarityThreshold": 0.85,
-      "priorityFilter": "high",
-      "maxResults": 10,
-      "outputMode": "summary"
-    }
-  ]
-}
-\`\`\`
-
-PARAMETERS:
-- directory: Directory to analyze (required)
-- minTokens: Minimum token count (default: 50, lower = more sensitive)
-- minLines: Minimum line count (default: 5)
-- similarityThreshold: 0-1 similarity threshold (default: 0.85)
-- priorityFilter: Filter by priority (high/medium/low, optional)
-- maxResults: Maximum number of clones to return (optional)
-- outputMode: summary|detailed|recommendations (default: detailed)
-
-EXAMPLES:
-
-1. Find all clones in project:
-\`\`\`json
-{
-  "toolId": "clonedetection",
-  "actions": [{ "type": "detect-clones", "directory": "." }]
-}
-\`\`\`
-
-2. High-priority refactoring opportunities only:
-\`\`\`json
-{
-  "toolId": "clonedetection",
-  "actions": [{ "type": "detect-clones", "directory": "src", "priorityFilter": "high", "maxResults": 10 }]
-}
-\`\`\`
-
-3. More sensitive detection (finds smaller clones):
-\`\`\`json
-{
-  "toolId": "clonedetection",
-  "actions": [{ "type": "detect-clones", "directory": ".", "minTokens": 30, "similarityThreshold": 0.80 }]
-}
-\`\`\`
-
-4. Quick overview:
-\`\`\`json
-{
-  "toolId": "clonedetection",
-  "actions": [{ "type": "detect-clones", "directory": ".", "outputMode": "summary" }]
-}
-\`\`\`
-
-OUTPUT FORMAT:
-Returns clone detection results with:
-- summary: Overall statistics (total clones, duplication %, priority breakdown)
-- clones: Array of detected clone groups with:
-  - id, type, confidence, instances, metrics
-  - refactoringAdvice: priority, strategy, suggestedName, reasoning, actionableSteps
-
-OUTPUT MODES:
-- summary: High-level overview only (duplication %, top 5 clones)
-- detailed: Full clone details with code snippets (default)
-- recommendations: Refactoring priorities with actionable steps
-
-LIMITATIONS:
-- Analyzes JavaScript/TypeScript family only
-- Maximum file size: ${Math.round(this.maxFileSize / 1024)}KB per file
-- Analysis timeout: ${this.timeout / 1000} seconds
-    `;
-  }
-
-  /**
-   * Parse parameters from tool command content
-   * @param {string} content - Raw tool command content
-   * @returns {Object} Parsed parameters
-   */
-  parseParameters(content) {
-    try {
-      const params = {};
-      const actions = [];
-
-      this.logger?.debug('CloneDetection tool parsing parameters', {
-        contentLength: content.length,
-        contentPreview: content.substring(0, 200)
-      });
-
-      // Extract self-closing <detect-clones> tags
-      const detectClonesPattern = /<detect-clones\s+(.+?)\/>/g;
-      let match;
-
-      while ((match = detectClonesPattern.exec(content)) !== null) {
-        const attributeString = match[1].trim();
-        const parser = new TagParser();
-        const attributes = parser.parseAttributes(attributeString);
-
-        const action = {
-          type: 'detect-clones',
-          ...attributes
-        };
-
-        // Normalize attribute names
-        if (action['min-tokens']) {
-          action.minTokens = parseInt(action['min-tokens'], 10);
-          delete action['min-tokens'];
-        }
-        if (action['min-lines']) {
-          action.minLines = parseInt(action['min-lines'], 10);
-          delete action['min-lines'];
-        }
-        if (action['similarity-threshold']) {
-          action.similarityThreshold = parseFloat(action['similarity-threshold']);
-          delete action['similarity-threshold'];
-        }
-        if (action['priority-filter']) {
-          action.priorityFilter = action['priority-filter'];
-          delete action['priority-filter'];
-        }
-        if (action['max-results']) {
-          action.maxResults = parseInt(action['max-results'], 10);
-          delete action['max-results'];
-        }
-        if (action['output-mode']) {
-          action.outputMode = action['output-mode'];
-          delete action['output-mode'];
-        }
-
-        actions.push(action);
-      }
-
-      params.actions = actions;
-      params.rawContent = content.trim();
-
-      this.logger?.debug('Parsed CloneDetection tool parameters', {
-        totalActions: actions.length,
-        actionTypes: actions.map(a => a.type)
-      });
-
-      return params;
-
-    } catch (error) {
-      throw new Error(`Failed to parse clone detection parameters: ${error.message}`);
-    }
-  }
-
-  /**
-   * Get required parameters
-   * @returns {Array<string>} Array of required parameter names
-   */
-  getRequiredParameters() {
-    return ['actions'];
-  }
-
-  /**
-   * Custom parameter validation
-   * @param {Object} params - Parameters to validate
-   * @returns {Object} Validation result
-   */
-  customValidateParameters(params) {
-    const errors = [];
-
-    if (!params.actions || !Array.isArray(params.actions) || params.actions.length === 0) {
-      errors.push('At least one action is required');
-    } else {
-      // Validate each action
-      for (const [index, action] of params.actions.entries()) {
-        if (!action.type) {
-          errors.push(`Action ${index + 1}: type is required`);
-          continue;
-        }
-
-        if (action.type === 'detect-clones') {
-          if (!action.directory) {
-            errors.push(`Action ${index + 1}: directory is required for detect-clones`);
-          }
-
-          // Validate numeric parameters
-          if (action.minTokens !== undefined && (action.minTokens < 10 || action.minTokens > 1000)) {
-            errors.push(`Action ${index + 1}: min-tokens must be between 10 and 1000`);
-          }
-
-          if (action.minLines !== undefined && (action.minLines < 1 || action.minLines > 100)) {
-            errors.push(`Action ${index + 1}: min-lines must be between 1 and 100`);
-          }
-
-          if (action.similarityThreshold !== undefined &&
-              (action.similarityThreshold < 0.5 || action.similarityThreshold > 1.0)) {
-            errors.push(`Action ${index + 1}: similarity-threshold must be between 0.5 and 1.0`);
-          }
-
-          // Validate enum parameters
-          if (action.priorityFilter && !['high', 'medium', 'low'].includes(action.priorityFilter)) {
-            errors.push(`Action ${index + 1}: priority-filter must be high, medium, or low`);
-          }
-
-          if (action.outputMode && !['summary', 'detailed', 'recommendations'].includes(action.outputMode)) {
-            errors.push(`Action ${index + 1}: output-mode must be summary, detailed, or recommendations`);
-          }
-        } else {
-          errors.push(`Action ${index + 1}: unknown action type: ${action.type}`);
-        }
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Execute tool with parsed parameters
-   * @param {Object} params - Parsed parameters
-   * @param {Object} context - Execution context
-   * @returns {Promise<Object>} Execution result
-   */
-  async execute(params, context) {
-    const { actions } = params;
-    const { projectDir, agentId, directoryAccess } = context;
-
-    // Get directory access configuration
-    const accessConfig = directoryAccess ||
-      this.directoryAccessManager.createDirectoryAccess({
-        workingDirectory: projectDir || process.cwd(),
-        writeEnabledDirectories: [],
-        readOnlyDirectories: [projectDir || process.cwd()],
-        restrictToProject: true
-      });
-
-    const workingDir = this.directoryAccessManager.getWorkingDirectory(accessConfig);
-    const results = [];
-
-    for (const action of actions) {
-      try {
-        if (action.type === 'detect-clones') {
-          const result = await this.detectClones(
-            action.directory,
-            workingDir,
-            accessConfig,
-            action
-          );
-          results.push(result);
-        } else {
-          throw new Error(`Unknown action type: ${action.type}`);
-        }
-
-      } catch (error) {
-        this.logger?.error('Clone detection action failed', {
-          action: action.type,
-          error: error.message
-        });
-
-        results.push({
-          directory: action.directory,
-          error: error.message,
-          success: false
-        });
-      }
-    }
-
-    return {
-      success: true,
-      results,
-      toolUsed: 'clonedetection'
-    };
-  }
-
-  /**
-   * Detect clones in directory
-   * @private
-   */
-  async detectClones(directory, workingDir, accessConfig, options = {}) {
-    const fullDir = path.isAbsolute(directory)
-      ? path.normalize(directory)
-      : path.resolve(workingDir, directory);
-
-    // Validate read access
-    const accessResult = this.directoryAccessManager.validateReadAccess(fullDir, accessConfig);
-    if (!accessResult.allowed) {
-      throw new Error(`Read access denied: ${accessResult.reason}`);
-    }
-
-    try {
-      // Get clone detector instance
-      const detector = await this.getCloneDetector();
-
-      // Prepare configuration
-      const config = {
-        minTokens: options.minTokens || this.defaultMinTokens,
-        minLines: options.minLines || this.defaultMinLines,
-        similarityThreshold: options.similarityThreshold || this.defaultSimilarityThreshold,
-        include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs', '**/*.ts', '**/*.tsx', '**/*.vue'],
-        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.js', '**/*.spec.js'],
-        maxFileSize: this.maxFileSize
-      };
-
-      this.logger?.info('Starting clone detection', {
-        directory: fullDir,
-        config
-      });
-
-      // Run clone detection (without output file)
-      const report = await detector.run(fullDir, null);
-
-      if (!report) {
-        return {
-          directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
-          fullPath: fullDir,
-          success: true,
-          summary: {
-            totalFiles: 0,
-            totalClones: 0,
-            duplicationPercentage: 0
-          },
-          clones: [],
-          message: 'No files found or no clones detected'
-        };
-      }
-
-      // Apply filters
-      let filteredClones = report.clones;
-
-      // Filter by priority
-      if (options.priorityFilter) {
-        filteredClones = filteredClones.filter(
-          clone => clone.refactoringAdvice.priority === options.priorityFilter
-        );
-      }
-
-      // Limit results
-      if (options.maxResults) {
-        filteredClones = filteredClones.slice(0, options.maxResults);
-      }
-
-      // Format output based on mode
-      const outputMode = options.outputMode || 'detailed';
-
-      if (outputMode === 'summary') {
-        return this.formatSummaryOutput(report, filteredClones, fullDir, accessConfig);
-      } else if (outputMode === 'recommendations') {
-        return this.formatRecommendationsOutput(report, filteredClones, fullDir, accessConfig);
-      } else {
-        return this.formatDetailedOutput(report, filteredClones, fullDir, accessConfig);
-      }
-
-    } catch (error) {
-      throw new Error(`Failed to detect clones in ${directory}: ${error.message}`);
-    }
-  }
-
-  /**
-   * Format summary output
-   * @private
-   */
-  formatSummaryOutput(report, clones, fullDir, accessConfig) {
-    return {
-      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
-      fullPath: fullDir,
-      success: true,
-      outputMode: 'summary',
-      summary: {
-        totalFiles: report.summary.totalFiles,
-        totalClones: report.summary.totalClones,
-        duplicatedLines: report.summary.totalDuplicatedLines,
-        duplicationPercentage: report.summary.duplicationPercentage,
-        priorityCounts: report.summary.priorityCounts,
-        topClones: clones.slice(0, 5).map(clone => ({
-          id: clone.id,
-          type: clone.type,
-          confidence: clone.confidence,
-          instances: clone.metrics.instanceCount,
-          lines: clone.metrics.lineCount,
-          priority: clone.refactoringAdvice.priority,
-          strategy: clone.refactoringAdvice.strategy,
-          locations: clone.instances.map(i => `${i.file}:${i.startLine}-${i.endLine}`)
-        }))
-      }
-    };
-  }
-
-  /**
-   * Format recommendations output
-   * @private
-   */
-  formatRecommendationsOutput(report, clones, fullDir, accessConfig) {
-    return {
-      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
-      fullPath: fullDir,
-      success: true,
-      outputMode: 'recommendations',
-      summary: {
-        totalFiles: report.summary.totalFiles,
-        totalClones: report.summary.totalClones,
-        duplicationPercentage: report.summary.duplicationPercentage
-      },
-      recommendations: clones.map(clone => ({
-        id: clone.id,
-        priority: clone.refactoringAdvice.priority,
-        strategy: clone.refactoringAdvice.strategy,
-        suggestedName: clone.refactoringAdvice.suggestedName,
-        reasoning: clone.refactoringAdvice.reasoning,
-        effort: clone.refactoringAdvice.estimatedEffort,
-        benefits: clone.refactoringAdvice.benefits,
-        steps: clone.refactoringAdvice.actionableSteps,
-        metrics: {
-          instances: clone.metrics.instanceCount,
-          lines: clone.metrics.lineCount,
-          files: clone.metrics.filesCovered,
-          impact: clone.metrics.impactScore
-        },
-        locations: clone.instances.map(i => ({
-          file: i.file,
-          startLine: i.startLine,
-          endLine: i.endLine
-        }))
-      }))
-    };
-  }
-
-  /**
-   * Format detailed output
-   * @private
-   */
-  formatDetailedOutput(report, clones, fullDir, accessConfig) {
-    return {
-      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
-      fullPath: fullDir,
-      success: true,
-      outputMode: 'detailed',
-      summary: report.summary,
-      clones: clones.map(clone => ({
-        ...clone,
-        // Truncate code snippets for agent readability
-        instances: clone.instances.map(instance => ({
-          ...instance,
-          code: instance.code.split('\n').slice(0, 10).join('\n') +
-                (instance.code.split('\n').length > 10 ? '\n... (truncated)' : '')
-        }))
-      }))
-    };
-  }
-
-  /**
-   * Get clone detector instance (lazy initialization)
-   * @private
-   */
-  async getCloneDetector() {
-    if (!this.cloneDetector) {
-      const { CloneDetectionTool } = await import('../analyzers/codeCloneDetector/index.js');
-
-      const config = {
-        minTokens: this.defaultMinTokens,
-        minLines: this.defaultMinLines,
-        similarityThreshold: this.defaultSimilarityThreshold,
-        include: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx', '**/*.vue'],
-        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**'],
-        maxFileSize: this.maxFileSize
-      };
-
-      this.cloneDetector = new CloneDetectionTool(config);
-      this.logger?.debug('Clone detector initialized', { config });
-    }
-
-    return this.cloneDetector;
-  }
-
-  /**
-   * Get supported actions for this tool
-   * @returns {Array<string>} Array of supported action names
-   */
-  getSupportedActions() {
-    return ['detect-clones'];
-  }
-
-  /**
-   * Get parameter schema for validation
-   * @returns {Object} Parameter schema
-   */
-  getParameterSchema() {
-    return {
-      type: 'object',
-      properties: {
-        actions: {
-          type: 'array',
-          minItems: 1,
-          items: {
-            type: 'object',
-            properties: {
-              type: {
-                type: 'string',
-                enum: this.getSupportedActions()
-              },
-              directory: { type: 'string' },
-              minTokens: { type: 'number', minimum: 10, maximum: 1000 },
-              minLines: { type: 'number', minimum: 1, maximum: 100 },
-              similarityThreshold: { type: 'number', minimum: 0.5, maximum: 1.0 },
-              priorityFilter: { type: 'string', enum: ['high', 'medium', 'low'] },
-              maxResults: { type: 'number', minimum: 1 },
-              outputMode: { type: 'string', enum: ['summary', 'detailed', 'recommendations'] }
-            },
-            required: ['type', 'directory']
-          }
-        }
-      },
-      required: ['actions']
-    };
-  }
-}
-
-export default CloneDetectionTool;
+/**
+ * CloneDetectionTool - Detect duplicated code (code clones) for refactoring
+ *
+ * Purpose:
+ * - Identify exact and similar code clones across the codebase
+ * - Provide refactoring recommendations with priorities
+ * - Help reduce technical debt and improve maintainability
+ * - Support JavaScript, TypeScript, JSX, TSX, Vue files
+ */
+
+import { BaseTool } from './baseTool.js';
+import TagParser from '../utilities/tagParser.js';
+import DirectoryAccessManager from '../utilities/directoryAccessManager.js';
+import path from 'path';
+
+class CloneDetectionTool extends BaseTool {
+  constructor(config = {}, logger = null) {
+    super(config, logger);
+
+    // Tool metadata
+    this.requiresProject = true;
+    this.isAsync = true; // Run async to avoid blocking the event loop
+    this.timeout = config.timeout || 300000; // 5 minutes default (increased for large projects)
+    this.maxConcurrentOperations = config.maxConcurrentOperations || 1;
+
+    // Clone detection settings
+    this.defaultMinTokens = config.defaultMinTokens || 50;
+    this.defaultMinLines = config.defaultMinLines || 5;
+    this.defaultSimilarityThreshold = config.defaultSimilarityThreshold || 0.85;
+    this.maxFileSize = config.maxFileSize || 500000; // 500KB per file
+
+    // Directory access manager
+    this.directoryAccessManager = new DirectoryAccessManager(config, logger);
+
+    // Clone detector will be initialized lazily when needed
+    this.cloneDetector = null;
+  }
+
+  /**
+   * Get tool description for LLM consumption
+   * @returns {string} Tool description
+   */
+  getDescription() {
+    return `
+Code Clone Detection Tool: Find duplicated code for refactoring opportunities
+
+This tool identifies exact and similar code patterns (code clones) across your codebase to help reduce duplication, improve maintainability, and identify refactoring opportunities.
+
+WHAT IT DETECTS:
+- Exact Clones (Type 1): Identical code with different formatting/comments
+- Similar Clones (Type 2/3): Structurally similar code with minor variations
+
+SUPPORTED LANGUAGES:
+- JavaScript (.js, .jsx, .mjs, .cjs)
+- TypeScript (.ts, .tsx)
+- Vue (.vue)
+
+USAGE:
+\`\`\`json
+{
+  "toolId": "clonedetection",
+  "actions": [
+    {
+      "type": "detect-clones",
+      "directory": "src",
+      "minTokens": 50,
+      "minLines": 5,
+      "similarityThreshold": 0.85,
+      "priorityFilter": "high",
+      "maxResults": 10,
+      "outputMode": "summary"
+    }
+  ]
+}
+\`\`\`
+
+PARAMETERS:
+- directory: Directory to analyze (required)
+- minTokens: Minimum token count (default: 50, lower = more sensitive)
+- minLines: Minimum line count (default: 5)
+- similarityThreshold: 0-1 similarity threshold (default: 0.85)
+- priorityFilter: Filter by priority (high/medium/low, optional)
+- maxResults: Maximum number of clones to return (optional)
+- outputMode: summary|detailed|recommendations (default: detailed)
+
+EXAMPLES:
+
+1. Find all clones in project:
+\`\`\`json
+{
+  "toolId": "clonedetection",
+  "actions": [{ "type": "detect-clones", "directory": "." }]
+}
+\`\`\`
+
+2. High-priority refactoring opportunities only:
+\`\`\`json
+{
+  "toolId": "clonedetection",
+  "actions": [{ "type": "detect-clones", "directory": "src", "priorityFilter": "high", "maxResults": 10 }]
+}
+\`\`\`
+
+3. More sensitive detection (finds smaller clones):
+\`\`\`json
+{
+  "toolId": "clonedetection",
+  "actions": [{ "type": "detect-clones", "directory": ".", "minTokens": 30, "similarityThreshold": 0.80 }]
+}
+\`\`\`
+
+4. Quick overview:
+\`\`\`json
+{
+  "toolId": "clonedetection",
+  "actions": [{ "type": "detect-clones", "directory": ".", "outputMode": "summary" }]
+}
+\`\`\`
+
+OUTPUT FORMAT:
+Returns clone detection results with:
+- summary: Overall statistics (total clones, duplication %, priority breakdown)
+- clones: Array of detected clone groups with:
+  - id, type, confidence, instances, metrics
+  - refactoringAdvice: priority, strategy, suggestedName, reasoning, actionableSteps
+
+OUTPUT MODES:
+- summary: High-level overview only (duplication %, top 5 clones)
+- detailed: Full clone details with code snippets (default)
+- recommendations: Refactoring priorities with actionable steps
+
+LIMITATIONS:
+- Analyzes JavaScript/TypeScript family only
+- Maximum file size: ${Math.round(this.maxFileSize / 1024)}KB per file
+- Analysis timeout: ${this.timeout / 1000} seconds
+    `;
+  }
+
+  /**
+   * Parse parameters from tool command content
+   * @param {string} content - Raw tool command content
+   * @returns {Object} Parsed parameters
+   */
+  parseParameters(content) {
+    try {
+      const params = {};
+      const actions = [];
+
+      this.logger?.debug('CloneDetection tool parsing parameters', {
+        contentLength: content.length,
+        contentPreview: content.substring(0, 200)
+      });
+
+      // Extract self-closing <detect-clones> tags
+      const detectClonesPattern = /<detect-clones\s+(.+?)\/>/g;
+      let match;
+
+      while ((match = detectClonesPattern.exec(content)) !== null) {
+        const attributeString = match[1].trim();
+        const parser = new TagParser();
+        const attributes = parser.parseAttributes(attributeString);
+
+        const action = {
+          type: 'detect-clones',
+          ...attributes
+        };
+
+        // Normalize attribute names
+        if (action['min-tokens']) {
+          action.minTokens = parseInt(action['min-tokens'], 10);
+          delete action['min-tokens'];
+        }
+        if (action['min-lines']) {
+          action.minLines = parseInt(action['min-lines'], 10);
+          delete action['min-lines'];
+        }
+        if (action['similarity-threshold']) {
+          action.similarityThreshold = parseFloat(action['similarity-threshold']);
+          delete action['similarity-threshold'];
+        }
+        if (action['priority-filter']) {
+          action.priorityFilter = action['priority-filter'];
+          delete action['priority-filter'];
+        }
+        if (action['max-results']) {
+          action.maxResults = parseInt(action['max-results'], 10);
+          delete action['max-results'];
+        }
+        if (action['output-mode']) {
+          action.outputMode = action['output-mode'];
+          delete action['output-mode'];
+        }
+
+        actions.push(action);
+      }
+
+      params.actions = actions;
+      params.rawContent = content.trim();
+
+      this.logger?.debug('Parsed CloneDetection tool parameters', {
+        totalActions: actions.length,
+        actionTypes: actions.map(a => a.type)
+      });
+
+      return params;
+
+    } catch (error) {
+      throw new Error(`Failed to parse clone detection parameters: ${error.message}`, { cause: error });
+    }
+  }
+
+  /**
+   * Get required parameters
+   * @returns {Array<string>} Array of required parameter names
+   */
+  getRequiredParameters() {
+    return ['actions'];
+  }
+
+  /**
+   * Custom parameter validation
+   * @param {Object} params - Parameters to validate
+   * @returns {Object} Validation result
+   */
+  customValidateParameters(params) {
+    const errors = [];
+
+    if (!params.actions || !Array.isArray(params.actions) || params.actions.length === 0) {
+      errors.push('At least one action is required');
+    } else {
+      // Validate each action
+      for (const [index, action] of params.actions.entries()) {
+        if (!action.type) {
+          errors.push(`Action ${index + 1}: type is required`);
+          continue;
+        }
+
+        if (action.type === 'detect-clones') {
+          if (!action.directory) {
+            errors.push(`Action ${index + 1}: directory is required for detect-clones`);
+          }
+
+          // Validate numeric parameters
+          if (action.minTokens !== undefined && (action.minTokens < 10 || action.minTokens > 1000)) {
+            errors.push(`Action ${index + 1}: min-tokens must be between 10 and 1000`);
+          }
+
+          if (action.minLines !== undefined && (action.minLines < 1 || action.minLines > 100)) {
+            errors.push(`Action ${index + 1}: min-lines must be between 1 and 100`);
+          }
+
+          if (action.similarityThreshold !== undefined &&
+              (action.similarityThreshold < 0.5 || action.similarityThreshold > 1.0)) {
+            errors.push(`Action ${index + 1}: similarity-threshold must be between 0.5 and 1.0`);
+          }
+
+          // Validate enum parameters
+          if (action.priorityFilter && !['high', 'medium', 'low'].includes(action.priorityFilter)) {
+            errors.push(`Action ${index + 1}: priority-filter must be high, medium, or low`);
+          }
+
+          if (action.outputMode && !['summary', 'detailed', 'recommendations'].includes(action.outputMode)) {
+            errors.push(`Action ${index + 1}: output-mode must be summary, detailed, or recommendations`);
+          }
+        } else {
+          errors.push(`Action ${index + 1}: unknown action type: ${action.type}`);
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Execute tool with parsed parameters
+   * @param {Object} params - Parsed parameters
+   * @param {Object} context - Execution context
+   * @returns {Promise<Object>} Execution result
+   */
+  async execute(params, context) {
+    const { actions } = params;
+    const { projectDir, directoryAccess } = context;
+
+    // Get directory access configuration
+    const accessConfig = directoryAccess ||
+      this.directoryAccessManager.createDirectoryAccess({
+        workingDirectory: projectDir || process.cwd(),
+        writeEnabledDirectories: [],
+        readOnlyDirectories: [projectDir || process.cwd()],
+        restrictToProject: true
+      });
+
+    const workingDir = this.directoryAccessManager.getWorkingDirectory(accessConfig);
+    const results = [];
+
+    for (const action of actions) {
+      try {
+        if (action.type === 'detect-clones') {
+          const result = await this.detectClones(
+            action.directory,
+            workingDir,
+            accessConfig,
+            action
+          );
+          results.push(result);
+        } else {
+          throw new Error(`Unknown action type: ${action.type}`);
+        }
+
+      } catch (error) {
+        this.logger?.error('Clone detection action failed', {
+          action: action.type,
+          error: error.message
+        });
+
+        results.push({
+          directory: action.directory,
+          error: error.message,
+          success: false
+        });
+      }
+    }
+
+    return {
+      success: true,
+      results,
+      toolUsed: 'clonedetection'
+    };
+  }
+
+  /**
+   * Detect clones in directory
+   * @private
+   */
+  async detectClones(directory, workingDir, accessConfig, options = {}) {
+    const fullDir = path.isAbsolute(directory)
+      ? path.normalize(directory)
+      : path.resolve(workingDir, directory);
+
+    // Validate read access
+    const accessResult = this.directoryAccessManager.validateReadAccess(fullDir, accessConfig);
+    if (!accessResult.allowed) {
+      throw new Error(`Read access denied: ${accessResult.reason}`);
+    }
+
+    try {
+      // Get clone detector instance
+      const detector = await this.getCloneDetector();
+
+      // Prepare configuration
+      const config = {
+        minTokens: options.minTokens || this.defaultMinTokens,
+        minLines: options.minLines || this.defaultMinLines,
+        similarityThreshold: options.similarityThreshold || this.defaultSimilarityThreshold,
+        include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.cjs', '**/*.ts', '**/*.tsx', '**/*.vue'],
+        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.js', '**/*.spec.js'],
+        maxFileSize: this.maxFileSize
+      };
+
+      this.logger?.info('Starting clone detection', {
+        directory: fullDir,
+        config
+      });
+
+      // Run clone detection (without output file)
+      const report = await detector.run(fullDir, null);
+
+      if (!report) {
+        return {
+          directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
+          fullPath: fullDir,
+          success: true,
+          summary: {
+            totalFiles: 0,
+            totalClones: 0,
+            duplicationPercentage: 0
+          },
+          clones: [],
+          message: 'No files found or no clones detected'
+        };
+      }
+
+      // Apply filters
+      let filteredClones = report.clones;
+
+      // Filter by priority
+      if (options.priorityFilter) {
+        filteredClones = filteredClones.filter(
+          clone => clone.refactoringAdvice.priority === options.priorityFilter
+        );
+      }
+
+      // Limit results
+      if (options.maxResults) {
+        filteredClones = filteredClones.slice(0, options.maxResults);
+      }
+
+      // Format output based on mode
+      const outputMode = options.outputMode || 'detailed';
+
+      if (outputMode === 'summary') {
+        return this.formatSummaryOutput(report, filteredClones, fullDir, accessConfig);
+      } else if (outputMode === 'recommendations') {
+        return this.formatRecommendationsOutput(report, filteredClones, fullDir, accessConfig);
+      } else {
+        return this.formatDetailedOutput(report, filteredClones, fullDir, accessConfig);
+      }
+
+    } catch (error) {
+      throw new Error(`Failed to detect clones in ${directory}: ${error.message}`, { cause: error });
+    }
+  }
+
+  /**
+   * Format summary output
+   * @private
+   */
+  formatSummaryOutput(report, clones, fullDir, accessConfig) {
+    return {
+      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
+      fullPath: fullDir,
+      success: true,
+      outputMode: 'summary',
+      summary: {
+        totalFiles: report.summary.totalFiles,
+        totalClones: report.summary.totalClones,
+        duplicatedLines: report.summary.totalDuplicatedLines,
+        duplicationPercentage: report.summary.duplicationPercentage,
+        priorityCounts: report.summary.priorityCounts,
+        topClones: clones.slice(0, 5).map(clone => ({
+          id: clone.id,
+          type: clone.type,
+          confidence: clone.confidence,
+          instances: clone.metrics.instanceCount,
+          lines: clone.metrics.lineCount,
+          priority: clone.refactoringAdvice.priority,
+          strategy: clone.refactoringAdvice.strategy,
+          locations: clone.instances.map(i => `${i.file}:${i.startLine}-${i.endLine}`)
+        }))
+      }
+    };
+  }
+
+  /**
+   * Format recommendations output
+   * @private
+   */
+  formatRecommendationsOutput(report, clones, fullDir, accessConfig) {
+    return {
+      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
+      fullPath: fullDir,
+      success: true,
+      outputMode: 'recommendations',
+      summary: {
+        totalFiles: report.summary.totalFiles,
+        totalClones: report.summary.totalClones,
+        duplicationPercentage: report.summary.duplicationPercentage
+      },
+      recommendations: clones.map(clone => ({
+        id: clone.id,
+        priority: clone.refactoringAdvice.priority,
+        strategy: clone.refactoringAdvice.strategy,
+        suggestedName: clone.refactoringAdvice.suggestedName,
+        reasoning: clone.refactoringAdvice.reasoning,
+        effort: clone.refactoringAdvice.estimatedEffort,
+        benefits: clone.refactoringAdvice.benefits,
+        steps: clone.refactoringAdvice.actionableSteps,
+        metrics: {
+          instances: clone.metrics.instanceCount,
+          lines: clone.metrics.lineCount,
+          files: clone.metrics.filesCovered,
+          impact: clone.metrics.impactScore
+        },
+        locations: clone.instances.map(i => ({
+          file: i.file,
+          startLine: i.startLine,
+          endLine: i.endLine
+        }))
+      }))
+    };
+  }
+
+  /**
+   * Format detailed output
+   * @private
+   */
+  formatDetailedOutput(report, clones, fullDir, accessConfig) {
+    return {
+      directory: this.directoryAccessManager.createRelativePath(fullDir, accessConfig),
+      fullPath: fullDir,
+      success: true,
+      outputMode: 'detailed',
+      summary: report.summary,
+      clones: clones.map(clone => ({
+        ...clone,
+        // Truncate code snippets for agent readability
+        instances: clone.instances.map(instance => ({
+          ...instance,
+          code: instance.code.split('\n').slice(0, 10).join('\n') +
+                (instance.code.split('\n').length > 10 ? '\n... (truncated)' : '')
+        }))
+      }))
+    };
+  }
+
+  /**
+   * Get clone detector instance (lazy initialization)
+   * @private
+   */
+  async getCloneDetector() {
+    if (!this.cloneDetector) {
+      const { CloneDetectionTool } = await import('../analyzers/codeCloneDetector/index.js');
+
+      const config = {
+        minTokens: this.defaultMinTokens,
+        minLines: this.defaultMinLines,
+        similarityThreshold: this.defaultSimilarityThreshold,
+        include: ['**/*.js', '**/*.jsx', '**/*.ts', '**/*.tsx', '**/*.vue'],
+        exclude: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+        maxFileSize: this.maxFileSize
+      };
+
+      this.cloneDetector = new CloneDetectionTool(config);
+      this.logger?.debug('Clone detector initialized', { config });
+    }
+
+    return this.cloneDetector;
+  }
+
+  /**
+   * Get supported actions for this tool
+   * @returns {Array<string>} Array of supported action names
+   */
+  getSupportedActions() {
+    return ['detect-clones'];
+  }
+
+  /**
+   * Get parameter schema for validation
+   * @returns {Object} Parameter schema
+   */
+  getParameterSchema() {
+    return {
+      type: 'object',
+      properties: {
+        actions: {
+          type: 'array',
+          minItems: 1,
+          items: {
+            type: 'object',
+            properties: {
+              type: {
+                type: 'string',
+                enum: this.getSupportedActions()
+              },
+              directory: { type: 'string' },
+              minTokens: { type: 'number', minimum: 10, maximum: 1000 },
+              minLines: { type: 'number', minimum: 1, maximum: 100 },
+              similarityThreshold: { type: 'number', minimum: 0.5, maximum: 1.0 },
+              priorityFilter: { type: 'string', enum: ['high', 'medium', 'low'] },
+              maxResults: { type: 'number', minimum: 1 },
+              outputMode: { type: 'string', enum: ['summary', 'detailed', 'recommendations'] }
+            },
+            required: ['type', 'directory']
+          }
+        }
+      },
+      required: ['actions']
+    };
+  }
+}
+
+export default CloneDetectionTool;