pastapolice 1.0.2 → 1.0.3

package/dist/index.cjs

@@ -220025,6 +220025,10 @@ function isKeyword(text) {
 function hashNormalized(normalized) {
   return (0, import_xxhash.xxh64)(normalized).toString(16);
 }
+function tokenizeNormalized(normalized) {
+  const tokens = normalized.split(/[\s{}\[\]();,.<>+/*%=!?&|:]+/).filter((t) => t.length > 0);
+  return tokens;
+}
 
 // src/processor.ts
 async function processFile(file, minLines, map) {
@@ -220065,6 +220069,22 @@ async function processFileSemantic(file, minLines, semanticMap) {
     semanticMap.get(hash).push(func);
   }
 }
+async function processFileFuzzy(file, minLines, allFunctions = []) {
+  const content = await (0, import_promises.readFile)(file, "utf-8");
+  const functions = parseFunctions(file, content);
+  const effectiveMinLines = Math.max(1, minLines);
+  for (const func of functions) {
+    func.file = file;
+    const lineCount = func.end - func.start + 1;
+    if (lineCount < effectiveMinLines) {
+      continue;
+    }
+    normalizeFunction(file, content, func);
+    func.tokens = tokenizeNormalized(func.normalized);
+    allFunctions.push(func);
+  }
+  return allFunctions;
+}
 function normalizeLine(line) {
   return line.trim();
 }
@@ -220080,6 +220100,49 @@ function getSemanticMatches(semanticMap) {
   }
   return matches;
 }
+function jaccardSimilarity(tokens1, tokens2) {
+  if (tokens1.length === 0 && tokens2.length === 0) return 1;
+  if (tokens1.length === 0 || tokens2.length === 0) return 0;
+  const set1 = new Set(tokens1);
+  const set2 = new Set(tokens2);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function getFuzzyMatches(allFunctions, threshold = 0.6) {
+  const matches = [];
+  const checked = /* @__PURE__ */ new Set();
+  for (let i = 0; i < allFunctions.length; i++) {
+    for (let j = i + 1; j < allFunctions.length; j++) {
+      const func1 = allFunctions[i];
+      const func2 = allFunctions[j];
+      if (func1.file === func2.file) continue;
+      const pairKey = `${func1.file}:${func1.start}-${func1.end}|${func2.file}:${func2.start}-${func2.end}`;
+      if (checked.has(pairKey)) continue;
+      checked.add(pairKey);
+      const tokens1 = func1.tokens || tokenizeNormalized(func1.normalized);
+      const tokens2 = func2.tokens || tokenizeNormalized(func2.normalized);
+      const similarity = jaccardSimilarity(tokens1, tokens2);
+      if (similarity >= threshold) {
+        const existingMatch = matches.find(
+          (m) => m.pairs.some(
+            (p) => p.func1.file === func1.file && p.func1.start === func1.start || p.func1.file === func2.file && p.func1.start === func2.start
+          )
+        );
+        if (existingMatch) {
+          existingMatch.pairs.push({ func1, func2, similarity });
+          existingMatch.averageSimilarity = existingMatch.pairs.reduce((sum, p) => sum + p.similarity, 0) / existingMatch.pairs.length;
+        } else {
+          matches.push({
+            pairs: [{ func1, func2, similarity }],
+            averageSimilarity: similarity
+          });
+        }
+      }
+    }
+  }
+  return matches;
+}
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -220624,12 +220687,56 @@ async function reportSemantic(matches) {
   }
   console.log(source_default.yellow(`Total semantic matches found: ${matches.length}`));
 }
+async function reportFuzzy(matches) {
+  if (matches.length === 0) {
+    console.log(source_default.green("\u2705 No suspicious pasta found."));
+    return;
+  }
+  console.log(source_default.red("\n\u{1F693} Fuzzy semantic matching complete!\n"));
+  for (const match of matches) {
+    const similarityPercent = Math.round(match.averageSimilarity * 100);
+    console.log(source_default.red(`\u{1F50D} ${similarityPercent}% similar functions detected:
+`));
+    const funcSet = /* @__PURE__ */ new Map();
+    for (const pair of match.pairs) {
+      const key1 = `${pair.func1.file}:${pair.func1.start}`;
+      const key2 = `${pair.func2.file}:${pair.func2.start}`;
+      if (!funcSet.has(key1)) funcSet.set(key1, pair.func1);
+      if (!funcSet.has(key2)) funcSet.set(key2, pair.func2);
+    }
+    for (const func of funcSet.values()) {
+      console.log(source_default.yellow(`  ${func.signature}`));
+      console.log(source_default.gray(`    File: ${func.file}:${func.start}-${func.end}`));
+      try {
+        const content = await (0, import_promises2.readFile)(func.file, "utf-8");
+        const lines = content.split("\n");
+        const snippet = lines.slice(func.start - 1, func.end).join("\n");
+        console.log(source_default.gray("    Code:"));
+        snippet.split("\n").forEach((line) => {
+          console.log(source_default.gray("      " + line));
+        });
+      } catch {
+      }
+      console.log();
+    }
+    console.log(source_default.gray("--------------------------------\n"));
+  }
+  console.log(source_default.yellow(`Total fuzzy matches found: ${matches.length}`));
+}
 
 // src/scan.ts
-async function scan(root, minLines, syntactic = false) {
+async function scan(root, minLines, syntactic = false, fuzzy = false) {
   console.log("\u{1F693} PastaPolice scanning...");
   const files = await getSourceFiles(root);
-  if (!syntactic) {
+  if (fuzzy) {
+    console.log("\u{1F50D} Mode: Fuzzy semantic matching (AST-based with similarity scoring)");
+    const allFunctions = [];
+    for (const file of files) {
+      await processFileFuzzy(file, 1, allFunctions);
+    }
+    const matches = getFuzzyMatches(allFunctions, 0.7);
+    await reportFuzzy(matches);
+  } else if (!syntactic) {
     console.log("\u{1F50D} Mode: Semantic clone detection (AST-based)");
     const semanticMap = /* @__PURE__ */ new Map();
     for (const file of files) {
@@ -220652,10 +220759,14 @@ var program2 = new Command();
 program2.name("PastaPolice").description("Detect copy-paste code blocks").argument("[path]", "path to scan", ".").option("-m, --min-lines <number>", "minimum lines per block", "5").option(
   "-s, --syntactic",
   "use syntactic (line-based) detection instead of semantic"
+).option(
+  "-f, --fuzzy",
+  "use fuzzy semantic matching to find similar (not exact) functions"
 ).action(async (path, options) => {
   const minLines = parseInt(options.minLines, 10);
   const syntactic = options.syntactic || false;
-  await scan(path, minLines, syntactic);
+  const fuzzy = options.fuzzy || false;
+  await scan(path, minLines, syntactic, fuzzy);
 });
 program2.parse();
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pastapolice",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Detect copy-paste and semantically similar code in TypeScript/JavaScript projects",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -10,6 +10,10 @@
   "bin": {
     "pastapolice": "./dist/index.cjs"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lawlesx/PastaPolice.git"
+  },
   "keywords": [
     "duplicate",
     "code",