@goshenkata/dryscan-core 1.2.7 → 1.2.10

package/src/extractors/java.ts

@@ -1,376 +0,0 @@
-import crypto from "node:crypto";
-import Parser from "tree-sitter";
-import Java from "tree-sitter-java";
-import { LanguageExtractor } from "./LanguageExtractor";
-import { IndexUnit, IndexUnitType } from "../types";
-import { indexConfig } from "../config/indexConfig";
-import { DryConfig } from "../types";
-import { configStore } from "../config/configStore";
-import { BLOCK_HASH_ALGO } from "../const";
-
-export class JavaExtractor implements LanguageExtractor {
-  readonly id = "java";
-  readonly exts = [".java"];
-
-  private parser: Parser;
-  private readonly repoPath: string;
-  private config?: DryConfig;
-
-  constructor(repoPath: string) {
-    this.repoPath = repoPath;
-    this.parser = new Parser();
-    this.parser.setLanguage(Java);
-  }
-
-  supports(filePath: string): boolean {
-    const lower = filePath.toLowerCase();
-    return this.exts.some((ext) => lower.endsWith(ext));
-  }
-
-  async extractFromText(fileRelPath: string, source: string): Promise<IndexUnit[]> {
-    if (!source.trim()) return [];
-
-    this.config = await configStore.get(this.repoPath);
-
-    const tree = this.parser.parse(source);
-    const units: IndexUnit[] = [];
-
-    const visit = (node: Parser.SyntaxNode, currentClass?: IndexUnit) => {
-      if (this.isClassNode(node)) {
-        const className = this.getClassName(node, source) || "<anonymous>";
-        if (this.isDtoClass(node, source, className)) {
-          return;
-        }
-        const startLine = node.startPosition.row;
-        const endLine = node.endPosition.row;
-        const classLength = endLine - startLine;
-        const skipClass = this.shouldSkip(IndexUnitType.CLASS, className, classLength);
-        const classId = this.buildId(IndexUnitType.CLASS, className, startLine, endLine);
-        const code = this.stripComments(this.stripClassBody(node, source));
-        const classUnit: IndexUnit = {
-          id: classId,
-          name: className,
-          filePath: fileRelPath,
-          startLine,
-          endLine,
-          code,
-          unitType: IndexUnitType.CLASS,
-          children: [],
-        };
-        if (!skipClass) {
-          units.push(classUnit);
-        }
-
-        for (let i = 0; i < node.namedChildCount; i++) {
-          const child = node.namedChild(i);
-          if (child) visit(child, skipClass ? undefined : classUnit);
-        }
-        return;
-      }
-
-      if (this.isFunctionNode(node)) {
-        const fnUnit = this.buildFunctionUnit(node, source, fileRelPath, currentClass);
-        const fnLength = fnUnit.endLine - fnUnit.startLine;
-        const bodyNode = this.getFunctionBody(node);
-        const fnArity = this.getNodeArity(node);
-        const skipFunction = this.shouldSkip(IndexUnitType.FUNCTION, fnUnit.name, fnLength, fnArity);
-
-        if (skipFunction) {
-          return;
-        }
-
-        units.push(fnUnit);
-
-        if (bodyNode) {
-          const blocks = this.extractBlocks(bodyNode, source, fileRelPath, fnUnit);
-          units.push(...blocks);
-        }
-      }
-
-      for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child) visit(child, currentClass);
-      }
-    };
-
-    visit(tree.rootNode);
-
-    //remove duplicates if any
-    return this.removeDuplicates(units);
-  }
-
-  unitLabel(unit: IndexUnit): string | null {
-    if (unit.unitType === IndexUnitType.CLASS) return unit.filePath;
-    if (unit.unitType === IndexUnitType.FUNCTION) return this.canonicalFunctionSignature(unit);
-    if (unit.unitType === IndexUnitType.BLOCK) return this.normalizedBlockHash(unit);
-    return unit.name;
-  }
-
-  private isClassNode(node: Parser.SyntaxNode): boolean {
-    return node.type === "class_declaration";
-  }
-
-  private getClassName(node: Parser.SyntaxNode, source: string): string | null {
-    const nameNode = node.childForFieldName?.("name");
-    return nameNode ? source.slice(nameNode.startIndex, nameNode.endIndex) : null;
-  }
-
-  private isFunctionNode(node: Parser.SyntaxNode): boolean {
-    return node.type === "method_declaration" || node.type === "constructor_declaration";
-  }
-
-  private getFunctionName(node: Parser.SyntaxNode, source: string, parentClass?: IndexUnit): string | null {
-    const nameNode = node.childForFieldName?.("name");
-    const nameText = nameNode ? source.slice(nameNode.startIndex, nameNode.endIndex) : "<anonymous>";
-    return parentClass ? `${parentClass.name}.${nameText}` : nameText;
-  }
-
-  private getFunctionBody(node: Parser.SyntaxNode): Parser.SyntaxNode | null {
-    return node.childForFieldName?.("body") ?? null;
-  }
-
-  private isBlockNode(node: Parser.SyntaxNode): boolean {
-    return node.type === "block";
-  }
-
-  private getMethodBodiesForClass(node: Parser.SyntaxNode): Parser.SyntaxNode[] {
-    const bodies: Parser.SyntaxNode[] = [];
-    const classBody = node.children.find(child => child.type === "class_body");
-    if (!classBody) return bodies;
-    
-    for (let i = 0; i < classBody.namedChildCount; i++) {
-      const child = classBody.namedChild(i);
-      if (!child) continue;
-      if (child.type === "method_declaration" || child.type === "constructor_declaration") {
-        const body = child.childForFieldName?.("body");
-        if (body) bodies.push(body);
-      }
-    }
-    return bodies;
-  }
-
-  private canonicalFunctionSignature(unit: IndexUnit): string {
-    const arity = this.extractArity(unit.code);
-    return `${unit.name}(arity:${arity})`;
-  }
-
-  private normalizedBlockHash(unit: IndexUnit): string {
-    const normalized = this.normalizeCode(unit.code);
-    return crypto.createHash(BLOCK_HASH_ALGO).update(normalized).digest("hex");
-  }
-
-  private shouldSkip(unitType: IndexUnitType, name: string, lineCount: number, arity?: number): boolean {
-    if (!this.config) {
-      throw new Error("Config not loaded before skip evaluation");
-    }
-    const config = this.config;
-    const minLines = unitType === IndexUnitType.BLOCK
-      ? Math.max(indexConfig.blockMinLines, config.minBlockLines ?? 0)
-      : config.minLines;
-    const belowMin = minLines > 0 && lineCount < minLines;
-    const trivial = unitType === IndexUnitType.FUNCTION && this.isTrivialFunction(name, arity ?? 0);
-    return belowMin || trivial;
-  }
-
-  /**
-   * A function is trivial if it follows a simple accessor pattern:
-   * - getters/isers: name matches get[A-Z] or is[A-Z] with exactly 0 parameters
-   * - setters: name matches set[A-Z] with at most 1 parameter
-   * Methods like getUserById(Long id) have arity > 0 and are NOT trivial.
-   */
-  private isTrivialFunction(fullName: string, arity: number): boolean {
-    const simpleName = fullName.split(".").pop() || fullName;
-    const isGetter = /^(get|is)[A-Z]/.test(simpleName) && arity === 0;
-    const isSetter = /^set[A-Z]/.test(simpleName) && arity <= 1;
-    return isGetter || isSetter;
-  }
-
-  /** Counts the formal parameters of a method or constructor node. */
-  private getNodeArity(node: Parser.SyntaxNode): number {
-    const params = node.childForFieldName?.("parameters");
-    if (!params) return 0;
-    return params.namedChildren.filter(c => c.type === "formal_parameter" || c.type === "spread_parameter").length;
-  }
-
-  private isDtoClass(node: Parser.SyntaxNode, source: string, className: string): boolean {
-    const classBody = node.children.find((child) => child.type === "class_body");
-    if (!classBody) return false;
-
-    let hasField = false;
-
-    for (let i = 0; i < classBody.namedChildCount; i++) {
-      const child = classBody.namedChild(i);
-      if (!child) continue;
-
-      if (child.type === "field_declaration") {
-        hasField = true;
-        continue;
-      }
-
-      if (child.type.includes("annotation")) {
-        continue;
-      }
-
-      if (child.type === "method_declaration" || child.type === "constructor_declaration") {
-        const simpleName = this.getSimpleFunctionName(child, source);
-        const fullName = `${className}.${simpleName}`;
-        const arity = this.getNodeArity(child);
-        if (!this.isTrivialFunction(fullName, arity)) {
-          return false;
-        }
-        continue;
-      }
-
-      return false;
-    }
-
-    return hasField;
-  }
-
-  private getSimpleFunctionName(node: Parser.SyntaxNode, source: string): string {
-    const nameNode = node.childForFieldName?.("name");
-    return nameNode ? source.slice(nameNode.startIndex, nameNode.endIndex) : "<anonymous>";
-  }
-
-  private buildFunctionUnit(
-    node: Parser.SyntaxNode,
-    source: string,
-    file: string,
-    parentClass?: IndexUnit
-  ): IndexUnit {
-    const name = this.getFunctionName(node, source, parentClass) || "<anonymous>";
-    const startLine = node.startPosition.row;
-    const endLine = node.endPosition.row;
-    const id = this.buildId(IndexUnitType.FUNCTION, name, startLine, endLine);
-    const unit: IndexUnit = {
-      id,
-      name,
-      filePath: file,
-      startLine,
-      endLine,
-      children: [],
-      code: this.stripComments(source.slice(node.startIndex, node.endIndex)),
-      unitType: IndexUnitType.FUNCTION,
-      parentId: parentClass?.id,
-      parent: parentClass,
-    };
-    if (parentClass) {
-      parentClass.children = parentClass.children || [];
-      parentClass.children.push(unit);
-    }
-    return unit;
-  }
-
-  private extractBlocks(
-    bodyNode: Parser.SyntaxNode,
-    source: string,
-    file: string,
-    parentFunction: IndexUnit
-  ): IndexUnit[] {
-    const blocks: IndexUnit[] = [];
-
-    const visit = (n: Parser.SyntaxNode) => {
-      if (this.isBlockNode(n)) {
-        const startLine = n.startPosition.row;
-        const endLine = n.endPosition.row;
-        const lineCount = endLine - startLine;
-        if (this.shouldSkip(IndexUnitType.BLOCK, parentFunction.name, lineCount)) {
-          return;
-        }
-        if (lineCount >= indexConfig.blockMinLines) {
-          const id = this.buildId(IndexUnitType.BLOCK, parentFunction.name, startLine, endLine);
-          const blockUnit: IndexUnit = {
-            id,
-            name: parentFunction.name,
-            filePath: file,
-            startLine,
-            endLine,
-            code: this.stripComments(source.slice(n.startIndex, n.endIndex)),
-            unitType: IndexUnitType.BLOCK,
-            parentId: parentFunction.id,
-            parent: parentFunction,
-          };
-          const contextLength = this.config?.contextLength ?? 2048;
-          const splitBlocks = this.textSplitBlockIfOverContextLimit(blockUnit, contextLength);
-          parentFunction.children = parentFunction.children || [];
-          parentFunction.children.push(...splitBlocks);
-          blocks.push(...splitBlocks);
-        }
-      }
-
-      for (let i = 0; i < n.namedChildCount; i++) {
-        const child = n.namedChild(i);
-        if (child) visit(child);
-      }
-    };
-
-    visit(bodyNode);
-    return blocks;
-  }
-
-  private stripClassBody(node: Parser.SyntaxNode, source: string): string {
-    const classStart = node.startIndex;
-    let code = source.slice(classStart, node.endIndex);
-
-    const methodBodies: Array<{ start: number; end: number }> = [];
-    const candidates = this.getMethodBodiesForClass(node);
-
-    for (const body of candidates) {
-      methodBodies.push({ start: body.startIndex - classStart, end: body.endIndex - classStart });
-    }
-
-    methodBodies.sort((a, b) => b.start - a.start);
-    for (const body of methodBodies) {
-      code = code.slice(0, body.start) + " { }" + code.slice(body.end);
-    }
-
-    return code;
-  }
-
-  private buildId(type: IndexUnitType, name: string, startLine: number, endLine: number): string {
-    return `${type}:${name}:${startLine}-${endLine}`;
-  }
-
-  private extractArity(code: string): number {
-    const match = code.match(/^[^{]*?\(([^)]*)\)/s);
-    if (!match) return 0;
-    const params = match[1]
-      .split(",")
-      .map((p) => p.trim())
-      .filter(Boolean);
-    return params.length;
-  }
-
-  private normalizeCode(code: string): string {
-    const withoutBlockComments = code.replace(/\/\*[\s\S]*?\*\//g, "");
-    const withoutLineComments = withoutBlockComments.replace(/\/\/[^\n\r]*/g, "");
-    return withoutLineComments.replace(/\s+/g, "");
-  }
-
-  private stripComments(code: string): string {
-    const withoutBlockComments = code.replace(/\/\*[\s\S]*?\*\//g, (match) => match.replace(/[^\n\r]/g, ""));
-    return withoutBlockComments.replace(/\/\/[^\n\r]*/g, "");
-  }
-
-  private removeDuplicates(units: IndexUnit[]): IndexUnit[] | PromiseLike<IndexUnit[]> {
-    return Array.from(new Map(units.map(u => [u.id, u])).values());
-  }
-
-  /** Splits a block unit's code into chunks if it exceeds the context length limit. */
-  private textSplitBlockIfOverContextLimit(unit: IndexUnit, contextLength: number): IndexUnit[] {
-    if (unit.code.length <= contextLength) return [unit];
-
-    const chunks: IndexUnit[] = [];
-    let chunkIndex = 0;
-    for (let i = 0; i < unit.code.length; i += contextLength) {
-      chunks.push({
-        ...unit,
-        id: `${unit.id}:chunk${chunkIndex}`,
-        code: unit.code.slice(i, i + contextLength),
-      });
-      chunkIndex++;
-    }
-    return chunks;
-  }
-}
-

package/src/index.ts

@@ -1,9 +0,0 @@
-// Public surface: keep minimal API for consumers
-export { DryScan } from './DryScan';
-export { configStore } from './config/configStore';
-export {
-	DuplicateGroup,
-	DuplicationScore,
-	DuplicateReport,
-	DryConfig,
-} from './types';

package/src/services/DuplicateService.ts

@@ -1,257 +0,0 @@
-import debug from "debug";
-import shortUuid from "short-uuid";
-import { DryScanServiceDeps } from "./types";
-import { DuplicateAnalysisResult, DuplicateGroup, DuplicationScore, IndexUnit, IndexUnitType } from "../types";
-import { indexConfig } from "../config/indexConfig";
-import { DryConfig } from "../types";
-import { DuplicationCache } from "./DuplicationCache";
-
-const log = debug("DryScan:DuplicateService");
-
-export class DuplicateService {
-  private config?: DryConfig;
-  private readonly cache = DuplicationCache.getInstance();
-
-  constructor(private readonly deps: DryScanServiceDeps) {}
-
-  /**
-   * @param dirtyPaths - File paths changed since last run. When provided, only
-   *   dirty×all similarities are recomputed; clean×clean values are reused from
-   *   the existing matrix.  Pass undefined (or omit) for a full rebuild.
-   */
-  async findDuplicates(config: DryConfig, dirtyPaths?: string[]): Promise<DuplicateAnalysisResult> {
-    this.config = config;
-    const t0 = performance.now();
-    const allUnits = await this.deps.db.getAllUnits();
-    log("Starting duplicate analysis on %d units", allUnits.length);
-
-    if (allUnits.length < 2) {
-      return { duplicates: [], score: this.computeDuplicationScore([], allUnits) };
-    }
-
-    const thresholds = this.resolveThresholds(config.threshold);
-    const duplicates = await this.computeDuplicates(allUnits, thresholds, dirtyPaths);
-    const filtered = duplicates.filter((g) => !this.isGroupExcluded(g));
-    log("Found %d duplicate groups (%d excluded)", filtered.length, duplicates.length - filtered.length);
-
-    this.cache.update(filtered).catch((err) => log("Cache update failed: %O", err));
-
-    const score = this.computeDuplicationScore(filtered, allUnits);
-    log("findDuplicates completed in %dms", (performance.now() - t0).toFixed(2));
-    return { duplicates: filtered, score };
-  }
-
-  private resolveThresholds(functionThreshold?: number): { function: number; block: number; class: number } {
-    const d = indexConfig.thresholds;
-    const clamp = (v: number) => Math.min(1, Math.max(0, v));
-    const fn = clamp(functionThreshold ?? d.function);
-    return {
-      function: fn,
-      block: clamp(fn + d.block - d.function),
-      class: clamp(fn + d.class - d.function),
-    };
-  }
-
-  private async computeDuplicates(
-    units: IndexUnit[],
-    thresholds: { function: number; block: number; class: number },
-    dirtyPaths?: string[]
-  ): Promise<DuplicateGroup[]> {
-    this.cache.clearRunCaches();
-    await this.cache.buildEmbSimCache(units, dirtyPaths);
-
-    const duplicates: DuplicateGroup[] = [];
-    const t0 = performance.now();
-
-    for (const [type, typedUnits] of this.groupByType(units)) {
-      const threshold = this.getThreshold(type, thresholds);
-      log("Comparing %d %s units (threshold=%.3f)", typedUnits.length, type, threshold);
-
-      for (let i = 0; i < typedUnits.length; i++) {
-        for (let j = i + 1; j < typedUnits.length; j++) {
-          const left = typedUnits[i], right = typedUnits[j];
-          if (this.shouldSkipComparison(left, right)) continue;
-
-          // Always check the cache first — this allows pairs whose embeddings
-          // have since been cleared to still be reported using a prior score.
-          const cached = this.cache.get(left.id, right.id, left.filePath, right.filePath);
-          const hasEmbeddings = left.embedding?.length && right.embedding?.length;
-          const similarity = cached ?? (hasEmbeddings ? this.computeWeightedSimilarity(left, right, threshold) : 0);
-          if (similarity < threshold) continue;
-
-          const exclusionString = this.deps.pairing.pairKeyForUnits(left, right);
-          if (!exclusionString) continue;
-
-          duplicates.push({
-            id: `${left.id}::${right.id}`,
-            similarity,
-            shortId: shortUuid.generate(),
-            exclusionString,
-            left: this.toMember(left),
-            right: this.toMember(right),
-          });
-        }
-      }
-    }
-
-    log("computeDuplicates: %d duplicates in %dms", duplicates.length, (performance.now() - t0).toFixed(2));
-    return duplicates.sort((a, b) => b.similarity - a.similarity);
-  }
-
-  private isGroupExcluded(group: DuplicateGroup): boolean {
-    const config = this.config;
-    if (!config?.excludedPairs?.length) return false;
-    const key = this.deps.pairing.pairKeyForUnits(group.left, group.right);
-    if (!key) return false;
-    const actual = this.deps.pairing.parsePairKey(key);
-    if (!actual) return false;
-    return config.excludedPairs.some((entry) => {
-      const parsed = this.deps.pairing.parsePairKey(entry);
-      return parsed ? this.deps.pairing.pairKeyMatches(actual, parsed) : false;
-    });
-  }
-
-  private getThreshold(type: IndexUnitType, thresholds: { function: number; block: number; class: number }): number {
-    if (type === IndexUnitType.CLASS) return thresholds.class;
-    if (type === IndexUnitType.BLOCK) return thresholds.block;
-    return thresholds.function;
-  }
-
-  private computeWeightedSimilarity(left: IndexUnit, right: IndexUnit, threshold: number): number {
-    const selfSim = this.similarity(left, right);
-
-    //CLASS
-    if (left.unitType === IndexUnitType.CLASS) {
-      return selfSim * indexConfig.weights.class.self;
-    }
-
-    // FUNCTION
-    if (left.unitType === IndexUnitType.FUNCTION) {
-      const w = indexConfig.weights.function;
-      const hasPC = this.bothHaveParent(left, right, IndexUnitType.CLASS);
-      const total = w.self + (hasPC ? w.parentClass : 0);
-      // Early exit: even with perfect parent similarity, can't reach threshold.
-      if ((w.self * selfSim + (hasPC ? w.parentClass : 0)) / total < threshold) return 0;
-      return (w.self * selfSim + (hasPC ? w.parentClass * this.parentSimilarity(left, right, IndexUnitType.CLASS) : 0)) / total;
-    }
-
-    // BLOCK
-    const w = indexConfig.weights.block;
-    const hasPF = this.bothHaveParent(left, right, IndexUnitType.FUNCTION);
-    const hasPC = this.bothHaveParent(left, right, IndexUnitType.CLASS);
-    const total = w.self + (hasPF ? w.parentFunction : 0) + (hasPC ? w.parentClass : 0);
-    if ((w.self * selfSim + (hasPF ? w.parentFunction : 0) + (hasPC ? w.parentClass : 0)) / total < threshold) return 0;
-    return (
-      w.self * selfSim +
-      (hasPF ? w.parentFunction * this.parentSimilarity(left, right, IndexUnitType.FUNCTION) : 0) +
-      (hasPC ? w.parentClass * this.parentSimilarity(left, right, IndexUnitType.CLASS) : 0)
-    ) / total;
-  }
-
-  /** Groups all units by type for the comparison loop. Units without embeddings are included
-   * so that cache hits can still be returned for pairs whose embeddings were cleared. */
-  private groupByType(units: IndexUnit[]): Map<IndexUnitType, IndexUnit[]> {
-    const byType = new Map<IndexUnitType, IndexUnit[]>();
-    for (const unit of units) {
-      const list = byType.get(unit.unitType) ?? [];
-      list.push(unit);
-      byType.set(unit.unitType, list);
-    }
-    return byType;
-  }
-
-  private toMember(unit: IndexUnit): DuplicateGroup["left"] {
-    return {
-      id: unit.id,
-      name: unit.name,
-      filePath: unit.filePath,
-      startLine: unit.startLine,
-      endLine: unit.endLine,
-      code: unit.code,
-      unitType: unit.unitType,
-    };
-  }
-
-  private bothHaveParent(left: IndexUnit, right: IndexUnit, type: IndexUnitType): boolean {
-    return !!this.findParent(left, type) && !!this.findParent(right, type);
-  }
-
-  private parentSimilarity(left: IndexUnit, right: IndexUnit, type: IndexUnitType): number {
-    const lp = this.findParent(left, type), rp = this.findParent(right, type);
-    if (!lp || !rp) return 0;
-
-    const key = lp.id < rp.id ? `${lp.id}::${rp.id}` : `${rp.id}::${lp.id}`;
-    const cached = this.cache.getParentSim(key);
-    if (cached !== undefined) return cached;
-
-    const sim = this.similarity(lp, rp);
-    this.cache.setParentSim(key, sim);
-    return sim;
-  }
-
-  /** Resolves similarity via the pre-computed embedding matrix, falling back to best child match. */
-  private similarity(left: IndexUnit, right: IndexUnit): number {
-    return this.cache.getEmbSim(left.id, right.id) ?? this.childSimilarity(left, right);
-  }
-
-  private childSimilarity(left: IndexUnit, right: IndexUnit): number {
-    const lc = left.children ?? [], rc = right.children ?? [];
-    if (!lc.length || !rc.length) return 0;
-
-    let best = 0;
-    for (const l of lc) {
-      for (const r of rc) {
-        if (l.unitType !== r.unitType) continue;
-        const sim = this.similarity(l, r);
-        if (sim > best) best = sim;
-      }
-    }
-    return best;
-  }
-
-  private shouldSkipComparison(left: IndexUnit, right: IndexUnit): boolean {
-    if (left.unitType !== IndexUnitType.BLOCK || right.unitType !== IndexUnitType.BLOCK) return false;
-    if (left.filePath !== right.filePath) return false;
-    return (left.startLine <= right.startLine && left.endLine >= right.endLine)
-        || (right.startLine <= left.startLine && right.endLine >= left.endLine);
-  }
-
-  private findParent(unit: IndexUnit, type: IndexUnitType): IndexUnit | null {
-    let p = unit.parent;
-    while (p) {
-      if (p.unitType === type) return p;
-      p = p.parent;
-    }
-    return null;
-  }
-
-  private computeDuplicationScore(duplicates: DuplicateGroup[], allUnits: IndexUnit[]): DuplicationScore {
-    const totalLines = allUnits.reduce((sum, u) => sum + u.endLine - u.startLine + 1, 0);
-
-    if (!totalLines || !duplicates.length) {
-      return { score: 0, grade: "Excellent", totalLines, duplicateLines: 0, duplicateGroups: 0 };
-    }
-
-    const duplicateLines = duplicates.reduce((sum, g) => {
-      const avg = ((g.left.endLine - g.left.startLine + 1) + (g.right.endLine - g.right.startLine + 1)) / 2;
-      return sum + g.similarity * avg;
-    }, 0);
-
-    const score = (duplicateLines / totalLines) * 100;
-    return {
-      score,
-      grade: this.getScoreGrade(score),
-      totalLines,
-      duplicateLines: Math.round(duplicateLines),
-      duplicateGroups: duplicates.length,
-    };
-  }
-
-  private getScoreGrade(score: number): DuplicationScore["grade"] {
-    if (score < 5) return "Excellent";
-    if (score < 15) return "Good";
-    if (score < 30) return "Fair";
-    if (score < 50) return "Poor";
-    return "Critical";
-  }
-}