@aiready/pattern-detect 0.9.2 → 0.9.3

package/dist/index.js

@@ -31,8 +31,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   analyzePatterns: () => analyzePatterns,
+  calculateSeverity: () => calculateSeverity,
   detectDuplicatePatterns: () => detectDuplicatePatterns,
+  filterBySeverity: () => filterBySeverity,
   generateSummary: () => generateSummary,
+  getSeverityLabel: () => getSeverityLabel,
   getSmartDefaults: () => getSmartDefaults
 });
 module.exports = __toCommonJS(index_exports);
@@ -40,6 +43,154 @@ var import_core2 = require("@aiready/core");
 
 // src/detector.ts
 var import_core = require("@aiready/core");
+
+// src/context-rules.ts
+var CONTEXT_RULES = [
+  // Test Fixtures - Intentional duplication for test isolation
+  {
+    name: "test-fixtures",
+    detect: (file, code) => {
+      const isTestFile = file.includes(".test.") || file.includes(".spec.") || file.includes("__tests__") || file.includes("/test/") || file.includes("/tests/");
+      const hasTestFixtures = code.includes("beforeAll") || code.includes("afterAll") || code.includes("beforeEach") || code.includes("afterEach") || code.includes("setUp") || code.includes("tearDown");
+      return isTestFile && hasTestFixtures;
+    },
+    severity: "info",
+    reason: "Test fixture duplication is intentional for test isolation",
+    suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
+  },
+  // Email/Document Templates - Often intentionally similar for consistency
+  {
+    name: "templates",
+    detect: (file, code) => {
+      const isTemplate = file.includes("/templates/") || file.includes("-template") || file.includes("/email-templates/") || file.includes("/emails/");
+      const hasTemplateContent = (code.includes("return") || code.includes("export")) && (code.includes("html") || code.includes("subject") || code.includes("body"));
+      return isTemplate && hasTemplateContent;
+    },
+    severity: "low",
+    reason: "Template duplication may be intentional for maintainability and branding consistency",
+    suggestion: "Extract shared structure only if templates become hard to maintain"
+  },
+  // E2E/Integration Test Page Objects - Test independence
+  {
+    name: "e2e-page-objects",
+    detect: (file, code) => {
+      const isE2ETest = file.includes("e2e/") || file.includes("/e2e/") || file.includes(".e2e.") || file.includes("/playwright/") || file.includes("playwright/") || file.includes("/cypress/") || file.includes("cypress/") || file.includes("/integration/") || file.includes("integration/");
+      const hasPageObjectPatterns = code.includes("page.") || code.includes("await page") || code.includes("locator") || code.includes("getBy") || code.includes("selector") || code.includes("click(") || code.includes("fill(");
+      return isE2ETest && hasPageObjectPatterns;
+    },
+    severity: "low",
+    reason: "E2E test duplication ensures test independence and reduces coupling",
+    suggestion: "Consider page object pattern only if duplication causes maintenance issues"
+  },
+  // Configuration Files - Often necessarily similar by design
+  {
+    name: "config-files",
+    detect: (file) => {
+      return file.endsWith(".config.ts") || file.endsWith(".config.js") || file.includes("jest.config") || file.includes("vite.config") || file.includes("webpack.config") || file.includes("rollup.config") || file.includes("tsconfig");
+    },
+    severity: "low",
+    reason: "Configuration files often have similar structure by design",
+    suggestion: "Consider shared config base only if configurations become hard to maintain"
+  },
+  // Type Definitions - Duplication for type safety and module independence
+  {
+    name: "type-definitions",
+    detect: (file, code) => {
+      const isTypeFile = file.endsWith(".d.ts") || file.includes("/types/");
+      const hasTypeDefinitions = code.includes("interface ") || code.includes("type ") || code.includes("enum ");
+      return isTypeFile && hasTypeDefinitions;
+    },
+    severity: "info",
+    reason: "Type duplication may be intentional for module independence and type safety",
+    suggestion: "Extract to shared types package only if causing maintenance burden"
+  },
+  // Migration Scripts - One-off scripts that are similar by nature
+  {
+    name: "migration-scripts",
+    detect: (file) => {
+      return file.includes("/migrations/") || file.includes("/migrate/") || file.includes(".migration.");
+    },
+    severity: "info",
+    reason: "Migration scripts are typically one-off and intentionally similar",
+    suggestion: "Duplication is acceptable for migration scripts"
+  },
+  // Mock Data - Test data intentionally duplicated
+  {
+    name: "mock-data",
+    detect: (file, code) => {
+      const isMockFile = file.includes("/mocks/") || file.includes("/__mocks__/") || file.includes("/fixtures/") || file.includes(".mock.") || file.includes(".fixture.");
+      const hasMockData = code.includes("mock") || code.includes("Mock") || code.includes("fixture") || code.includes("stub") || code.includes("export const");
+      return isMockFile && hasMockData;
+    },
+    severity: "info",
+    reason: "Mock data duplication is expected for comprehensive test coverage",
+    suggestion: "Consider shared factories only for complex mock generation"
+  }
+];
+function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
+  for (const rule of CONTEXT_RULES) {
+    if (rule.detect(file1, code) || rule.detect(file2, code)) {
+      return {
+        severity: rule.severity,
+        reason: rule.reason,
+        suggestion: rule.suggestion,
+        matchedRule: rule.name
+      };
+    }
+  }
+  if (similarity >= 0.95 && linesOfCode >= 30) {
+    return {
+      severity: "critical",
+      reason: "Large nearly-identical code blocks waste tokens and create maintenance burden",
+      suggestion: "Extract to shared utility module immediately"
+    };
+  } else if (similarity >= 0.95 && linesOfCode >= 15) {
+    return {
+      severity: "high",
+      reason: "Nearly identical code should be consolidated",
+      suggestion: "Move to shared utility file"
+    };
+  } else if (similarity >= 0.85) {
+    return {
+      severity: "high",
+      reason: "High similarity indicates significant duplication",
+      suggestion: "Extract common logic to shared function"
+    };
+  } else if (similarity >= 0.7) {
+    return {
+      severity: "medium",
+      reason: "Moderate similarity detected",
+      suggestion: "Consider extracting shared patterns if code evolves together"
+    };
+  } else {
+    return {
+      severity: "low",
+      reason: "Minor similarity detected",
+      suggestion: "Monitor but refactoring may not be worthwhile"
+    };
+  }
+}
+function getSeverityLabel(severity) {
+  const labels = {
+    critical: "\u{1F534} CRITICAL",
+    high: "\u{1F7E1} HIGH",
+    medium: "\u{1F535} MEDIUM",
+    low: "\u26AA LOW",
+    info: "\u2139\uFE0F  INFO"
+  };
+  return labels[severity];
+}
+function filterBySeverity(duplicates, minSeverity) {
+  const severityOrder = ["info", "low", "medium", "high", "critical"];
+  const minIndex = severityOrder.indexOf(minSeverity);
+  if (minIndex === -1) return duplicates;
+  return duplicates.filter((dup) => {
+    const dupIndex = severityOrder.indexOf(dup.severity);
+    return dupIndex >= minIndex;
+  });
+}
+
+// src/detector.ts
 function categorizePattern(code) {
   const lower = code.toLowerCase();
   if (lower.includes("request") && lower.includes("response") || lower.includes("router.") || lower.includes("app.get") || lower.includes("app.post") || lower.includes("express") || lower.includes("ctx.body")) {
@@ -255,6 +406,13 @@ async function detectDuplicatePatterns(files, options) {
         const block2 = allBlocks[j];
         const similarity = jaccardSimilarity(blockTokens[i], blockTokens[j]);
         if (similarity >= minSimilarity) {
+          const { severity, reason, suggestion, matchedRule } = calculateSeverity(
+            block1.file,
+            block2.file,
+            block1.content,
+            similarity,
+            block1.linesOfCode
+          );
           const duplicate = {
             file1: block1.file,
             file2: block2.file,
@@ -266,7 +424,11 @@ async function detectDuplicatePatterns(files, options) {
             snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
             patternType: block1.patternType,
             tokenCost: block1.tokenCost + block2.tokenCost,
-            linesOfCode: block1.linesOfCode
+            linesOfCode: block1.linesOfCode,
+            severity,
+            reason,
+            suggestion,
+            matchedRule
           };
           duplicates.push(duplicate);
           if (streamResults) {
@@ -285,6 +447,13 @@ async function detectDuplicatePatterns(files, options) {
         if (block1.file === block2.file) continue;
         const similarity = jaccardSimilarity(blockTokens[i], blockTokens[j]);
         if (similarity >= minSimilarity) {
+          const { severity, reason, suggestion, matchedRule } = calculateSeverity(
+            block1.file,
+            block2.file,
+            block1.content,
+            similarity,
+            block1.linesOfCode
+          );
           const duplicate = {
             file1: block1.file,
             file2: block2.file,
@@ -296,7 +465,11 @@ async function detectDuplicatePatterns(files, options) {
             snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
             patternType: block1.patternType,
             tokenCost: block1.tokenCost + block2.tokenCost,
-            linesOfCode: block1.linesOfCode
+            linesOfCode: block1.linesOfCode,
+            severity,
+            reason,
+            suggestion,
+            matchedRule
           };
           duplicates.push(duplicate);
           if (streamResults) {
@@ -528,7 +701,10 @@ function generateSummary(results) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   analyzePatterns,
+  calculateSeverity,
   detectDuplicatePatterns,
+  filterBySeverity,
   generateSummary,
+  getSeverityLabel,
   getSmartDefaults
 });

package/dist/index.mjs

@@ -1,12 +1,18 @@
 import {
   analyzePatterns,
+  calculateSeverity,
   detectDuplicatePatterns,
+  filterBySeverity,
   generateSummary,
+  getSeverityLabel,
   getSmartDefaults
-} from "./chunk-65G3HXLQ.mjs";
+} from "./chunk-H73HEG7M.mjs";
 export {
   analyzePatterns,
+  calculateSeverity,
   detectDuplicatePatterns,
+  filterBySeverity,
   generateSummary,
+  getSeverityLabel,
   getSmartDefaults
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/pattern-detect",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "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",