@aiready/pattern-detect 0.11.31 → 0.11.32

package/dist/python-extractor-ELAKYK2W.mjs

@@ -0,0 +1,140 @@
+// src/extractors/python-extractor.ts
+import { getParser } from "@aiready/core";
+async function extractPythonPatterns(files) {
+  const patterns = [];
+  const parser = getParser("dummy.py");
+  if (!parser) {
+    console.warn("Python parser not available");
+    return patterns;
+  }
+  const pythonFiles = files.filter((f) => f.toLowerCase().endsWith(".py"));
+  for (const file of pythonFiles) {
+    try {
+      const fs = await import("fs");
+      const code = await fs.promises.readFile(file, "utf-8");
+      const result = parser.parse(code, file);
+      for (const exp of result.exports) {
+        if (exp.type === "function") {
+          patterns.push({
+            file,
+            name: exp.name,
+            type: "function",
+            startLine: exp.loc?.start.line || 0,
+            endLine: exp.loc?.end.line || 0,
+            imports: exp.imports || [],
+            dependencies: exp.dependencies || [],
+            signature: generatePythonSignature(exp),
+            language: "python"
+          });
+        } else if (exp.type === "class") {
+          patterns.push({
+            file,
+            name: exp.name,
+            type: "class",
+            startLine: exp.loc?.start.line || 0,
+            endLine: exp.loc?.end.line || 0,
+            imports: exp.imports || [],
+            dependencies: exp.dependencies || [],
+            signature: `class ${exp.name}`,
+            language: "python"
+          });
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to extract patterns from ${file}:`, error);
+    }
+  }
+  return patterns;
+}
+function generatePythonSignature(exp) {
+  const params = exp.parameters?.join(", ") || "";
+  return `def ${exp.name}(${params})`;
+}
+function calculatePythonSimilarity(pattern1, pattern2) {
+  let similarity = 0;
+  let factors = 0;
+  const nameSimilarity = calculateNameSimilarity(pattern1.name, pattern2.name);
+  similarity += nameSimilarity * 0.3;
+  factors += 0.3;
+  const importSimilarity = calculateImportSimilarity(
+    pattern1.imports || [],
+    pattern2.imports || []
+  );
+  similarity += importSimilarity * 0.4;
+  factors += 0.4;
+  if (pattern1.type === pattern2.type) {
+    similarity += 0.1;
+  }
+  factors += 0.1;
+  const sigSimilarity = calculateSignatureSimilarity(
+    pattern1.signature,
+    pattern2.signature
+  );
+  similarity += sigSimilarity * 0.2;
+  factors += 0.2;
+  return factors > 0 ? similarity / factors : 0;
+}
+function calculateNameSimilarity(name1, name2) {
+  if (name1 === name2) return 1;
+  const clean1 = name1.replace(
+    /^(get|set|is|has|create|delete|update|fetch)_?/,
+    ""
+  );
+  const clean2 = name2.replace(
+    /^(get|set|is|has|create|delete|update|fetch)_?/,
+    ""
+  );
+  if (clean1 === clean2) return 0.9;
+  if (clean1.includes(clean2) || clean2.includes(clean1)) {
+    return 0.7;
+  }
+  const set1 = new Set(clean1.split("_"));
+  const set2 = new Set(clean2.split("_"));
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function calculateImportSimilarity(imports1, imports2) {
+  if (imports1.length === 0 && imports2.length === 0) return 1;
+  if (imports1.length === 0 || imports2.length === 0) return 0;
+  const set1 = new Set(imports1);
+  const set2 = new Set(imports2);
+  const intersection = new Set([...set1].filter((x) => set2.has(x)));
+  const union = /* @__PURE__ */ new Set([...set1, ...set2]);
+  return intersection.size / union.size;
+}
+function calculateSignatureSimilarity(sig1, sig2) {
+  if (sig1 === sig2) return 1;
+  const params1 = (sig1.match(/\([^)]*\)/)?.[0] || "").split(",").filter(Boolean).length;
+  const params2 = (sig2.match(/\([^)]*\)/)?.[0] || "").split(",").filter(Boolean).length;
+  if (params1 === params2) return 0.8;
+  if (Math.abs(params1 - params2) === 1) return 0.5;
+  return 0;
+}
+function detectPythonAntiPatterns(patterns) {
+  const antiPatterns = [];
+  const nameGroups = /* @__PURE__ */ new Map();
+  for (const pattern of patterns) {
+    const baseName = pattern.name.replace(
+      /^(get|set|create|delete|update)_/,
+      ""
+    );
+    if (!nameGroups.has(baseName)) {
+      nameGroups.set(baseName, []);
+    }
+    nameGroups.get(baseName).push(pattern);
+  }
+  for (const [baseName, group] of nameGroups) {
+    if (group.length >= 3) {
+      antiPatterns.push(
+        `Found ${group.length} functions with similar names (${baseName}): Consider consolidating`
+      );
+    }
+  }
+  return antiPatterns;
+}
+export {
+  calculatePythonSimilarity,
+  detectPythonAntiPatterns,
+  extractPythonPatterns
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/pattern-detect",
-  "version": "0.11.31",
+  "version": "0.11.32",
   "description": "Semantic duplicate pattern detection for AI-generated code - finds similar implementations that waste AI context tokens",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -45,7 +45,7 @@
   "dependencies": {
     "commander": "^14.0.0",
     "chalk": "^5.3.0",
-    "@aiready/core": "0.9.32"
+    "@aiready/core": "0.9.33"
   },
   "devDependencies": {
     "tsup": "^8.3.5",