dslop 1.3.1 → 1.4.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## v1.4.1
+
+[compare changes](https://github.com/turf-sports/dslop/compare/v1.4.0...v1.4.1)
+
+### 📖 Documentation
+
+- Add technical details and limitations ([3598291](https://github.com/turf-sports/dslop/commit/3598291))
+
+### ❤️ Contributors
+
+- Siddharth Sharma <sharmasiddharthcs@gmail.com>
+
+## v1.4.0
+
+[compare changes](https://github.com/turf-sports/dslop/compare/v1.3.1...v1.4.0)
+
+### 🚀 Enhancements
+
+- Improve duplicate detection accuracy for small blocks ([b009d47](https://github.com/turf-sports/dslop/commit/b009d47))
+
+### ❤️ Contributors
+
+- Siddharth Sharma <sharmasiddharthcs@gmail.com>
+
 ## v1.3.1
 
 [compare changes](https://github.com/turf-sports/dslop/compare/v1.3.0...v1.3.1)

package/README.md

@@ -34,6 +34,32 @@ dslop --all --cross-package  # cross-package dupes (monorepos)
 | `--cross-package` | only show dupes across packages |
 | `--json` | json output |
 
+## How it works
+
+**Block extraction:** Sliding window over source files. Extracts overlapping blocks at sizes 4, 6, 9, 13... lines. For blocks <10 lines, step=1 (every line). Larger blocks use step=blockSize/2.
+
+**Normalization:** Before hashing, code is normalized:
+- String literals → `"<STRING>"`
+- Numbers → `<NUMBER>`
+- Whitespace collapsed
+- Comments preserved (intentional - comments often indicate copy-paste)
+
+**Matching:** Normalized blocks are hashed. Exact hash matches = exact duplicates. For similar (non-exact) matches, uses character-level similarity on a sample of blocks per hash bucket.
+
+**Declaration detection** (`--all` mode): Regex-based extraction of types, interfaces, functions, classes. Compares by name similarity (Levenshtein + word overlap) and content similarity.
+
+**Changed-line filtering** (default mode): Parses `git diff` output to get exact line ranges. Only reports duplicates where your changed lines match code elsewhere.
+
+## Limitations
+
+- **Text-based, not AST:** Doesn't understand code structure. A reformatted function won't match the original. Two semantically identical functions with different variable names won't match.
+- **TypeScript/JavaScript focused:** Default extensions are ts/tsx/js/jsx. Works on any text but tuned for JS-like syntax.
+- **No cross-language:** Won't detect a Python function duplicated in TypeScript.
+- **Comments affect matching:** Intentional tradeoff. Copy-pasted code often includes comments.
+- **Declaration detection is regex:** Can miss edge cases like multi-line generics or decorators.
+- **Minimum 4 lines:** Shorter duplicates ignored to reduce noise. Use `-m 2` for stricter.
+- **Memory:** Loads all blocks in memory. Very large codebases (>1M lines) may be slow.
+
 ## License
 
 MIT

package/dist/index.js

@@ -359,6 +359,249 @@ var COLORS = {
 var MAX_FILE_SIZE2 = 1024 * 1024;
 var MAX_BLOCKS_FOR_SIMILARITY = 1e4;
 
+// src/normalizer.ts
+function normalizeCode(code) {
+  let normalized = code;
+  normalized = normalized.replace(/"(?:[^"\\]|\\.)*"/g, `"${STRING_PLACEHOLDER}"`);
+  normalized = normalized.replace(/'(?:[^'\\]|\\.)*'/g, `'${STRING_PLACEHOLDER}'`);
+  normalized = normalized.replace(/`(?:[^`\\]|\\.)*`/g, `\`${TEMPLATE_PLACEHOLDER}\``);
+  normalized = normalized.replace(/\b\d+\.?\d*\b/g, NUMBER_PLACEHOLDER);
+  normalized = normalized.replace(/#[0-9a-fA-F]{3,8}\b/g, COLOR_PLACEHOLDER);
+  normalized = normalized.replace(/[ \t]+/g, " ");
+  normalized = normalized.split(`
+`).map((line) => line.trimEnd()).join(`
+`);
+  normalized = normalized.replace(/\n\s*\n/g, `
+`);
+  return normalized;
+}
+
+// src/declarations.ts
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(36);
+}
+var DECLARATION_PATTERNS = [
+  { type: "type", regex: /^(export\s+)?type\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*=/m, nameGroup: 2 },
+  { type: "interface", regex: /^(export\s+)?interface\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*(?:extends\s+[^{]+)?\{/m, nameGroup: 2 },
+  { type: "class", regex: /^(export\s+)?(?:abstract\s+)?class\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*(?:extends\s+\w+)?\s*(?:implements\s+[^{]+)?\{/m, nameGroup: 2 },
+  { type: "enum", regex: /^(export\s+)?(?:const\s+)?enum\s+([A-Z]\w*)\s*\{/m, nameGroup: 2 },
+  { type: "function", regex: /^(export\s+)?(?:async\s+)?function\s+([a-zA-Z]\w*)\s*(?:<[^>]*>)?\s*\(/m, nameGroup: 2 },
+  { type: "function", regex: /^(export\s+)?const\s+([a-zA-Z]\w*)\s*(?::\s*[^=]+)?\s*=\s*(?:async\s*)?\(/m, nameGroup: 2 },
+  { type: "function", regex: /^(export\s+)?const\s+([a-zA-Z]\w*)\s*=\s*<[^>]+>\s*\(/m, nameGroup: 2 },
+  { type: "const", regex: /^(export\s+)?const\s+([A-Z][A-Z_0-9]*)\s*(?::\s*[^=]+)?\s*=/m, nameGroup: 2 }
+];
+function findMatchingBrace(content, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  let inTemplate = false;
+  for (let i = startIndex;i < content.length; i++) {
+    const char = content[i];
+    const prevChar = content[i - 1];
+    if (inString) {
+      if (char === stringChar && prevChar !== "\\") {
+        inString = false;
+      }
+      continue;
+    }
+    if (inTemplate) {
+      if (char === "`" && prevChar !== "\\") {
+        inTemplate = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "`") {
+      inTemplate = true;
+      continue;
+    }
+    if (char === "{")
+      depth++;
+    if (char === "}") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return -1;
+}
+function findStatementEnd(content, startIndex) {
+  let depth = 0;
+  let inString = false;
+  let stringChar = "";
+  for (let i = startIndex;i < content.length; i++) {
+    const char = content[i];
+    const prevChar = content[i - 1];
+    if (inString) {
+      if (char === stringChar && prevChar !== "\\") {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      inString = true;
+      stringChar = char;
+      continue;
+    }
+    if (char === "(" || char === "{" || char === "[")
+      depth++;
+    if (char === ")" || char === "}" || char === "]")
+      depth--;
+    if (depth === 0 && (char === ";" || char === `
+`)) {
+      const remaining = content.slice(i + 1).trimStart();
+      if (!remaining.startsWith("|") && !remaining.startsWith("&")) {
+        return i;
+      }
+    }
+  }
+  return content.length - 1;
+}
+var QUICK_CHECK = /^(export\s+)?(type|interface|class|enum|const|function|async\s+function)\s+/;
+function extractDeclarations(content, filePath) {
+  const declarations = [];
+  const lines = content.split(`
+`);
+  let lineStart = 0;
+  for (let lineIndex = 0;lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    const trimmed = line.trimStart();
+    if (!QUICK_CHECK.test(trimmed)) {
+      lineStart += line.length + 1;
+      continue;
+    }
+    const remainingContent = content.slice(lineStart);
+    for (const pattern of DECLARATION_PATTERNS) {
+      const match = remainingContent.match(pattern.regex);
+      if (match && match.index === 0) {
+        const name = match[pattern.nameGroup];
+        if (!name)
+          continue;
+        const exported = !!match[1];
+        let endIndex;
+        if (pattern.type === "interface" || pattern.type === "class" || pattern.type === "enum") {
+          const braceStart = remainingContent.indexOf("{");
+          if (braceStart === -1)
+            continue;
+          endIndex = findMatchingBrace(remainingContent, braceStart);
+          if (endIndex === -1)
+            endIndex = remainingContent.indexOf(`
+`, braceStart + 1);
+        } else if (pattern.type === "type") {
+          endIndex = findStatementEnd(remainingContent, match[0].length);
+        } else {
+          const hasArrow = remainingContent.slice(match[0].length, match[0].length + 100).includes("=>");
+          if (hasArrow) {
+            const arrowIndex = remainingContent.indexOf("=>", match[0].length);
+            const afterArrow = remainingContent.slice(arrowIndex + 2).trimStart();
+            if (afterArrow.startsWith("{")) {
+              const braceStart = arrowIndex + 2 + (remainingContent.slice(arrowIndex + 2).length - afterArrow.length);
+              endIndex = findMatchingBrace(remainingContent, braceStart);
+            } else {
+              endIndex = findStatementEnd(remainingContent, arrowIndex + 2);
+            }
+          } else {
+            const braceIndex = remainingContent.indexOf("{", match[0].length);
+            const newlineIndex = remainingContent.indexOf(`
+`, match[0].length);
+            if (braceIndex !== -1 && (newlineIndex === -1 || braceIndex < newlineIndex)) {
+              endIndex = findMatchingBrace(remainingContent, braceIndex);
+            } else {
+              endIndex = findStatementEnd(remainingContent, match[0].length);
+            }
+          }
+        }
+        if (endIndex === -1)
+          endIndex = remainingContent.indexOf(`
+
+`);
+        if (endIndex === -1)
+          endIndex = Math.min(remainingContent.length - 1, 500);
+        const declarationContent = remainingContent.slice(0, endIndex + 1).trim();
+        const endLineIndex = lineIndex + declarationContent.split(`
+`).length - 1;
+        const normalized = normalizeCode(declarationContent);
+        declarations.push({
+          type: pattern.type,
+          name,
+          content: declarationContent,
+          normalized,
+          hash: simpleHash(normalized),
+          filePath,
+          startLine: lineIndex + 1,
+          endLine: endLineIndex + 1,
+          exported
+        });
+        break;
+      }
+    }
+    lineStart += line.length + 1;
+  }
+  return declarations;
+}
+function calculateNameSimilarity(a, b) {
+  if (a === b)
+    return 1;
+  const aLower = a.toLowerCase();
+  const bLower = b.toLowerCase();
+  if (aLower === bLower)
+    return 0.95;
+  if (aLower.includes(bLower) || bLower.includes(aLower))
+    return 0.8;
+  const aWords = splitCamelCase(a);
+  const bWords = splitCamelCase(b);
+  const aSet = new Set(aWords.map((w) => w.toLowerCase()));
+  const bSet = new Set(bWords.map((w) => w.toLowerCase()));
+  let intersection = 0;
+  for (const word of aSet) {
+    if (bSet.has(word))
+      intersection++;
+  }
+  const union = aSet.size + bSet.size - intersection;
+  const wordSimilarity = union > 0 ? intersection / union : 0;
+  if (wordSimilarity > 0.5)
+    return wordSimilarity * 0.9;
+  const distance = levenshteinDistance(aLower, bLower);
+  const maxLen = Math.max(aLower.length, bLower.length);
+  return Math.max(0, 1 - distance / maxLen) * 0.7;
+}
+function splitCamelCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/).filter((w) => w.length > 0);
+}
+function levenshteinDistance(a, b) {
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  const matrix = [];
+  for (let i = 0;i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= b.length; i++) {
+    for (let j = 1;j <= a.length; j++) {
+      if (b[i - 1] === a[j - 1]) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
 // src/detector.ts
 function calculateSimilarityFast(a, b) {
   if (a === b)
@@ -429,7 +672,7 @@ class UnionFind {
     }
   }
 }
-function findDuplicates(blocks, minSimilarity, _basePath) {
+function findDuplicates(blocks, minSimilarity, basePath) {
   const hashGroups = new Map;
   for (const block of blocks) {
     const existing = hashGroups.get(block.hash) ?? [];
@@ -582,7 +825,7 @@ function findDuplicates(blocks, minSimilarity, _basePath) {
   const dedupedGroups = deduplicateGroups(allDuplicates);
   return dedupedGroups.map((group) => ({
     ...group,
-    suggestion: generateRefactoringSuggestion(group, _basePath)
+    suggestion: generateRefactoringSuggestion(group, basePath)
   }));
 }
 function filterOverlappingBlocks(blocks) {
@@ -776,10 +1019,81 @@ function deduplicateGroups(groups) {
   }
   return result;
 }
+function findDeclarationDuplicates(declarations, minSimilarity) {
+  const duplicates = [];
+  let groupId = 0;
+  const byType = new Map;
+  for (const decl of declarations) {
+    const existing = byType.get(decl.type) ?? [];
+    existing.push(decl);
+    byType.set(decl.type, existing);
+  }
+  for (const [type, typeDecls] of byType) {
+    const processed = new Set;
+    for (let i = 0;i < typeDecls.length; i++) {
+      if (processed.has(i))
+        continue;
+      const declA = typeDecls[i];
+      const matches = [{
+        name: declA.name,
+        filePath: declA.filePath,
+        startLine: declA.startLine,
+        endLine: declA.endLine,
+        content: declA.content,
+        exported: declA.exported
+      }];
+      let bestNameSim = 0;
+      let bestContentSim = 0;
+      for (let j = i + 1;j < typeDecls.length; j++) {
+        if (processed.has(j))
+          continue;
+        const declB = typeDecls[j];
+        if (declA.filePath === declB.filePath && Math.abs(declA.startLine - declB.startLine) < 5)
+          continue;
+        const nameSim = calculateNameSimilarity(declA.name, declB.name);
+        const contentSim = calculateSimilarityFast(declA.normalized, declB.normalized);
+        const combined = Math.max(nameSim * 0.4 + contentSim * 0.6, nameSim >= 0.9 ? nameSim : 0, contentSim >= 0.9 ? contentSim : 0);
+        if (combined >= minSimilarity || nameSim >= 0.8 && contentSim >= 0.5) {
+          processed.add(j);
+          matches.push({
+            name: declB.name,
+            filePath: declB.filePath,
+            startLine: declB.startLine,
+            endLine: declB.endLine,
+            content: declB.content,
+            exported: declB.exported
+          });
+          bestNameSim = Math.max(bestNameSim, nameSim);
+          bestContentSim = Math.max(bestContentSim, contentSim);
+        }
+      }
+      if (matches.length >= 2) {
+        processed.add(i);
+        const exported = matches.find((m) => m.exported);
+        const suggestion = exported ? `Import \`${exported.name}\` from \`${exported.filePath.replace(/.*\/(src|lib)\//, "")}\`` : `Consider extracting \`${declA.name}\` to a shared location`;
+        duplicates.push({
+          id: groupId++,
+          type,
+          similarity: Math.max(bestNameSim, bestContentSim),
+          nameSimilarity: bestNameSim,
+          contentSimilarity: bestContentSim,
+          matches,
+          suggestion
+        });
+      }
+    }
+  }
+  duplicates.sort((a, b) => {
+    const scoreA = a.matches.length * a.similarity;
+    const scoreB = b.matches.length * b.similarity;
+    return scoreB - scoreA;
+  });
+  return duplicates;
+}
 
 // src/formatter.ts
 import path from "node:path";
-var { reset, bold, dim, red, green, yellow, blue, cyan, magenta, gray } = COLORS;
+var { reset, bold, dim, red, green, yellow, cyan, magenta, gray } = COLORS;
 function truncatePath(filePath, basePath) {
   const absoluteBase = path.resolve(basePath);
   let relativePath = filePath;
@@ -822,13 +1136,14 @@ function formatGroup(group, index, basePath) {
   if (hasMore) {
     lines.push(`  ${dim}└─${reset} ${gray}... and ${group.matches.length - MAX_MATCHES_IN_SUMMARY} more${reset}`);
   }
-  if (group.matches.length > 0) {
+  const firstMatch = group.matches[0];
+  if (firstMatch) {
     lines.push("");
     lines.push(`  ${dim}Code preview:${reset}`);
-    const previewLines = group.matches[0].content.split(`
+    const previewLines = firstMatch.content.split(`
 `).slice(0, CODE_PREVIEW_CONTEXT_LINES).map((line) => `  ${gray}│${reset} ${dim}${line.slice(0, 80)}${line.length > 80 ? "..." : ""}${reset}`);
     lines.push(...previewLines);
-    if (group.matches[0].content.split(`
+    if (firstMatch.content.split(`
 `).length > CODE_PREVIEW_CONTEXT_LINES) {
       lines.push(`  ${gray}│${reset} ${dim}...${reset}`);
     }
@@ -856,8 +1171,11 @@ function formatOutput(groups, basePath) {
   lines.push("");
   const groupsToShow = groups.slice(0, MAX_GROUPS_DETAILED);
   for (let i = 0;i < groupsToShow.length; i++) {
-    lines.push(formatGroup(groupsToShow[i], i, basePath));
-    lines.push("");
+    const group = groupsToShow[i];
+    if (group) {
+      lines.push(formatGroup(group, i, basePath));
+      lines.push("");
+    }
   }
   if (groups.length > MAX_GROUPS_DETAILED) {
     lines.push(`${dim}... and ${groups.length - MAX_GROUPS_DETAILED} more groups${reset}`);
@@ -896,6 +1214,76 @@ function formatStats(groups) {
   return lines.join(`
 `);
 }
+var TYPE_LABELS = {
+  type: "Type",
+  interface: "Interface",
+  function: "Function",
+  class: "Class",
+  const: "Constant",
+  enum: "Enum"
+};
+function formatDeclarationGroup(group, index, basePath) {
+  const lines = [];
+  const typeLabel = TYPE_LABELS[group.type] || group.type;
+  const simBadge = group.similarity >= 0.95 ? `${red}${bold}EXACT${reset}` : `${yellow}${Math.round(group.similarity * 100)}%${reset}`;
+  lines.push(`${bold}${typeLabel} ${index + 1}${reset} │ ${simBadge} │ ${group.matches.length} occurrences`);
+  if (group.nameSimilarity > 0 && group.nameSimilarity < 1) {
+    lines.push(`  ${dim}Name similarity: ${Math.round(group.nameSimilarity * 100)}%${reset}`);
+  }
+  lines.push("");
+  for (const match of group.matches.slice(0, 5)) {
+    const displayPath = truncatePath(match.filePath, basePath);
+    const exportBadge = match.exported ? `${green}exported${reset}` : `${gray}local${reset}`;
+    lines.push(`  ${dim}├─${reset} ${cyan}${match.name}${reset} [${exportBadge}]`);
+    lines.push(`     ${displayPath}:${yellow}${match.startLine}${reset}-${yellow}${match.endLine}${reset}`);
+  }
+  if (group.matches.length > 5) {
+    lines.push(`  ${dim}└─${reset} ${gray}... and ${group.matches.length - 5} more${reset}`);
+  }
+  lines.push("");
+  lines.push(`  ${magenta}→${reset} ${group.suggestion}`);
+  return lines.join(`
+`);
+}
+function formatDeclarations(groups, basePath) {
+  if (groups.length === 0) {
+    return "";
+  }
+  const lines = [];
+  lines.push("");
+  lines.push(SECTION_SEPARATOR2);
+  lines.push(`${bold}DUPLICATE DECLARATIONS${reset}`);
+  lines.push(SECTION_SEPARATOR2);
+  lines.push("");
+  const byType = new Map;
+  for (const group of groups) {
+    const existing = byType.get(group.type) || [];
+    existing.push(group);
+    byType.set(group.type, existing);
+  }
+  let globalIndex = 0;
+  for (const [type, typeGroups] of byType) {
+    const typeLabel = TYPE_LABELS[type] || type;
+    lines.push(`${bold}${typeLabel}s (${typeGroups.length})${reset}`);
+    lines.push("");
+    for (const group of typeGroups.slice(0, 10)) {
+      lines.push(formatDeclarationGroup(group, globalIndex++, basePath));
+      lines.push("");
+    }
+    if (typeGroups.length > 10) {
+      lines.push(`${dim}... and ${typeGroups.length - 10} more ${typeLabel.toLowerCase()}s${reset}`);
+      lines.push("");
+    }
+  }
+  lines.push(SECTION_SEPARATOR2);
+  const totalDups = groups.reduce((sum, g) => sum + g.matches.length, 0);
+  lines.push(`${bold}Declaration Summary${reset}`);
+  lines.push(`  Duplicate groups: ${bold}${groups.length}${reset}`);
+  lines.push(`  Total occurrences: ${bold}${totalDups}${reset}`);
+  lines.push(SECTION_SEPARATOR2);
+  return lines.join(`
+`);
+}
 
 // node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -6446,26 +6834,7 @@ glob.glob = glob;
 // src/scanner.ts
 import path3 from "node:path";
 import { readFile, stat } from "node:fs/promises";
-
-// src/normalizer.ts
-function normalizeCode(code) {
-  let normalized = code;
-  normalized = normalized.replace(/"(?:[^"\\]|\\.)*"/g, `"${STRING_PLACEHOLDER}"`);
-  normalized = normalized.replace(/'(?:[^'\\]|\\.)*'/g, `'${STRING_PLACEHOLDER}'`);
-  normalized = normalized.replace(/`(?:[^`\\]|\\.)*`/g, `\`${TEMPLATE_PLACEHOLDER}\``);
-  normalized = normalized.replace(/\b\d+\.?\d*\b/g, NUMBER_PLACEHOLDER);
-  normalized = normalized.replace(/#[0-9a-fA-F]{3,8}\b/g, COLOR_PLACEHOLDER);
-  normalized = normalized.replace(/[ \t]+/g, " ");
-  normalized = normalized.split(`
-`).map((line) => line.trimEnd()).join(`
-`);
-  normalized = normalized.replace(/\n\s*\n/g, `
-`);
-  return normalized;
-}
-
-// src/scanner.ts
-function simpleHash(str) {
+function simpleHash2(str) {
   let hash = 0;
   for (let i = 0;i < str.length; i++) {
     const char = str.charCodeAt(i);
@@ -6493,7 +6862,7 @@ function extractBlocks(content, filePath, minLines, shouldNormalize) {
     blockSizes.push(size);
   }
   for (const blockSize of blockSizes) {
-    const step = Math.max(1, Math.floor(blockSize / SLIDING_WINDOW_STEP_DIVISOR));
+    const step = blockSize < 10 ? 1 : Math.max(1, Math.floor(blockSize / SLIDING_WINDOW_STEP_DIVISOR));
     for (let i = 0;i <= lines.length - blockSize; i += step) {
       const blockLines = lines.slice(i, i + blockSize);
       const blockContent = blockLines.join(`
@@ -6503,7 +6872,7 @@ function extractBlocks(content, filePath, minLines, shouldNormalize) {
         continue;
       }
       const normalized = shouldNormalize ? normalizeCode(blockContent) : blockContent;
-      const hash = simpleHash(normalized);
+      const hash = simpleHash2(normalized);
       blocks.push({
         content: blockContent,
         normalized,
@@ -6524,10 +6893,11 @@ function shouldIgnore(filePath, ignorePatterns) {
     return normalizedPath.includes(`/${normalizedPattern}/`) || normalizedPath.includes(`\\${normalizedPattern}\\`) || normalizedPath.endsWith(`/${normalizedPattern}`) || normalizedPath.endsWith(`\\${normalizedPattern}`);
   });
 }
-async function scanDirectory(targetPath, options) {
+async function scanDirectory(targetPath, options, enableDeclarations = true) {
   const { extensions, ignorePatterns, minLines, normalize: normalize2 } = options;
   const absolutePath = path3.resolve(targetPath);
   const blocks = [];
+  const declarations = [];
   let fileCount = 0;
   let totalLines = 0;
   const pattern = extensions.length === 1 ? `**/*.${extensions[0]}` : `**/*.{${extensions.join(",")}}`;
@@ -6537,6 +6907,7 @@ async function scanDirectory(targetPath, options) {
     nodir: true,
     ignore: ignorePatterns.map((p) => `**/${p}/**`)
   });
+  const isTypeScript = enableDeclarations && extensions.some((ext2) => ext2 === "ts" || ext2 === "tsx");
   for (const filePath of files) {
     if (shouldIgnore(filePath, ignorePatterns)) {
       continue;
@@ -6553,45 +6924,102 @@ async function scanDirectory(targetPath, options) {
       fileCount++;
       const fileBlocks = extractBlocks(content, filePath, minLines, normalize2);
       blocks.push(...fileBlocks);
+      if (isTypeScript && (filePath.endsWith(".ts") || filePath.endsWith(".tsx"))) {
+        const fileDeclarations = extractDeclarations(content, filePath);
+        declarations.push(...fileDeclarations);
+      }
     } catch {
       console.warn(`Warning: Could not read ${filePath}`);
     }
   }
-  return { blocks, fileCount, totalLines };
+  return { blocks, declarations, fileCount, totalLines };
 }
 
 // index.ts
-var VERSION = process.env.npm_package_version || "1.3.1";
-function getChangedFiles(targetPath) {
-  const absolutePath = path4.resolve(targetPath);
-  const files = new Set;
-  const addFiles = (output) => {
-    for (const file of output.split(`
+var VERSION = process.env.npm_package_version || "1.4.1";
+function parseDiffOutput(diff, cwd) {
+  const changes = new Map;
+  let currentFile = null;
+  let newLineNum = 0;
+  for (const line of diff.split(`
 `)) {
-      if (file.trim()) {
-        files.add(path4.resolve(absolutePath, file.trim()));
+    if (line.startsWith("+++ b/")) {
+      currentFile = path4.resolve(cwd, line.slice(6));
+      if (!changes.has(currentFile)) {
+        changes.set(currentFile, []);
+      }
+    } else if (line.startsWith("@@") && currentFile) {
+      const match2 = line.match(/@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (match2) {
+        newLineNum = parseInt(match2[1], 10);
+      }
+    } else if (currentFile && newLineNum > 0) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        const ranges = changes.get(currentFile);
+        const lastRange = ranges[ranges.length - 1];
+        if (lastRange && lastRange.end === newLineNum - 1) {
+          lastRange.end = newLineNum;
+        } else {
+          ranges.push({ start: newLineNum, end: newLineNum });
+        }
+        newLineNum++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {} else if (!line.startsWith("\\")) {
+        newLineNum++;
       }
     }
+  }
+  return changes;
+}
+function getChangedLines(targetPath) {
+  const absolutePath = path4.resolve(targetPath);
+  const allChanges = new Map;
+  const mergeChanges = (newChanges) => {
+    for (const [file, ranges] of newChanges) {
+      if (!allChanges.has(file)) {
+        allChanges.set(file, []);
+      }
+      allChanges.get(file).push(...ranges);
+    }
+  };
+  const addFullFile = (filePath) => {
+    const resolved = path4.resolve(absolutePath, filePath);
+    if (!allChanges.has(resolved)) {
+      allChanges.set(resolved, [{ start: 1, end: 999999 }]);
+    }
   };
   try {
-    addFiles(execSync("git diff --cached --name-only", { cwd: absolutePath, encoding: "utf-8" }));
-    addFiles(execSync("git diff --name-only", { cwd: absolutePath, encoding: "utf-8" }));
-    addFiles(execSync("git ls-files --others --exclude-standard", { cwd: absolutePath, encoding: "utf-8" }));
+    const stagedDiff = execSync("git diff --cached", { cwd: absolutePath, encoding: "utf-8" });
+    mergeChanges(parseDiffOutput(stagedDiff, absolutePath));
+    const unstagedDiff = execSync("git diff", { cwd: absolutePath, encoding: "utf-8" });
+    mergeChanges(parseDiffOutput(unstagedDiff, absolutePath));
+    const untracked = execSync("git ls-files --others --exclude-standard", { cwd: absolutePath, encoding: "utf-8" });
+    for (const file of untracked.split(`
+`)) {
+      if (file.trim())
+        addFullFile(file.trim());
+    }
     try {
       const baseBranch = execSync("git rev-parse --abbrev-ref origin/HEAD 2>/dev/null || echo origin/main", { cwd: absolutePath, encoding: "utf-8" }).trim().replace("origin/", "");
       const currentBranch = execSync("git rev-parse --abbrev-ref HEAD", { cwd: absolutePath, encoding: "utf-8" }).trim();
       if (currentBranch !== baseBranch) {
         const mergeBase = execSync(`git merge-base ${baseBranch} HEAD 2>/dev/null || echo ""`, { cwd: absolutePath, encoding: "utf-8" }).trim();
         if (mergeBase) {
-          addFiles(execSync(`git diff --name-only ${mergeBase}...HEAD`, { cwd: absolutePath, encoding: "utf-8" }));
+          const branchDiff = execSync(`git diff ${mergeBase}...HEAD`, { cwd: absolutePath, encoding: "utf-8" });
+          mergeChanges(parseDiffOutput(branchDiff, absolutePath));
         }
       }
     } catch {}
-    return files;
+    return allChanges;
   } catch {
-    return new Set;
+    return new Map;
   }
 }
+function isInChangedLines(filePath, blockStart, blockEnd, changes) {
+  const ranges = changes.get(filePath);
+  if (!ranges)
+    return false;
+  return ranges.some((r) => blockStart <= r.end && blockEnd >= r.start);
+}
 function showHelp() {
   console.log(`
 dslop - Detect Similar/Duplicate Lines Of Programming
@@ -6675,8 +7103,8 @@ async function main() {
     minLines,
     normalize: normalize2
   };
-  const changedFiles = !scanAll ? getChangedFiles(targetPath) : null;
-  if (!scanAll && changedFiles?.size === 0) {
+  const changedLines = !scanAll ? getChangedLines(targetPath) : null;
+  if (!scanAll && changedLines?.size === 0) {
     console.log(`
 No changes found. Use --all to scan entire codebase.`);
     process.exit(0);
@@ -6684,7 +7112,7 @@ No changes found. Use --all to scan entire codebase.`);
   console.log(`
 Scanning ${targetPath}...`);
   if (!scanAll) {
-    console.log(`  Mode: checking ${changedFiles.size} changed files`);
+    console.log(`  Mode: checking changed lines in ${changedLines.size} files`);
   } else {
     console.log(`  Mode: full codebase scan`);
   }
@@ -6697,20 +7125,42 @@ Scanning ${targetPath}...`);
   console.log();
   try {
     const startTime = performance.now();
-    const { blocks, fileCount, totalLines } = await scanDirectory(targetPath, scanOptions);
+    const { blocks, declarations, fileCount, totalLines } = await scanDirectory(targetPath, scanOptions, scanAll);
     const scanTime = performance.now() - startTime;
     console.log(`Scanned ${fileCount} files (${totalLines.toLocaleString()} lines) in ${Math.round(scanTime)}ms`);
-    console.log(`Extracted ${blocks.length.toLocaleString()} code blocks
+    if (declarations.length > 0) {
+      console.log(`Extracted ${blocks.length.toLocaleString()} code blocks, ${declarations.length.toLocaleString()} declarations
+`);
+    } else {
+      console.log(`Extracted ${blocks.length.toLocaleString()} code blocks
 `);
-    if (blocks.length === 0) {
-      console.log("No code blocks found to analyze.");
+    }
+    if (blocks.length === 0 && declarations.length === 0) {
+      console.log("No code found to analyze.");
       process.exit(0);
     }
     const detectStart = performance.now();
     let duplicates = findDuplicates(blocks, similarity, targetPath);
+    let declDuplicates = findDeclarationDuplicates(declarations, similarity);
     const detectTime = performance.now() - detectStart;
-    if (!scanAll && changedFiles) {
-      duplicates = duplicates.filter((group) => group.matches.some((m) => changedFiles.has(m.filePath)));
+    if (!scanAll && changedLines) {
+      const changedFilePaths = new Set(changedLines.keys());
+      duplicates = duplicates.filter((group) => {
+        const inChanged = group.matches.filter((m) => isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines));
+        const notInChanged = group.matches.filter((m) => !isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines));
+        if (inChanged.length === 0 || notInChanged.length === 0)
+          return false;
+        const inOtherFiles = notInChanged.some((m) => !changedFilePaths.has(m.filePath));
+        const inSameFileOutsideChanges = notInChanged.some((m) => changedFilePaths.has(m.filePath));
+        if (inOtherFiles && group.matches.length > 10)
+          return false;
+        return inOtherFiles || inSameFileOutsideChanges;
+      });
+      declDuplicates = declDuplicates.filter((group) => {
+        const inChanged = group.matches.filter((m) => isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines));
+        const notInChanged = group.matches.filter((m) => !isInChangedLines(m.filePath, m.startLine, m.endLine, changedLines));
+        return inChanged.length > 0 && notInChanged.length > 0;
+      });
     }
     if (crossPackage) {
       duplicates = duplicates.filter((group) => {
@@ -6720,10 +7170,23 @@ Scanning ${targetPath}...`);
         }));
         return packages.size > 1;
       });
+      declDuplicates = declDuplicates.filter((group) => {
+        const packages = new Set(group.matches.map((m) => {
+          const match2 = m.filePath.match(/(?:apps|packages|libs)\/([^\/]+)/);
+          return match2 ? match2[1] : m.filePath.split("/")[0];
+        }));
+        return packages.size > 1;
+      });
     }
-    console.log(`Found ${duplicates.length} duplicate groups in ${Math.round(detectTime)}ms
+    const totalGroups = duplicates.length + declDuplicates.length;
+    console.log(`Found ${totalGroups} duplicate groups in ${Math.round(detectTime)}ms`);
+    if (declDuplicates.length > 0) {
+      console.log(`  (${duplicates.length} code blocks, ${declDuplicates.length} declarations)
 `);
-    if (duplicates.length === 0) {
+    } else {
+      console.log();
+    }
+    if (totalGroups === 0) {
       if (!scanAll) {
         console.log("No duplicates in your changes. You're good!");
       } else if (crossPackage) {
@@ -6734,10 +7197,15 @@ Scanning ${targetPath}...`);
       process.exit(0);
     }
     if (jsonOutput) {
-      console.log(JSON.stringify(duplicates, null, 2));
+      console.log(JSON.stringify({ duplicates, declarations: declDuplicates }, null, 2));
     } else {
-      console.log(formatOutput(duplicates, targetPath));
-      console.log(formatStats(duplicates));
+      if (duplicates.length > 0) {
+        console.log(formatOutput(duplicates, targetPath));
+        console.log(formatStats(duplicates));
+      }
+      if (declDuplicates.length > 0) {
+        console.log(formatDeclarations(declDuplicates, targetPath));
+      }
     }
   } catch (error) {
     console.error("Error:", error instanceof Error ? error.message : error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dslop",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Detect Similar/Duplicate Lines Of Programming - Find code duplication in your codebase",
   "type": "module",
   "main": "./dist/index.js",