@juspay/yama 1.3.0 → 1.4.0

package/dist/utils/ContentSimilarityService.js

@@ -0,0 +1,215 @@
+/**
+ * Content Similarity Service for Semantic Deduplication
+ * Uses AI to compare violations with existing PR comments for semantic similarity
+ */
+import { logger } from "./Logger.js";
+/**
+ * Service for calculating semantic similarity between violations and PR comments
+ */
+export class ContentSimilarityService {
+    neurolink;
+    aiConfig;
+    constructor(aiConfig) {
+        this.aiConfig = aiConfig;
+    }
+    /**
+     * Calculate similarity scores between violations and comments in batches
+     */
+    async batchCalculateSimilarity(violations, comments, batchSize = 15) {
+        const startTime = Date.now();
+        logger.debug(`🔍 Starting semantic similarity analysis: ${violations.length} violations vs ${comments.length} comments`);
+        if (violations.length === 0 || comments.length === 0) {
+            logger.debug("⏭️ No violations or comments to compare, skipping similarity analysis");
+            return [];
+        }
+        // Prepare violation and comment content for AI analysis
+        const violationData = this.prepareViolationContent(violations);
+        const commentData = this.prepareCommentContent(comments);
+        logger.debug(`📝 Prepared ${violationData.length} violations and ${commentData.length} comments for analysis`);
+        // Process in batches to manage token limits
+        const allResults = [];
+        const totalBatches = Math.ceil(violations.length / batchSize);
+        for (let i = 0; i < violations.length; i += batchSize) {
+            const batchIndex = Math.floor(i / batchSize) + 1;
+            const violationBatch = violationData.slice(i, i + batchSize);
+            logger.debug(`🔄 Processing batch ${batchIndex}/${totalBatches} (${violationBatch.length} violations)`);
+            try {
+                const batchResults = await this.processSimilarityBatch(violationBatch, commentData);
+                allResults.push(...batchResults);
+                logger.debug(`✅ Batch ${batchIndex} completed: ${batchResults.length} similarity scores calculated`);
+                // Add delay between batches to avoid rate limiting
+                if (batchIndex < totalBatches) {
+                    await this.delay(1000);
+                }
+            }
+            catch (error) {
+                logger.error(`❌ Batch ${batchIndex} failed: ${error.message}`);
+                // Continue with next batch instead of failing entirely
+            }
+        }
+        const processingTime = Date.now() - startTime;
+        logger.success(`✅ Semantic similarity analysis completed: ${allResults.length} comparisons in ${processingTime}ms`);
+        return allResults;
+    }
+    /**
+     * Prepare violation content for AI analysis
+     */
+    prepareViolationContent(violations) {
+        return violations.map((violation, index) => ({
+            index,
+            id: `violation_${index}`,
+            content: this.extractViolationContent(violation),
+        }));
+    }
+    /**
+     * Prepare comment content for AI analysis
+     */
+    prepareCommentContent(comments) {
+        return comments.map((comment, index) => ({
+            index,
+            id: comment.id,
+            content: this.extractCommentContent(comment),
+        }));
+    }
+    /**
+     * Extract meaningful content from violation for comparison
+     */
+    extractViolationContent(violation) {
+        const parts = [
+            `Issue: ${violation.issue}`,
+            `Message: ${violation.message}`,
+            violation.file ? `File: ${violation.file}` : "",
+            violation.code_snippet ? `Code: ${violation.code_snippet}` : "",
+            `Severity: ${violation.severity}`,
+            `Category: ${violation.category}`,
+        ].filter(Boolean);
+        return parts.join(" | ");
+    }
+    /**
+     * Extract meaningful content from comment for comparison
+     */
+    extractCommentContent(comment) {
+        const parts = [
+            `Comment: ${comment.text}`,
+            comment.anchor?.filePath ? `File: ${comment.anchor.filePath}` : "",
+            `Author: ${comment.author.displayName || comment.author.name}`,
+        ].filter(Boolean);
+        return parts.join(" | ");
+    }
+    /**
+     * Process a single batch of violations against all comments
+     */
+    async processSimilarityBatch(violationBatch, commentData) {
+        const prompt = this.createSimilarityPrompt(violationBatch, commentData);
+        try {
+            // Initialize NeuroLink if not already done
+            if (!this.neurolink) {
+                const { NeuroLink } = await import("@juspay/neurolink");
+                this.neurolink = new NeuroLink();
+            }
+            // Use NeuroLink for AI analysis
+            const result = await this.neurolink.generate({
+                input: { text: prompt },
+                systemPrompt: "You are an expert code reviewer analyzing semantic similarity between violations and comments. Provide accurate similarity scores based on content analysis.",
+                provider: this.aiConfig.provider || "auto",
+                model: this.aiConfig.model || "best",
+                temperature: 0.1, // Low temperature for consistent similarity scoring
+                maxTokens: this.aiConfig.maxTokens || 4000,
+                timeout: "5m",
+                enableAnalytics: this.aiConfig.enableAnalytics || false,
+                enableEvaluation: false,
+            });
+            return this.parseSimilarityResponse(result.content, violationBatch, commentData);
+        }
+        catch (error) {
+            logger.error(`Failed to process similarity batch: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Create AI prompt for similarity analysis
+     */
+    createSimilarityPrompt(violations, comments) {
+        const violationList = violations
+            .map((v, i) => `${i + 1}. ${v.content}`)
+            .join("\n");
+        const commentList = comments
+            .map((c, i) => `${i + 1}. ${c.content.substring(0, 300)}${c.content.length > 300 ? "..." : ""}`)
+            .join("\n");
+        return `
+Analyze the semantic similarity between these code review violations and existing PR comments.
+
+NEW VIOLATIONS TO CHECK:
+${violationList}
+
+EXISTING PR COMMENTS:
+${commentList}
+
+For each violation, determine if it's semantically similar to any existing comment. Consider:
+- Same or similar issues being reported
+- Same file or code area being discussed
+- Similar concerns or suggestions
+- Related security, performance, or code quality topics
+
+Return a JSON array with similarity scores (0-100) for each violation-comment pair that has meaningful similarity (score >= 70).
+
+Format: [{"violation": 1, "comment": 2, "score": 85, "reasoning": "Both discuss the same security vulnerability in authentication"}, ...]
+
+Only include pairs with scores >= 70. If no meaningful similarities exist, return an empty array [].
+`.trim();
+    }
+    /**
+     * Parse AI response to extract similarity results
+     */
+    parseSimilarityResponse(response, violationBatch, commentData) {
+        try {
+            // Extract JSON from response
+            const jsonMatch = response.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                logger.debug("No JSON array found in AI response, assuming no similarities");
+                return [];
+            }
+            const similarities = JSON.parse(jsonMatch[0]);
+            const results = [];
+            for (const similarity of similarities) {
+                const violationIndex = similarity.violation - 1; // Convert from 1-based to 0-based
+                const commentIndex = similarity.comment - 1;
+                if (violationIndex >= 0 &&
+                    violationIndex < violationBatch.length &&
+                    commentIndex >= 0 &&
+                    commentIndex < commentData.length) {
+                    const violation = violationBatch[violationIndex];
+                    const comment = commentData[commentIndex];
+                    results.push({
+                        violationIndex: violation.index,
+                        commentIndex: comment.index,
+                        violationId: violation.id,
+                        commentId: comment.id,
+                        similarityScore: similarity.score,
+                        reasoning: similarity.reasoning,
+                    });
+                }
+            }
+            logger.debug(`📊 Parsed ${results.length} similarity results from AI response`);
+            return results;
+        }
+        catch (error) {
+            logger.error(`Failed to parse similarity response: ${error.message}`);
+            logger.debug(`Raw response: ${response}`);
+            return [];
+        }
+    }
+    /**
+     * Simple delay utility for rate limiting
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+}
+/**
+ * Factory function to create ContentSimilarityService
+ */
+export function createContentSimilarityService(aiConfig) {
+    return new ContentSimilarityService(aiConfig);
+}
+//# sourceMappingURL=ContentSimilarityService.js.map

package/dist/utils/ExactDuplicateRemover.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Exact Duplicate Removal Utility for Multi-Instance Processing
+ * Handles deduplication of violations from multiple Neurolink SDK instances
+ */
+import { Violation, DeduplicationResult, InstanceResult, PRComment, CommentDeduplicationResult, AIProviderConfig } from "../types/index.js";
+/**
+ * Exact Duplicate Remover for Multi-Instance Results
+ * Implements multi-level deduplication strategy
+ */
+export declare class ExactDuplicateRemover {
+    /**
+     * Remove exact duplicates from multiple instance results
+     */
+    removeDuplicates(instanceResults: InstanceResult[]): DeduplicationResult;
+    /**
+     * Flatten violations from all instances with source tracking
+     */
+    private flattenViolationsWithSource;
+    /**
+     * Remove exact hash duplicates (Level 1)
+     */
+    private removeExactHashDuplicates;
+    /**
+     * Remove normalized duplicates (Level 2)
+     */
+    private removeNormalizedDuplicates;
+    /**
+     * Remove same file+line duplicates (Level 3)
+     */
+    private removeSameLineDuplicates;
+    /**
+     * Create hash for exact violation matching
+     */
+    private createViolationHash;
+    /**
+     * Create hash for normalized violation matching
+     */
+    private createNormalizedViolationHash;
+    /**
+     * Normalize code snippet for comparison
+     */
+    private normalizeCodeSnippet;
+    /**
+     * Normalize text for comparison
+     */
+    private normalizeText;
+    /**
+     * Resolve duplicate by severity (and potentially other factors)
+     */
+    private resolveDuplicateBySeverity;
+    /**
+     * Track which instance contributed how many violations
+     */
+    private trackContributions;
+    /**
+     * Remove source tracking information from violation
+     */
+    private stripSourceInfo;
+    /**
+     * Remove violations that duplicate existing PR comments using semantic similarity
+     * Uses AI-powered ContentSimilarityService for intelligent deduplication
+     */
+    removeAgainstExistingComments(newViolations: Violation[], existingComments: PRComment[], aiConfig: AIProviderConfig, similarityThreshold?: number): Promise<CommentDeduplicationResult>;
+    /**
+     * Get detailed deduplication statistics
+     */
+    getDeduplicationStats(result: DeduplicationResult): string;
+    /**
+     * Get detailed comment deduplication statistics
+     */
+    getCommentDeduplicationStats(result: CommentDeduplicationResult): string;
+}
+/**
+ * Factory function to create ExactDuplicateRemover
+ */
+export declare function createExactDuplicateRemover(): ExactDuplicateRemover;
+//# sourceMappingURL=ExactDuplicateRemover.d.ts.map

package/dist/utils/ExactDuplicateRemover.js

@@ -0,0 +1,361 @@
+/**
+ * Exact Duplicate Removal Utility for Multi-Instance Processing
+ * Handles deduplication of violations from multiple Neurolink SDK instances
+ */
+import { createHash } from "crypto";
+import { logger } from "./Logger.js";
+/**
+ * Exact Duplicate Remover for Multi-Instance Results
+ * Implements multi-level deduplication strategy
+ */
+export class ExactDuplicateRemover {
+    /**
+     * Remove exact duplicates from multiple instance results
+     */
+    removeDuplicates(instanceResults) {
+        const startTime = Date.now();
+        logger.debug("🔍 Starting exact duplicate removal process");
+        // Step 1: Flatten all violations with source tracking
+        const allViolations = this.flattenViolationsWithSource(instanceResults);
+        logger.debug(`📊 Total violations from all instances: ${allViolations.length}`);
+        // Step 2: Remove exact hash duplicates
+        const exactDuplicates = this.removeExactHashDuplicates(allViolations);
+        logger.debug(`🎯 Exact duplicates removed: ${exactDuplicates.removed}`);
+        // Step 3: Remove normalized duplicates
+        const normalizedDuplicates = this.removeNormalizedDuplicates(exactDuplicates.unique);
+        logger.debug(`📝 Normalized duplicates removed: ${normalizedDuplicates.removed}`);
+        // Step 4: Remove same file+line duplicates
+        const finalResult = this.removeSameLineDuplicates(normalizedDuplicates.unique);
+        logger.debug(`📍 Same-line duplicates removed: ${finalResult.removed}`);
+        // Step 5: Track contributions and create metrics
+        const instanceContributions = this.trackContributions(finalResult.unique);
+        const processingTime = Date.now() - startTime;
+        const metrics = {
+            totalViolationsInput: allViolations.length,
+            exactDuplicatesRemoved: exactDuplicates.removed,
+            normalizedDuplicatesRemoved: normalizedDuplicates.removed,
+            sameLineDuplicatesRemoved: finalResult.removed,
+            finalUniqueViolations: finalResult.unique.length,
+            deduplicationRate: ((allViolations.length - finalResult.unique.length) /
+                allViolations.length) *
+                100,
+            instanceContributions: Object.fromEntries(instanceContributions),
+            processingTimeMs: processingTime,
+        };
+        logger.success(`✅ Deduplication completed: ${allViolations.length} → ${finalResult.unique.length} violations ` +
+            `(${metrics.deduplicationRate.toFixed(1)}% reduction) in ${processingTime}ms`);
+        return {
+            uniqueViolations: finalResult.unique.map((v) => this.stripSourceInfo(v)),
+            duplicatesRemoved: {
+                exactDuplicates: exactDuplicates.removed,
+                normalizedDuplicates: normalizedDuplicates.removed,
+                sameLineDuplicates: finalResult.removed,
+            },
+            instanceContributions,
+            processingMetrics: metrics,
+        };
+    }
+    /**
+     * Flatten violations from all instances with source tracking
+     */
+    flattenViolationsWithSource(instanceResults) {
+        const allViolations = [];
+        for (const result of instanceResults) {
+            if (!result.success || !result.violations) {
+                logger.debug(`⚠️ Skipping failed instance: ${result.instanceName}`);
+                continue;
+            }
+            result.violations.forEach((violation, index) => {
+                allViolations.push({
+                    ...violation,
+                    source: result.instanceName,
+                    originalIndex: index,
+                });
+            });
+        }
+        return allViolations;
+    }
+    /**
+     * Remove exact hash duplicates (Level 1)
+     */
+    removeExactHashDuplicates(violations) {
+        const seenHashes = new Set();
+        const unique = [];
+        let removed = 0;
+        for (const violation of violations) {
+            const hash = this.createViolationHash(violation);
+            if (!seenHashes.has(hash)) {
+                seenHashes.add(hash);
+                unique.push(violation);
+            }
+            else {
+                removed++;
+                logger.debug(`🔄 Exact duplicate removed: ${violation.issue} (${violation.source})`);
+            }
+        }
+        return { unique, removed };
+    }
+    /**
+     * Remove normalized duplicates (Level 2)
+     */
+    removeNormalizedDuplicates(violations) {
+        const seenNormalizedHashes = new Set();
+        const unique = [];
+        let removed = 0;
+        for (const violation of violations) {
+            const normalizedHash = this.createNormalizedViolationHash(violation);
+            if (!seenNormalizedHashes.has(normalizedHash)) {
+                seenNormalizedHashes.add(normalizedHash);
+                unique.push(violation);
+            }
+            else {
+                removed++;
+                logger.debug(`📝 Normalized duplicate removed: ${violation.issue} (${violation.source})`);
+            }
+        }
+        return { unique, removed };
+    }
+    /**
+     * Remove same file+line duplicates (Level 3)
+     */
+    removeSameLineDuplicates(violations) {
+        const fileLineMap = new Map();
+        const uniqueMap = new Map();
+        let removed = 0;
+        for (const violation of violations) {
+            if (!violation.file || !violation.code_snippet) {
+                uniqueMap.set(`${violation.file}_${violation.originalIndex}`, violation);
+                continue;
+            }
+            const fileKey = violation.file;
+            const lineKey = this.normalizeCodeSnippet(violation.code_snippet);
+            const uniqueKey = `${violation.file}_${violation.originalIndex}`;
+            if (!fileLineMap.has(fileKey)) {
+                fileLineMap.set(fileKey, new Map());
+            }
+            const linesInFile = fileLineMap.get(fileKey);
+            if (linesInFile.has(lineKey)) {
+                // Duplicate found - resolve by severity and instance quality
+                const existing = linesInFile.get(lineKey);
+                const better = this.resolveDuplicateBySeverity([existing, violation]);
+                if (better === violation) {
+                    // Replace existing with current
+                    linesInFile.set(lineKey, violation);
+                    // Remove existing from unique map and add current
+                    const existingKey = `${existing.file}_${existing.originalIndex}`;
+                    uniqueMap.delete(existingKey);
+                    uniqueMap.set(uniqueKey, violation);
+                }
+                removed++;
+                logger.debug(`📍 Same-line duplicate resolved: ${violation.issue} (${violation.source})`);
+            }
+            else {
+                linesInFile.set(lineKey, violation);
+                uniqueMap.set(uniqueKey, violation);
+            }
+        }
+        return { unique: Array.from(uniqueMap.values()), removed };
+    }
+    /**
+     * Create hash for exact violation matching
+     */
+    createViolationHash(violation) {
+        const key = {
+            file: violation.file?.trim(),
+            code_snippet: violation.code_snippet?.trim(),
+            severity: violation.severity,
+            category: violation.category,
+            issue: violation.issue.trim(),
+            message: violation.message.trim(),
+        };
+        return createHash("sha256").update(JSON.stringify(key)).digest("hex");
+    }
+    /**
+     * Create hash for normalized violation matching
+     */
+    createNormalizedViolationHash(violation) {
+        const normalized = {
+            file: violation.file?.toLowerCase().trim(),
+            code_snippet: this.normalizeCodeSnippet(violation.code_snippet || ""),
+            severity: violation.severity,
+            category: violation.category,
+            issue: this.normalizeText(violation.issue),
+            message: this.normalizeText(violation.message),
+        };
+        return createHash("sha256")
+            .update(JSON.stringify(normalized))
+            .digest("hex");
+    }
+    /**
+     * Normalize code snippet for comparison
+     */
+    normalizeCodeSnippet(snippet) {
+        return snippet
+            .replace(/\s+/g, " ") // Normalize whitespace
+            .replace(/['"]/g, '"') // Normalize quotes
+            .replace(/;+$/, "") // Remove trailing semicolons
+            .replace(/[{}]/g, "") // Remove braces for comparison
+            .trim()
+            .toLowerCase();
+    }
+    /**
+     * Normalize text for comparison
+     */
+    normalizeText(text) {
+        return text
+            .toLowerCase()
+            .replace(/[^\w\s]/g, "") // Remove punctuation
+            .replace(/\s+/g, " ") // Normalize whitespace
+            .trim();
+    }
+    /**
+     * Resolve duplicate by severity (and potentially other factors)
+     */
+    resolveDuplicateBySeverity(duplicates) {
+        const severityOrder = {
+            CRITICAL: 4,
+            MAJOR: 3,
+            MINOR: 2,
+            SUGGESTION: 1,
+        };
+        return duplicates.reduce((best, current) => {
+            const bestScore = severityOrder[best.severity] || 0;
+            const currentScore = severityOrder[current.severity] || 0;
+            if (currentScore > bestScore) {
+                return current;
+            }
+            else if (currentScore === bestScore) {
+                // Same severity - could add more sophisticated logic here
+                // For now, prefer the first one (could be based on instance quality)
+                return best;
+            }
+            return best;
+        });
+    }
+    /**
+     * Track which instance contributed how many violations
+     */
+    trackContributions(violations) {
+        const contributions = new Map();
+        for (const violation of violations) {
+            const current = contributions.get(violation.source) || 0;
+            contributions.set(violation.source, current + 1);
+        }
+        return contributions;
+    }
+    /**
+     * Remove source tracking information from violation
+     */
+    stripSourceInfo(violation) {
+        const { source, originalIndex, ...cleanViolation } = violation;
+        return cleanViolation;
+    }
+    /**
+     * Remove violations that duplicate existing PR comments using semantic similarity
+     * Uses AI-powered ContentSimilarityService for intelligent deduplication
+     */
+    async removeAgainstExistingComments(newViolations, existingComments, aiConfig, similarityThreshold = 85) {
+        const startTime = Date.now();
+        logger.debug("🔍 Starting semantic comment deduplication process");
+        logger.debug(`📊 New violations: ${newViolations.length}, Existing comments: ${existingComments.length}`);
+        logger.debug(`🎯 Similarity threshold: ${similarityThreshold}%`);
+        if (newViolations.length === 0 || existingComments.length === 0) {
+            logger.debug("⏭️ No violations or comments to compare, skipping deduplication");
+            return {
+                uniqueViolations: newViolations,
+                duplicatesRemoved: 0,
+                semanticMatches: [],
+            };
+        }
+        try {
+            // Use ContentSimilarityService for semantic analysis
+            const { ContentSimilarityService } = await import("./ContentSimilarityService.js");
+            const similarityService = new ContentSimilarityService(aiConfig);
+            // Get similarity results
+            const similarityResults = await similarityService.batchCalculateSimilarity(newViolations, existingComments, 15);
+            // Filter violations based on similarity threshold
+            const duplicateViolationIndices = new Set();
+            const semanticMatches = [];
+            for (const result of similarityResults) {
+                if (result.similarityScore >= similarityThreshold) {
+                    duplicateViolationIndices.add(result.violationIndex);
+                    const violation = newViolations[result.violationIndex];
+                    const comment = existingComments[result.commentIndex];
+                    semanticMatches.push({
+                        violation: violation.issue,
+                        comment: `Comment ${comment.id}`,
+                        similarityScore: result.similarityScore,
+                        reasoning: result.reasoning,
+                    });
+                    logger.debug(`🎯 Semantic duplicate found: "${violation.issue}" matches comment ${comment.id} ` +
+                        `(${result.similarityScore}% similarity)`);
+                }
+            }
+            // Create final list of unique violations
+            const uniqueViolations = newViolations.filter((_, index) => !duplicateViolationIndices.has(index));
+            const processingTime = Date.now() - startTime;
+            const duplicatesRemoved = duplicateViolationIndices.size;
+            logger.success(`✅ Semantic deduplication completed: ${newViolations.length} → ${uniqueViolations.length} violations ` +
+                `(${duplicatesRemoved} duplicates removed) in ${processingTime}ms`);
+            return {
+                uniqueViolations,
+                duplicatesRemoved,
+                semanticMatches,
+            };
+        }
+        catch (error) {
+            logger.error(`❌ Semantic deduplication failed: ${error.message}`);
+            logger.warn("⚠️ Falling back to no deduplication - returning all violations");
+            // Graceful fallback: return all violations if AI analysis fails
+            return {
+                uniqueViolations: newViolations,
+                duplicatesRemoved: 0,
+                semanticMatches: [],
+            };
+        }
+    }
+    /**
+     * Get detailed deduplication statistics
+     */
+    getDeduplicationStats(result) {
+        const metrics = result.processingMetrics;
+        const contributions = Array.from(result.instanceContributions.entries())
+            .map(([instance, count]) => `${instance}: ${count}`)
+            .join(", ");
+        return `
+📊 Deduplication Statistics:
+• Input violations: ${metrics.totalViolationsInput}
+• Exact duplicates removed: ${metrics.exactDuplicatesRemoved}
+• Normalized duplicates removed: ${metrics.normalizedDuplicatesRemoved}
+• Same-line duplicates removed: ${metrics.sameLineDuplicatesRemoved}
+• Final unique violations: ${metrics.finalUniqueViolations}
+• Deduplication rate: ${metrics.deduplicationRate.toFixed(1)}%
+• Processing time: ${metrics.processingTimeMs}ms
+• Instance contributions: ${contributions}
+    `.trim();
+    }
+    /**
+     * Get detailed comment deduplication statistics
+     */
+    getCommentDeduplicationStats(result) {
+        const averageSimilarity = result.semanticMatches.length > 0
+            ? result.semanticMatches.reduce((sum, match) => sum + match.similarityScore, 0) / result.semanticMatches.length
+            : 0;
+        return `
+📊 Comment Deduplication Statistics:
+• Input violations: ${result.uniqueViolations.length + result.duplicatesRemoved}
+• Unique violations: ${result.uniqueViolations.length}
+• Duplicates removed: ${result.duplicatesRemoved}
+• Deduplication rate: ${((result.duplicatesRemoved / (result.uniqueViolations.length + result.duplicatesRemoved)) * 100).toFixed(1)}%
+• Semantic matches: ${result.semanticMatches.length}
+• Average similarity score: ${averageSimilarity.toFixed(1)}%
+    `.trim();
+    }
+}
+/**
+ * Factory function to create ExactDuplicateRemover
+ */
+export function createExactDuplicateRemover() {
+    return new ExactDuplicateRemover();
+}
+//# sourceMappingURL=ExactDuplicateRemover.js.map