@aiready/pattern-detect 0.17.14 → 0.17.16

package/dist/detector-entry/index.js

@@ -159,124 +159,421 @@ var INFRA_RULES = [
     severity: import_core3.Severity.Info,
     reason: "CLI command definitions follow standard Commander.js patterns and are intentionally similar",
     suggestion: "Command boilerplate duplication is acceptable for CLI interfaces"
-  }
-];
-
-// src/rules/categories/logic-rules.ts
-var import_core4 = require("@aiready/core");
-var LOGIC_RULES = [
-  // Re-export / Barrel files - Intentional API surface consolidation
+  },
+  // DynamoDB Single-Table Design - Standard single-table patterns with prefixed keys
   {
-    name: "re-export-files",
+    name: "dynamodb-single-table",
     detect: (file, code) => {
-      const isIndexFile = file.endsWith("/index.ts") || file.endsWith("/index.js") || file.endsWith("/index.tsx") || file.endsWith("/index.jsx");
-      const lines = code.split("\n").filter((l) => l.trim());
-      if (lines.length === 0) return false;
-      const reExportLines = lines.filter(
-        (l) => /^export\s+(\{[^}]+\}|\*)\s+from\s+/.test(l.trim()) || /^export\s+\*\s+as\s+\w+\s+from\s+/.test(l.trim())
-      ).length;
-      return isIndexFile && reExportLines > 0 && reExportLines / lines.length > 0.5;
+      const hasDynamoDBPattern = code.includes("docClient") || code.includes("dynamodb") || code.includes("DynamoDB") || code.includes("queryItems") || code.includes("putItem") || code.includes("getItem") || code.includes("updateItem") || code.includes("deleteItem");
+      const hasKeyPrefix = code.includes("userId:") && code.includes("#") || code.includes("pk:") && code.includes("#") || code.includes("Key:") && code.includes("#") || /[A-Z]+#/.test(code);
+      const hasSingleTablePattern = code.includes("KeyConditionExpression") || code.includes("pk =") || code.includes("sk =") || code.includes("userId") && code.includes("timestamp");
+      return hasDynamoDBPattern && (hasKeyPrefix || hasSingleTablePattern);
     },
-    severity: import_core4.Severity.Info,
-    reason: "Barrel/index files intentionally re-export for API surface consolidation",
-    suggestion: "Re-exports in barrel files are expected and not true duplication"
+    severity: import_core3.Severity.Info,
+    reason: "DynamoDB single-table design with prefixed keys is a standard pattern for efficient data access",
+    suggestion: "Single-table query patterns are intentionally similar and should not be refactored"
   },
-  // Type Definitions - Duplication for type safety and module independence
+  // CLI Main Function Boilerplate - Standard argument parsing patterns
   {
-    name: "type-definitions",
+    name: "cli-main-boilerplate",
     detect: (file, code) => {
-      const isTypeFile = file.endsWith(".d.ts") || file.includes("/types/");
-      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");
-      const isInterfaceOnlySnippet = code.trim().startsWith("interface ") && code.includes("{") && code.includes("}") && !code.includes("function ") && !code.includes("const ") && !code.includes("return ");
-      return isTypeFile && hasOnlyTypeDefinitions || isInterfaceOnlySnippet;
+      const basename = file.split("/").pop() || "";
+      const isCliFile = file.includes("/cli/") || file.includes("/commands/") || basename.startsWith("cli") || basename.endsWith(".cli.ts") || basename.endsWith(".cli.js");
+      const hasMainFunction = code.includes("function main()") || code.includes("async function main()") || code.includes("const main =") || code.includes("main()");
+      const hasArgParsing = code.includes("process.argv") || code.includes("yargs") || code.includes("commander") || code.includes("minimist") || code.includes(".parse(") || code.includes("args") && code.includes("._");
+      return isCliFile && hasMainFunction && hasArgParsing;
     },
+    severity: import_core3.Severity.Info,
+    reason: "CLI main functions with argument parsing follow standard boilerplate patterns",
+    suggestion: "CLI argument parsing boilerplate is acceptable and should not be flagged as duplication"
+  }
+];
+
+// src/rules/categories/logic/file-detectors.ts
+var FileDetectors = {
+  isIndexFile: (file) => file.endsWith("/index.ts") || file.endsWith("/index.js") || file.endsWith("/index.tsx") || file.endsWith("/index.jsx"),
+  isTypeFile: (file) => file.endsWith(".d.ts") || file.includes("/types/"),
+  isUtilFile: (file) => file.endsWith(".util.ts") || file.endsWith(".helper.ts") || file.endsWith(".utils.ts"),
+  isHookFile: (file) => file.includes("/hooks/") || file.endsWith(".hook.ts") || file.endsWith(".hook.tsx"),
+  isHelperFile: (file) => file.includes("/utils/") || file.includes("/helpers/") || file.endsWith(".util.ts"),
+  isVizFile: (file) => file.includes("/visualizer/") || file.includes("/charts/") || file.includes("GraphCanvas") || file.includes("ForceDirected"),
+  isApiFile: (file) => file.includes("/api/") || file.includes("/lib/") || file.includes("/utils/") || file.endsWith(".ts"),
+  isPackageOrApp: (file) => file.includes("/packages/") || file.includes("/apps/") || file.includes("/core/"),
+  getPackageName: (file) => {
+    const match = file.match(/\/(packages|apps|core)\/([^/]+)\//);
+    return match?.[2] || null;
+  }
+};
+
+// src/rules/categories/logic/keyword-lists.ts
+var VALIDATION_KEYWORDS = [
+  "isValid",
+  "validate",
+  "checkValid",
+  "isEmail",
+  "isPhone",
+  "isUrl",
+  "isNumeric",
+  "isAlpha",
+  "isAlphanumeric",
+  "isEmpty",
+  "isNotEmpty",
+  "isRequired",
+  "isOptional"
+];
+var HOOK_KEYWORDS = [
+  "function use",
+  "export function use",
+  "const use",
+  "export const use"
+];
+var VIZ_EVENT_KEYWORDS = ["dragstarted", "dragged", "dragended"];
+var VIZ_LIB_KEYWORDS = ["simulation", "d3.", "alphaTarget"];
+var ICON_HELPER_KEYWORDS = [
+  "getIcon",
+  "getColor",
+  "getLabel",
+  "getRating"
+];
+var UTIL_KEYWORDS = [
+  "format",
+  "parse",
+  "sanitize",
+  "normalize",
+  "convert",
+  "utility",
+  "helper"
+];
+
+// src/rules/categories/logic/detectors.ts
+var isEnumDefinition = (code) => /(?:export\s+)?(?:const\s+)?enum\s+/.test(code) || code.includes("enum ") && code.includes("{") && code.includes("}");
+var hasSingletonGetter = (code) => /(?:export\s+)?(?:async\s+)?function\s+get[A-Z][a-zA-Z0-9]*\s*\(/.test(
+  code
+) || /(?:export\s+)?const\s+get[A-Z][a-zA-Z0-9]*\s*=\s*(?:async\s+)?\(\)\s*=>/.test(
+  code
+);
+var hasSingletonPattern = (code) => code.includes("if (!") && code.includes("instance") && code.includes(" = ") || code.includes("if (!_") && code.includes(" = new ");
+var hasReExportPattern = (code) => {
+  const lines = code.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return false;
+  const reExportLines = lines.filter(
+    (l) => /^export\s+(\{[^}]+\}|\*)\s+from\s+/.test(l.trim()) || /^export\s+\*\s+as\s+\w+\s+from\s+/.test(l.trim())
+  ).length;
+  return reExportLines > 0 && reExportLines / lines.length > 0.5;
+};
+var isInterfaceOnlySnippet = (code) => {
+  const hasInterface = code.includes("interface ");
+  const hasType = code.includes("type ");
+  const hasEnum = code.includes("enum ");
+  const hasNoImpl = ![
+    "function ",
+    "class ",
+    "const ",
+    "let ",
+    "var ",
+    "export default",
+    "export {"
+  ].some((kw) => code.includes(kw));
+  return (hasInterface || hasType || hasEnum) && hasNoImpl;
+};
+
+// src/rules/categories/logic/code-patterns.ts
+var COMMON_ENUM_PATTERNS = [
+  ["LOW", ["'low'", "0", "'LOW'"]],
+  ["HIGH", ["'high'", "2", "'HIGH'"]],
+  ["MEDIUM", ["'medium'", "1", "'MEDIUM'"]]
+];
+var hasEnumValue = (code, enumName, variants) => variants.some((v) => code.includes(`${enumName} = ${v}`));
+var CodePatterns = {
+  // Enum patterns
+  hasCommonEnumValues: (code) => COMMON_ENUM_PATTERNS.every(
+    ([name, variants]) => hasEnumValue(code, name, variants)
+  ),
+  isEnumDefinition,
+  // Type patterns - helpers for checking type-only definitions
+  hasTypeDefinition: (code) => code.includes("interface ") || code.includes("type ") || code.includes("enum "),
+  isTypeOnlyFile: (code) => {
+    const hasTypes = CodePatterns.hasTypeDefinition(code);
+    const hasNoImpl = ![
+      "function ",
+      "class ",
+      "const ",
+      "let ",
+      "export default"
+    ].some((kw) => code.includes(kw));
+    return hasTypes && hasNoImpl;
+  },
+  hasOnlyTypeDefinitions: (code) => {
+    const hasTypes = CodePatterns.hasTypeDefinition(code);
+    const hasNoImpl = ![
+      "function ",
+      "class ",
+      "const ",
+      "let ",
+      "var ",
+      "export default",
+      "export {"
+    ].some((kw) => code.includes(kw));
+    return hasTypes && hasNoImpl;
+  },
+  // Utility patterns - function group patterns
+  hasUtilPattern: (code) => CodePatterns.hasFunctionGroup(code, "") || CodePatterns.hasKeywordGroup(code, UTIL_KEYWORDS),
+  hasFunctionGroup: (code, prefix) => {
+    const regex = new RegExp(
+      `${prefix}(format|parse|sanitize|normalize|convert)`,
+      "i"
+    );
+    return regex.test(code);
+  },
+  // Pattern checkers using keyword lists
+  hasKeywordGroup: (code, keywords) => keywords.some((kw) => code.includes(kw)),
+  // Validation patterns - unified keyword check
+  hasValidationPattern: (code) => CodePatterns.hasKeywordGroup(code, VALIDATION_KEYWORDS),
+  // Hook patterns - React/Vue hooks
+  hasHookPattern: (code) => CodePatterns.hasKeywordGroup(code, HOOK_KEYWORDS),
+  // Score/Rating patterns
+  hasScorePattern: (code) => (code.includes("if (score >=") || code.includes("if (score >")) && code.includes("return") && code.includes("'") && code.split("if (score").length >= 3,
+  // Visualization patterns - D3/Canvas
+  hasVizPattern: (code) => CodePatterns.hasKeywordGroup(code, VIZ_EVENT_KEYWORDS) && CodePatterns.hasKeywordGroup(code, VIZ_LIB_KEYWORDS),
+  // Switch/Icon patterns
+  hasSwitchPattern: (code) => code.includes("switch (") && code.includes("case '") && code.includes("return") && code.split("case ").length >= 4,
+  hasIconPattern: (code) => CodePatterns.hasKeywordGroup(code, ICON_HELPER_KEYWORDS),
+  // Singleton patterns
+  hasSingletonGetter,
+  hasSingletonPattern,
+  // Re-export patterns
+  hasReExportPattern,
+  // Interface-only snippets
+  isInterfaceOnlySnippet
+};
+
+// src/rules/categories/logic/api-patterns.ts
+var API_PATTERNS = {
+  stripe: {
+    functions: ["getStripe"],
+    keywords: ["process.env.STRIPE_SECRET_KEY"]
+  },
+  userManagement: {
+    functions: ["getUserByEmail"],
+    keywords: ["queryItems"]
+  },
+  userUpdate: {
+    functions: ["updateUser"],
+    keywords: ["buildUpdateExpression"]
+  },
+  repositoryListing: {
+    functions: ["listUserRepositories", "listTeamRepositories"],
+    keywords: ["queryItems"]
+  },
+  remediationQueries: {
+    functions: ["getRemediation"],
+    keywords: ["queryItems"]
+  },
+  keyFormatting: {
+    functions: ["formatBreakdownKey"],
+    keywords: [".replace(/([A-Z])/g"]
+  },
+  dynamoDbQueries: {
+    functions: ["queryItems"],
+    keywords: ["KeyConditionExpression"]
+  },
+  itemOperations: {
+    functions: ["putItem"],
+    keywords: ["createdAt"]
+  },
+  itemUpdates: {
+    functions: ["updateItem"],
+    keywords: ["buildUpdateExpression"]
+  }
+};
+var ApiPatterns = {
+  /**
+   * Check if code contains a common API pattern
+   * Reduces from 11 separate || conditions to single call
+   */
+  hasCommonApiPattern: (code) => {
+    for (const pattern of Object.values(API_PATTERNS)) {
+      const hasFunctions = pattern.functions.some((fn) => code.includes(fn));
+      const hasKeywords = pattern.keywords.some((kw) => code.includes(kw));
+      if (hasFunctions && hasKeywords) {
+        return true;
+      }
+    }
+    return false;
+  },
+  /**
+   * Get all API patterns (useful for documentation/analysis)
+   */
+  getPatterns: () => API_PATTERNS,
+  /**
+   * Check if code matches a specific API pattern by name
+   */
+  matchesPattern: (code, patternName) => {
+    const pattern = API_PATTERNS[patternName];
+    if (!pattern) return false;
+    const hasFunctions = pattern.functions.some((fn) => code.includes(fn));
+    const hasKeywords = pattern.keywords.some((kw) => code.includes(kw));
+    return hasFunctions && hasKeywords;
+  }
+};
+
+// src/rules/categories/logic/rule-builders.ts
+var import_core4 = require("@aiready/core");
+function createRule(config) {
+  return {
+    name: config.name,
+    detect: config.detect,
+    severity: config.severity || import_core4.Severity.Info,
+    reason: config.reason,
+    suggestion: config.suggestion
+  };
+}
+var RuleTemplates = {
+  // Type-related rules
+  typeDefinition: {
     severity: import_core4.Severity.Info,
     reason: "Type/interface definitions are intentionally duplicated for module independence",
     suggestion: "Extract to shared types package only if causing maintenance burden"
   },
-  // 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;
-    },
+  crossPackageType: {
     severity: import_core4.Severity.Info,
-    reason: "Utility functions in dedicated utility files may be intentionally similar",
+    reason: "Types in different packages/modules are often intentionally similar for module independence",
+    suggestion: "Cross-package type duplication is acceptable for decoupled module architecture"
+  },
+  // Pattern rules
+  standardPatterns: {
+    severity: import_core4.Severity.Info,
+    reason: "This pattern is inherently similar and intentionally duplicated across modules",
+    suggestion: "Pattern duplication is acceptable for domain clarity and independence"
+  },
+  // API rules
+  commonApiFunction: {
+    severity: import_core4.Severity.Info,
+    reason: "Common API/utility functions are legitimately duplicated across modules for clarity and independence",
     suggestion: "Consider extracting to shared utilities only if causing significant duplication"
   },
-  // React/Vue Hooks - Standard patterns
-  {
-    name: "shared-hooks",
+  // Utility rules
+  utilityFunction: {
+    severity: import_core4.Severity.Info,
+    reason: "Utility functions may be intentionally similar across modules",
+    suggestion: "Consider extracting to shared utilities only if causing significant duplication"
+  },
+  // Boilerplate rules
+  boilerplate: {
+    severity: import_core4.Severity.Info,
+    reason: "This pattern is boilerplate and acceptable duplication",
+    suggestion: "Boilerplate reduction is acceptable for standard patterns"
+  },
+  // Enum rules
+  enumSemantic: {
+    severity: import_core4.Severity.Info,
+    reason: "Enums with different names represent different semantic domain concepts, even if they share similar values",
+    suggestion: "Different enums (e.g., EscalationPriority vs HealthSeverity) serve different purposes and should not be merged"
+  },
+  enumValue: {
+    severity: import_core4.Severity.Info,
+    reason: "Common enum values (LOW, MEDIUM, HIGH, CRITICAL) are standard patterns used across different domain enums",
+    suggestion: "Enum value similarity is expected for severity/priority enums and should not be flagged as duplication"
+  },
+  // Barrel file rules
+  barrelFile: {
+    severity: import_core4.Severity.Info,
+    reason: "Barrel/index files intentionally re-export for API surface consolidation",
+    suggestion: "Re-exports in barrel files are expected and not true duplication"
+  }
+};
+
+// src/rules/categories/logic-rules.ts
+var LOGIC_RULES = [
+  // Enum patterns - identify by semantic meaning and value patterns
+  createRule({
+    name: "enum-semantic-difference",
+    detect: (file, code) => CodePatterns.isEnumDefinition(code),
+    ...RuleTemplates.enumSemantic
+  }),
+  createRule({
+    name: "enum-value-similarity",
+    detect: (file, code) => CodePatterns.hasCommonEnumValues(code) && CodePatterns.isEnumDefinition(code),
+    ...RuleTemplates.enumValue
+  }),
+  // Barrel/re-export files - intentional API consolidation
+  createRule({
+    name: "re-export-files",
+    detect: (file, code) => FileDetectors.isIndexFile(file) && CodePatterns.hasReExportPattern(code),
+    ...RuleTemplates.barrelFile
+  }),
+  // Type definitions - consolidated rule for both local and cross-package types
+  // PHASE 2 CONSOLIDATION: merged type-definitions + cross-package-types
+  createRule({
+    name: "type-definitions",
     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;
+      if (FileDetectors.isTypeFile(file)) {
+        if (CodePatterns.hasOnlyTypeDefinitions(code)) return true;
+      }
+      if (CodePatterns.isInterfaceOnlySnippet(code)) return true;
+      if (FileDetectors.isPackageOrApp(file) && FileDetectors.getPackageName(file) !== null && CodePatterns.hasTypeDefinition(code)) {
+        return true;
+      }
+      return false;
     },
-    severity: import_core4.Severity.Info,
+    reason: "Type/interface definitions are intentionally duplicated for module independence and decoupled module architecture",
+    suggestion: "Extract to shared types package only if causing significant maintenance burden or cross-package conflicts"
+  }),
+  // Utility functions - dedicated utility file patterns
+  createRule({
+    name: "utility-functions",
+    detect: (file, code) => FileDetectors.isUtilFile(file) && CodePatterns.hasUtilPattern(code),
+    ...RuleTemplates.utilityFunction
+  }),
+  // React/Vue Hooks - standard hook patterns
+  createRule({
+    name: "shared-hooks",
+    detect: (file, code) => FileDetectors.isHookFile(file) && CodePatterns.hasHookPattern(code),
     reason: "Hooks follow standard patterns and are often intentionally similar across components",
     suggestion: "Consider extracting common hook logic only if hooks become complex"
-  },
-  // Score/Rating Helper Functions - Common threshold patterns
-  {
+  }),
+  // Score/Rating helpers - common threshold patterns
+  createRule({
     name: "score-helpers",
-    detect: (file, code) => {
-      const isHelperFile = file.includes("/utils/") || file.includes("/helpers/") || file.endsWith(".util.ts");
-      const hasScorePattern = (code.includes("if (score >=") || code.includes("if (score >")) && code.includes("return") && code.includes("'") && code.split("if (score").length >= 3;
-      return isHelperFile && hasScorePattern;
-    },
-    severity: import_core4.Severity.Info,
+    detect: (file, code) => (FileDetectors.isHelperFile(file) || file.includes("/utils/")) && CodePatterns.hasScorePattern(code),
     reason: "Score/rating helper functions use common threshold patterns that are intentionally similar",
     suggestion: "Score formatting duplication is acceptable for consistent UI display"
-  },
-  // D3/Canvas Event Handlers - Standard visualization patterns
-  {
+  }),
+  // D3/Canvas event handlers - visualization patterns
+  createRule({
     name: "visualization-handlers",
-    detect: (file, code) => {
-      const isVizFile = file.includes("/visualizer/") || file.includes("/charts/") || file.includes("GraphCanvas") || file.includes("ForceDirected");
-      const hasVizPattern = (code.includes("dragstarted") || code.includes("dragged") || code.includes("dragended")) && (code.includes("simulation") || code.includes("d3.") || code.includes("alphaTarget"));
-      return isVizFile && hasVizPattern;
-    },
-    severity: import_core4.Severity.Info,
+    detect: (file, code) => FileDetectors.isVizFile(file) && CodePatterns.hasVizPattern(code),
     reason: "D3/visualization event handlers follow standard patterns and are intentionally similar",
     suggestion: "Visualization boilerplate duplication is acceptable for interactive charts"
-  },
-  // Icon/Switch Statement Helpers - Common enum-to-value patterns
-  {
+  }),
+  // Switch statement helpers - enum-to-value mapping
+  createRule({
     name: "switch-helpers",
-    detect: (file, code) => {
-      const hasSwitchPattern = code.includes("switch (") && code.includes("case '") && code.includes("return") && code.split("case ").length >= 4;
-      const hasIconPattern = code.includes("getIcon") || code.includes("getColor") || code.includes("getLabel") || code.includes("getRating");
-      return hasSwitchPattern && hasIconPattern;
-    },
-    severity: import_core4.Severity.Info,
+    detect: (file, code) => CodePatterns.hasSwitchPattern(code) && CodePatterns.hasIconPattern(code),
     reason: "Switch statement helpers for enum-to-value mapping are inherently similar",
     suggestion: "Switch duplication is acceptable for mapping enums to display values"
-  },
-  // Common API/Utility Functions - Legitimate duplication across modules
-  {
+  }),
+  // Common API/Utility functions - legitimately duplicated across modules
+  createRule({
     name: "common-api-functions",
-    detect: (file, code) => {
-      const isApiFile = file.includes("/api/") || file.includes("/lib/") || file.includes("/utils/") || file.endsWith(".ts");
-      const hasCommonApiPattern = code.includes("getStripe") && code.includes("process.env.STRIPE_SECRET_KEY") || code.includes("getUserByEmail") && code.includes("queryItems") || code.includes("updateUser") && code.includes("buildUpdateExpression") || code.includes("listUserRepositories") && code.includes("queryItems") || code.includes("listTeamRepositories") && code.includes("queryItems") || code.includes("getRemediation") && code.includes("queryItems") || code.includes("formatBreakdownKey") && code.includes(".replace(/([A-Z])/g") || code.includes("queryItems") && code.includes("KeyConditionExpression") || code.includes("putItem") && code.includes("createdAt") || code.includes("updateItem") && code.includes("buildUpdateExpression");
-      return isApiFile && hasCommonApiPattern;
-    },
-    severity: import_core4.Severity.Info,
-    reason: "Common API/utility functions are legitimately duplicated across modules for clarity and independence",
-    suggestion: "Consider extracting to shared utilities only if causing significant duplication"
-  },
-  // Validation Functions - Inherently similar patterns
-  {
+    detect: (file, code) => FileDetectors.isApiFile(file) && ApiPatterns.hasCommonApiPattern(code),
+    ...RuleTemplates.commonApiFunction
+  }),
+  // Validation functions - inherently similar patterns
+  // PHASE 2: Consolidated validation-function branches into single rule
+  createRule({
     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: import_core4.Severity.Info,
+    detect: (file, code) => CodePatterns.hasValidationPattern(code),
     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"
-  }
+  }),
+  // Singleton getter pattern - standard initialization
+  createRule({
+    name: "singleton-getter",
+    detect: (file, code) => CodePatterns.hasSingletonGetter(code) && CodePatterns.hasSingletonPattern(code),
+    reason: "Singleton getter functions follow standard initialization pattern and are intentionally similar",
+    suggestion: "Singleton getters are boilerplate and acceptable duplication for lazy initialization"
+  })
 ];
 
 // src/context-rules.ts
@@ -309,7 +606,7 @@ function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
       reason: "Nearly identical code should be consolidated",
       suggestion: "Move to shared utility file"
     };
-  } else if (similarity >= 0.85) {
+  } else if (similarity >= 0.85 && linesOfCode >= 10) {
     return {
       severity: import_core5.Severity.Major,
       reason: "High similarity indicates significant duplication",
@@ -363,7 +660,10 @@ async function detectDuplicatePatterns(fileContents, options) {
     ignoreWhitelist = []
   } = options;
   const allBlocks = [];
-  const excludeRegexes = excludePatterns.map((p) => new RegExp(p, "i"));
+  const regexStr = (f) => f.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "[^/]*").replace(/\[\^\/\]\*\[\^\/\]\*/g, ".*");
+  const excludeRegexes = excludePatterns.map(
+    (p) => new RegExp(`${regexStr(p)}$`, "i")
+  );
   for (const { file, content } of fileContents) {
     const blocks = extractBlocks(file, content);
     for (const b of blocks) {

package/dist/detector-entry/index.mjs

@@ -1,7 +1,7 @@
 import {
   detectDuplicatePatterns
-} from "../chunk-RH5JPWEC.mjs";
-import "../chunk-UKQFCUQA.mjs";
+} from "../chunk-XR373Q6G.mjs";
+import "../chunk-XWIBTD67.mjs";
 export {
   detectDuplicatePatterns
 };