@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/{context-rules-entry.js → chunk-TIBF7KST.mjs}

@@ -1,34 +1,10 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/context-rules-entry.ts
-var context_rules_entry_exports = {};
-__export(context_rules_entry_exports, {
-  calculateSeverity: () => calculateSeverity,
-  filterBySeverity: () => filterBySeverity,
-  getSeverityLabel: () => getSeverityLabel,
-  getSeverityThreshold: () => getSeverityThreshold
-});
-module.exports = __toCommonJS(context_rules_entry_exports);
-
 // src/context-rules.ts
-var import_core = require("@aiready/core");
+import {
+  IssueType,
+  getSeverityLabel,
+  filterBySeverity,
+  Severity
+} from "@aiready/core";
 var CONTEXT_RULES = [
   // Test Fixtures - Intentional duplication for test isolation
   {
@@ -38,7 +14,7 @@ var CONTEXT_RULES = [
       const hasTestFixtures = code.includes("beforeAll") || code.includes("afterAll") || code.includes("beforeEach") || code.includes("afterEach") || code.includes("setUp") || code.includes("tearDown");
       return isTestFile && hasTestFixtures;
     },
-    severity: import_core.Severity.Info,
+    severity: Severity.Info,
     reason: "Test fixture duplication is intentional for test isolation",
     suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
   },
@@ -50,7 +26,7 @@ var CONTEXT_RULES = [
       const hasTemplateContent = (code.includes("return") || code.includes("export")) && (code.includes("html") || code.includes("subject") || code.includes("body"));
       return isTemplate && hasTemplateContent;
     },
-    severity: import_core.Severity.Minor,
+    severity: Severity.Minor,
     reason: "Template duplication may be intentional for maintainability and branding consistency",
     suggestion: "Extract shared structure only if templates become hard to maintain"
   },
@@ -62,7 +38,7 @@ var CONTEXT_RULES = [
       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: import_core.Severity.Minor,
+    severity: Severity.Minor,
     reason: "E2E test duplication ensures test independence and reduces coupling",
     suggestion: "Consider page object pattern only if duplication causes maintenance issues"
   },
@@ -72,20 +48,21 @@ var CONTEXT_RULES = [
     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: import_core.Severity.Minor,
+    severity: Severity.Minor,
     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
+  // Only apply to .d.ts files or files in /types/ directories, not to all files containing interfaces
   {
     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;
+      const hasOnlyTypeDefinitions = (code.includes("interface ") || code.includes("type ") || code.includes("enum ")) && !code.includes("function ") && !code.includes("class ") && !code.includes("const ") && !code.includes("let ") && !code.includes("export default");
+      return isTypeFile && hasOnlyTypeDefinitions;
     },
-    severity: import_core.Severity.Info,
-    reason: "Type duplication may be intentional for module independence and type safety",
+    severity: Severity.Info,
+    reason: "Type-only files may be intentionally duplicated for module independence",
     suggestion: "Extract to shared types package only if causing maintenance burden"
   },
   // Migration Scripts - One-off scripts that are similar by nature
@@ -94,7 +71,7 @@ var CONTEXT_RULES = [
     detect: (file) => {
       return file.includes("/migrations/") || file.includes("/migrate/") || file.includes(".migration.");
     },
-    severity: import_core.Severity.Info,
+    severity: Severity.Info,
     reason: "Migration scripts are typically one-off and intentionally similar",
     suggestion: "Duplication is acceptable for migration scripts"
   },
@@ -106,7 +83,7 @@ var CONTEXT_RULES = [
       const hasMockData = code.includes("mock") || code.includes("Mock") || code.includes("fixture") || code.includes("stub") || code.includes("export const");
       return isMockFile && hasMockData;
     },
-    severity: import_core.Severity.Info,
+    severity: Severity.Info,
     reason: "Mock data duplication is expected for comprehensive test coverage",
     suggestion: "Consider shared factories only for complex mock generation"
   },
@@ -118,9 +95,56 @@ var CONTEXT_RULES = [
       const hasToolStructure = code.includes("execute") && (code.includes("try") || code.includes("catch"));
       return isToolFile && hasToolStructure;
     },
-    severity: import_core.Severity.Info,
+    severity: Severity.Info,
     reason: "Tool implementations share structural boilerplate but have distinct business logic",
     suggestion: "Tool duplication is acceptable for boilerplate interface wrappers"
+  },
+  // Common UI Event Handlers - Boilerplate by nature
+  {
+    name: "common-ui-handlers",
+    detect: (file, code) => {
+      const isUIFile = file.includes("/components/") || file.includes(".tsx") || file.includes(".jsx") || file.includes("/hooks/");
+      const hasCommonHandler = code.includes("handleClickOutside") || code.includes("handleClickInside") || code.includes("handleEscape") || code.includes("handleKeyDown") || code.includes("handleKeyUp") || code.includes("handleMouseDown") || code.includes("handleMouseUp") || code.includes("handleFocus") || code.includes("handleBlur") || code.includes("handleResize") || code.includes("handleScroll") || code.includes("handleSubmit") || code.includes("handleCancel") || code.includes("handleClose") || code.includes("handleOpen") || code.includes("handleToggle");
+      return isUIFile && hasCommonHandler;
+    },
+    severity: Severity.Minor,
+    reason: "Common UI event handlers are boilerplate patterns that repeat across components",
+    suggestion: "Consider extracting to shared hooks (useClickOutside, useEscapeKey) only if causing maintenance issues"
+  },
+  // Utility Functions - Small helpers in dedicated utility files
+  {
+    name: "utility-functions",
+    detect: (file, code) => {
+      const isUtilFile = file.endsWith(".util.ts") || file.endsWith(".helper.ts") || file.endsWith(".utils.ts");
+      const hasUtilPattern = code.includes("function format") || code.includes("function parse") || code.includes("function sanitize") || code.includes("function normalize") || code.includes("function convert");
+      return isUtilFile && hasUtilPattern;
+    },
+    severity: Severity.Minor,
+    reason: "Utility functions in dedicated utility files may be intentionally similar",
+    suggestion: "Consider extracting to shared utilities only if causing significant duplication"
+  },
+  // React/Vue Hooks - Standard patterns
+  {
+    name: "shared-hooks",
+    detect: (file, code) => {
+      const isHookFile = file.includes("/hooks/") || file.endsWith(".hook.ts") || file.endsWith(".hook.tsx");
+      const hasHookPattern = code.includes("function use") || code.includes("export function use") || code.includes("const use") || code.includes("export const use");
+      return isHookFile && hasHookPattern;
+    },
+    severity: Severity.Minor,
+    reason: "Hooks follow standard patterns and are often intentionally similar across components",
+    suggestion: "Consider extracting common hook logic only if hooks become complex"
+  },
+  // Validation Functions - Inherently similar patterns
+  {
+    name: "validation-functions",
+    detect: (file, code) => {
+      const hasValidationPattern = code.includes("isValid") || code.includes("validate") || code.includes("checkValid") || code.includes("isEmail") || code.includes("isPhone") || code.includes("isUrl") || code.includes("isNumeric") || code.includes("isAlpha") || code.includes("isAlphanumeric") || code.includes("isEmpty") || code.includes("isNotEmpty") || code.includes("isRequired") || code.includes("isOptional");
+      return hasValidationPattern;
+    },
+    severity: Severity.Minor,
+    reason: "Validation functions are inherently similar and often intentionally duplicated for domain clarity",
+    suggestion: "Consider extracting to shared validators only if validation logic becomes complex"
   }
 ];
 function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
@@ -136,72 +160,51 @@ function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
   }
   if (similarity >= 0.95 && linesOfCode >= 30) {
     return {
-      severity: import_core.Severity.Critical,
+      severity: 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: import_core.Severity.Major,
+      severity: Severity.Major,
       reason: "Nearly identical code should be consolidated",
       suggestion: "Move to shared utility file"
     };
   } else if (similarity >= 0.85) {
     return {
-      severity: import_core.Severity.Major,
+      severity: Severity.Major,
       reason: "High similarity indicates significant duplication",
       suggestion: "Extract common logic to shared function"
     };
   } else if (similarity >= 0.7) {
     return {
-      severity: import_core.Severity.Minor,
+      severity: Severity.Minor,
       reason: "Moderate similarity detected",
       suggestion: "Consider extracting shared patterns if code evolves together"
     };
   } else {
     return {
-      severity: import_core.Severity.Minor,
+      severity: Severity.Minor,
       reason: "Minor similarity detected",
       suggestion: "Monitor but refactoring may not be worthwhile"
     };
   }
 }
-function getSeverityLabel(severity) {
-  const labels = {
-    [import_core.Severity.Critical]: "\u{1F534} CRITICAL",
-    [import_core.Severity.Major]: "\u{1F7E1} MAJOR",
-    [import_core.Severity.Minor]: "\u{1F535} MINOR",
-    [import_core.Severity.Info]: "\u2139\uFE0F  INFO"
-  };
-  return labels[severity];
-}
-function filterBySeverity(duplicates, minSeverity) {
-  const severityOrder = [
-    import_core.Severity.Info,
-    import_core.Severity.Minor,
-    import_core.Severity.Major,
-    import_core.Severity.Critical
-  ];
-  const minIndex = severityOrder.indexOf(minSeverity);
-  if (minIndex === -1) return duplicates;
-  return duplicates.filter((dup) => {
-    const dupIndex = severityOrder.indexOf(dup.severity);
-    return dupIndex >= minIndex;
-  });
-}
 function getSeverityThreshold(severity) {
   const thresholds = {
-    [import_core.Severity.Critical]: 0.95,
-    [import_core.Severity.Major]: 0.85,
-    [import_core.Severity.Minor]: 0.5,
-    [import_core.Severity.Info]: 0
+    [Severity.Critical]: 0.95,
+    [Severity.Major]: 0.85,
+    [Severity.Minor]: 0.5,
+    [Severity.Info]: 0
   };
   return thresholds[severity] || 0;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calculateSeverity,
-  filterBySeverity,
+
+export {
+  IssueType,
   getSeverityLabel,
+  filterBySeverity,
+  CONTEXT_RULES,
+  calculateSeverity,
   getSeverityThreshold
-});
+};