@aiready/pattern-detect 0.17.8 → 0.17.12

package/dist/detector-entry/index.js

@@ -25,11 +25,14 @@ __export(detector_entry_exports, {
 module.exports = __toCommonJS(detector_entry_exports);
 
 // src/detector.ts
-var import_core2 = require("@aiready/core");
+var import_core6 = require("@aiready/core");
 
 // src/context-rules.ts
+var import_core5 = require("@aiready/core");
+
+// src/rules/categories/test-rules.ts
 var import_core = require("@aiready/core");
-var CONTEXT_RULES = [
+var TEST_RULES = [
   // Test Fixtures - Intentional duplication for test isolation
   {
     name: "test-fixtures",
@@ -42,6 +45,35 @@ var CONTEXT_RULES = [
     reason: "Test fixture duplication is intentional for test isolation",
     suggestion: "Consider if shared test setup would improve maintainability without coupling tests"
   },
+  // 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: import_core.Severity.Info,
+    reason: "E2E test duplication ensures test independence and reduces coupling",
+    suggestion: "Consider page object pattern only if duplication causes maintenance issues"
+  },
+  // 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: import_core.Severity.Info,
+    reason: "Mock data duplication is expected for comprehensive test coverage",
+    suggestion: "Consider shared factories only for complex mock generation"
+  }
+];
+
+// src/rules/categories/web-rules.ts
+var import_core2 = require("@aiready/core");
+var WEB_RULES = [
   // Email/Document Templates - Often intentionally similar for consistency
   {
     name: "templates",
@@ -50,66 +82,59 @@ 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: import_core2.Severity.Info,
     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
+  // Common UI Event Handlers - Very specific patterns only
   {
-    name: "e2e-page-objects",
+    name: "common-ui-handlers",
     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;
+      const isUIFile = file.includes("/components/") || file.includes(".tsx") || file.includes(".jsx") || file.includes("/hooks/");
+      const hasCommonHandler = code.includes("handleClickOutside") && code.includes("dropdownRef.current") && code.includes("!dropdownRef.current.contains") || code.includes("handleEscape") && code.includes("event.key") && code.includes("=== 'Escape'") || code.includes("handleClickInside") && code.includes("event.stopPropagation");
+      return isUIFile && hasCommonHandler;
     },
-    severity: import_core.Severity.Minor,
-    reason: "E2E test duplication ensures test independence and reduces coupling",
-    suggestion: "Consider page object pattern only if duplication causes maintenance issues"
+    severity: import_core2.Severity.Info,
+    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"
   },
+  // Next.js Route Handler Patterns - Boilerplate API route patterns
+  {
+    name: "nextjs-route-handlers",
+    detect: (file, code) => {
+      const isRouteFile = file.includes("/api/") && (file.endsWith("/route.ts") || file.endsWith("/route.js"));
+      const hasRoutePattern = code.includes("export async function POST") || code.includes("export async function GET") || code.includes("export async function PUT") || code.includes("export async function DELETE") || code.includes("NextResponse.json") || code.includes("NextRequest");
+      return isRouteFile && hasRoutePattern;
+    },
+    severity: import_core2.Severity.Info,
+    reason: "Next.js route handlers follow standard patterns and are intentionally similar across endpoints",
+    suggestion: "Route handler duplication is acceptable for API endpoint boilerplate"
+  }
+];
+
+// src/rules/categories/infra-rules.ts
+var import_core3 = require("@aiready/core");
+var INFRA_RULES = [
   // 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: import_core.Severity.Minor,
+    severity: import_core3.Severity.Info,
     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: import_core.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: import_core.Severity.Info,
+    severity: import_core3.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: import_core.Severity.Info,
-    reason: "Mock data duplication is expected for comprehensive test coverage",
-    suggestion: "Consider shared factories only for complex mock generation"
-  },
   // Tool Implementations - Structural Boilerplate
   {
     name: "tool-implementations",
@@ -118,11 +143,132 @@ var CONTEXT_RULES = [
       const hasToolStructure = code.includes("execute") && (code.includes("try") || code.includes("catch"));
       return isToolFile && hasToolStructure;
     },
-    severity: import_core.Severity.Info,
+    severity: import_core3.Severity.Info,
     reason: "Tool implementations share structural boilerplate but have distinct business logic",
     suggestion: "Tool duplication is acceptable for boilerplate interface wrappers"
+  },
+  // CLI Command Definitions - Commander.js boilerplate patterns
+  {
+    name: "cli-command-definitions",
+    detect: (file, code) => {
+      const isCliFile = file.includes("/commands/") || file.includes("/cli/") || file.endsWith(".command.ts");
+      const hasCommandPattern = (code.includes(".command(") || code.includes("defineCommand")) && (code.includes(".description(") || code.includes(".option(")) && (code.includes(".action(") || code.includes("async"));
+      return isCliFile && hasCommandPattern;
+    },
+    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 = [
+  // 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 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;
+    },
+    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;
+    },
+    severity: import_core4.Severity.Info,
+    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: import_core4.Severity.Info,
+    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
+  {
+    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,
+    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
+  {
+    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,
+    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
+  {
+    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,
+    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
+  {
+    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
+  {
+    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,
+    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"
   }
 ];
+
+// src/context-rules.ts
+var CONTEXT_RULES = [
+  ...TEST_RULES,
+  ...WEB_RULES,
+  ...INFRA_RULES,
+  ...LOGIC_RULES
+];
 function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
   for (const rule of CONTEXT_RULES) {
     if (rule.detect(file1, code) || rule.detect(file2, code)) {
@@ -136,31 +282,31 @@ function calculateSeverity(file1, file2, code, similarity, linesOfCode) {
   }
   if (similarity >= 0.95 && linesOfCode >= 30) {
     return {
-      severity: import_core.Severity.Critical,
+      severity: import_core5.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: import_core5.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: import_core5.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: import_core5.Severity.Minor,
       reason: "Moderate similarity detected",
       suggestion: "Consider extracting shared patterns if code evolves together"
     };
   } else {
     return {
-      severity: import_core.Severity.Minor,
+      severity: import_core5.Severity.Minor,
       reason: "Minor similarity detected",
       suggestion: "Monitor but refactoring may not be worthwhile"
     };
@@ -181,13 +327,13 @@ function normalizeCode(code, isPython = false) {
 
 // src/detector.ts
 function extractBlocks(file, content) {
-  return (0, import_core2.extractCodeBlocks)(file, content);
+  return (0, import_core6.extractCodeBlocks)(file, content);
 }
 function calculateSimilarity(a, b) {
-  return (0, import_core2.calculateStringSimilarity)(a, b);
+  return (0, import_core6.calculateStringSimilarity)(a, b);
 }
 function calculateConfidence(similarity, tokens, lines) {
-  return (0, import_core2.calculateHeuristicConfidence)(similarity, tokens, lines);
+  return (0, import_core6.calculateHeuristicConfidence)(similarity, tokens, lines);
 }
 async function detectDuplicatePatterns(fileContents, options) {
   const {

package/dist/detector-entry/index.mjs

@@ -1,7 +1,7 @@
 import {
   detectDuplicatePatterns
-} from "../chunk-NQBYYWHJ.mjs";
-import "../chunk-J2G742QF.mjs";
+} from "../chunk-IPBGVPUX.mjs";
+import "../chunk-2P7BQHGR.mjs";
 export {
   detectDuplicatePatterns
 };

package/dist/{analyzer-entry-BVz-HnZd.d.mts → index-B-pnXpgn.d.mts}

@@ -49,6 +49,15 @@ declare function createRefactorClusters(duplicates: DuplicatePattern[]): Refacto
  * @returns Filtered array of refactor clusters
  */
 declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
+/**
+ * Detect if two duplicate files are likely brand-specific variants
+ * (e.g., different themed versions of the same UI component)
+ */
+declare function areBrandSpecificVariants(file1: string, file2: string, code1: string, code2: string): boolean;
+/**
+ * Filter out brand-specific variants from duplicates
+ */
+declare function filterBrandSpecificVariants(duplicates: DuplicatePattern[]): DuplicatePattern[];
 
 interface PatternDetectOptions extends ScanOptions {
     minSimilarity?: number;
@@ -116,4 +125,4 @@ declare function analyzePatterns(options: PatternDetectOptions): Promise<{
  */
 declare function generateSummary(results: AnalysisResult[]): PatternSummary;
 
-export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, createRefactorClusters as c, getSmartDefaults as d, groupDuplicatesByFilePair as e, filterClustersByImpact as f, generateSummary as g };
+export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, areBrandSpecificVariants as c, createRefactorClusters as d, filterClustersByImpact as e, filterBrandSpecificVariants as f, generateSummary as g, getSmartDefaults as h, groupDuplicatesByFilePair as i };

package/dist/{index-BwuoiCNm.d.ts → index-CWgYOKaK.d.ts}

@@ -1,4 +1,4 @@
-import { Severity, ScanOptions, AnalysisResult } from '@aiready/core';
+import { Severity, ScanOptions, Issue, AnalysisResult } from '@aiready/core';
 import { P as PatternType, D as DuplicatePattern } from './types-DU2mmhwb.js';
 
 interface DuplicateGroup {
@@ -49,6 +49,15 @@ declare function createRefactorClusters(duplicates: DuplicatePattern[]): Refacto
  * @returns Filtered array of refactor clusters
  */
 declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
+/**
+ * Detect if two duplicate files are likely brand-specific variants
+ * (e.g., different themed versions of the same UI component)
+ */
+declare function areBrandSpecificVariants(file1: string, file2: string, code1: string, code2: string): boolean;
+/**
+ * Filter out brand-specific variants from duplicates
+ */
+declare function filterBrandSpecificVariants(duplicates: DuplicatePattern[]): DuplicatePattern[];
 
 interface PatternDetectOptions extends ScanOptions {
     minSimilarity?: number;
@@ -70,6 +79,15 @@ interface PatternDetectOptions extends ScanOptions {
     ignoreWhitelist?: string[];
     onProgress?: (processed: number, total: number, message: string) => void;
 }
+/**
+ * Determine smart defaults based on repository size estimation.
+ */
+declare function getSmartDefaults(directory: string, userOptions: Partial<PatternDetectOptions>): Promise<PatternDetectOptions>;
+/**
+ * Log current configuration settings to the console.
+ */
+declare function logConfiguration(config: PatternDetectOptions, estimatedBlocks: number): void;
+
 interface PatternSummary {
     totalPatterns: number;
     totalTokenCost: number;
@@ -86,19 +104,27 @@ interface PatternSummary {
     }>;
 }
 /**
- * Determine smart defaults based on repository size estimation.
- *
- * @param directory - The directory to analyze for size.
- * @param userOptions - User-provided option overrides.
- * @returns Promise resolving to optimal detection options.
+ * Generate a summary of pattern detection results.
  */
-declare function getSmartDefaults(directory: string, userOptions: Partial<PatternDetectOptions>): Promise<PatternDetectOptions>;
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+/**
+ * Filter issues by severity level.
+ */
+declare function filterBySeverity(issues: Issue[], severity: string): Issue[];
+/**
+ * Get human-readable label for severity.
+ */
+declare function getSeverityLabel(severity: Severity): string;
+/**
+ * Calculate severity based on similarity.
+ */
+declare function calculateSeverity(similarity: number): Severity;
+
 /**
  * Main entry point for pattern detection analysis.
  *
  * @param options - Configuration including rootDir and detection parameters.
  * @returns Promise resolving to the comprehensive pattern detect report.
- * @lastUpdated 2026-03-18
  */
 declare function analyzePatterns(options: PatternDetectOptions): Promise<{
     results: AnalysisResult[];
@@ -108,12 +134,5 @@ declare function analyzePatterns(options: PatternDetectOptions): Promise<{
     clusters?: RefactorCluster[];
     config: PatternDetectOptions;
 }>;
-/**
- * Generate a summary of pattern detection results.
- *
- * @param results - Array of file-level analysis results.
- * @returns Consolidated pattern summary object.
- */
-declare function generateSummary(results: AnalysisResult[]): PatternSummary;
 
-export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, createRefactorClusters as c, getSmartDefaults as d, groupDuplicatesByFilePair as e, filterClustersByImpact as f, generateSummary as g };
+export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, areBrandSpecificVariants as c, calculateSeverity as d, createRefactorClusters as e, filterBrandSpecificVariants as f, filterBySeverity as g, filterClustersByImpact as h, generateSummary as i, getSeverityLabel as j, getSmartDefaults as k, groupDuplicatesByFilePair as l, logConfiguration as m };

package/dist/{index-BVz-HnZd.d.mts → index-Dl4BrGIT.d.mts}

@@ -1,4 +1,4 @@
-import { Severity, ScanOptions, AnalysisResult } from '@aiready/core';
+import { Severity, ScanOptions, Issue, AnalysisResult } from '@aiready/core';
 import { P as PatternType, D as DuplicatePattern } from './types-DU2mmhwb.mjs';
 
 interface DuplicateGroup {
@@ -49,6 +49,15 @@ declare function createRefactorClusters(duplicates: DuplicatePattern[]): Refacto
  * @returns Filtered array of refactor clusters
  */
 declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
+/**
+ * Detect if two duplicate files are likely brand-specific variants
+ * (e.g., different themed versions of the same UI component)
+ */
+declare function areBrandSpecificVariants(file1: string, file2: string, code1: string, code2: string): boolean;
+/**
+ * Filter out brand-specific variants from duplicates
+ */
+declare function filterBrandSpecificVariants(duplicates: DuplicatePattern[]): DuplicatePattern[];
 
 interface PatternDetectOptions extends ScanOptions {
     minSimilarity?: number;
@@ -70,6 +79,15 @@ interface PatternDetectOptions extends ScanOptions {
     ignoreWhitelist?: string[];
     onProgress?: (processed: number, total: number, message: string) => void;
 }
+/**
+ * Determine smart defaults based on repository size estimation.
+ */
+declare function getSmartDefaults(directory: string, userOptions: Partial<PatternDetectOptions>): Promise<PatternDetectOptions>;
+/**
+ * Log current configuration settings to the console.
+ */
+declare function logConfiguration(config: PatternDetectOptions, estimatedBlocks: number): void;
+
 interface PatternSummary {
     totalPatterns: number;
     totalTokenCost: number;
@@ -86,19 +104,27 @@ interface PatternSummary {
     }>;
 }
 /**
- * Determine smart defaults based on repository size estimation.
- *
- * @param directory - The directory to analyze for size.
- * @param userOptions - User-provided option overrides.
- * @returns Promise resolving to optimal detection options.
+ * Generate a summary of pattern detection results.
  */
-declare function getSmartDefaults(directory: string, userOptions: Partial<PatternDetectOptions>): Promise<PatternDetectOptions>;
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+/**
+ * Filter issues by severity level.
+ */
+declare function filterBySeverity(issues: Issue[], severity: string): Issue[];
+/**
+ * Get human-readable label for severity.
+ */
+declare function getSeverityLabel(severity: Severity): string;
+/**
+ * Calculate severity based on similarity.
+ */
+declare function calculateSeverity(similarity: number): Severity;
+
 /**
  * Main entry point for pattern detection analysis.
  *
  * @param options - Configuration including rootDir and detection parameters.
  * @returns Promise resolving to the comprehensive pattern detect report.
- * @lastUpdated 2026-03-18
  */
 declare function analyzePatterns(options: PatternDetectOptions): Promise<{
     results: AnalysisResult[];
@@ -108,12 +134,5 @@ declare function analyzePatterns(options: PatternDetectOptions): Promise<{
     clusters?: RefactorCluster[];
     config: PatternDetectOptions;
 }>;
-/**
- * Generate a summary of pattern detection results.
- *
- * @param results - Array of file-level analysis results.
- * @returns Consolidated pattern summary object.
- */
-declare function generateSummary(results: AnalysisResult[]): PatternSummary;
 
-export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, createRefactorClusters as c, getSmartDefaults as d, groupDuplicatesByFilePair as e, filterClustersByImpact as f, generateSummary as g };
+export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, areBrandSpecificVariants as c, calculateSeverity as d, createRefactorClusters as e, filterBrandSpecificVariants as f, filterBySeverity as g, filterClustersByImpact as h, generateSummary as i, getSeverityLabel as j, getSmartDefaults as k, groupDuplicatesByFilePair as l, logConfiguration as m };

package/dist/{analyzer-entry-BwuoiCNm.d.ts → index-DqS2e0kK.d.ts}

@@ -49,6 +49,15 @@ declare function createRefactorClusters(duplicates: DuplicatePattern[]): Refacto
  * @returns Filtered array of refactor clusters
  */
 declare function filterClustersByImpact(clusters: RefactorCluster[], minTokenCost?: number, minFiles?: number): RefactorCluster[];
+/**
+ * Detect if two duplicate files are likely brand-specific variants
+ * (e.g., different themed versions of the same UI component)
+ */
+declare function areBrandSpecificVariants(file1: string, file2: string, code1: string, code2: string): boolean;
+/**
+ * Filter out brand-specific variants from duplicates
+ */
+declare function filterBrandSpecificVariants(duplicates: DuplicatePattern[]): DuplicatePattern[];
 
 interface PatternDetectOptions extends ScanOptions {
     minSimilarity?: number;
@@ -116,4 +125,4 @@ declare function analyzePatterns(options: PatternDetectOptions): Promise<{
  */
 declare function generateSummary(results: AnalysisResult[]): PatternSummary;
 
-export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, createRefactorClusters as c, getSmartDefaults as d, groupDuplicatesByFilePair as e, filterClustersByImpact as f, generateSummary as g };
+export { type DuplicateGroup as D, type PatternDetectOptions as P, type RefactorCluster as R, type PatternSummary as a, analyzePatterns as b, areBrandSpecificVariants as c, createRefactorClusters as d, filterClustersByImpact as e, filterBrandSpecificVariants as f, generateSummary as g, getSmartDefaults as h, groupDuplicatesByFilePair as i };

package/dist/index.d.mts

@@ -1,14 +1,13 @@
 import { ToolProvider } from '@aiready/core';
-export { IssueType, Severity, filterBySeverity, getSeverityLabel } from '@aiready/core';
-export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './index-BVz-HnZd.mjs';
+export { Severity } from '@aiready/core';
 export { detectDuplicatePatterns } from './detector-entry/index.mjs';
-export { calculatePatternScore } from './scoring-entry/index.mjs';
-export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, g as getSeverityThreshold } from './index-szjQDBsm.mjs';
+export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as areBrandSpecificVariants, d as calculateSeverity, e as createRefactorClusters, f as filterBrandSpecificVariants, g as filterBySeverity, h as filterClustersByImpact, i as generateSummary, j as getSeverityLabel, k as getSmartDefaults, l as groupDuplicatesByFilePair, m as logConfiguration } from './index-Dl4BrGIT.mjs';
 export { D as DuplicatePattern, P as PatternType } from './types-DU2mmhwb.mjs';
+export { calculatePatternScore } from './scoring-entry/index.mjs';
 
 /**
  * Pattern Detection Tool Provider
  */
-declare const PatternDetectProvider: ToolProvider;
+declare const PATTERN_DETECT_PROVIDER: ToolProvider;
 
-export { PatternDetectProvider };
+export { PATTERN_DETECT_PROVIDER };

package/dist/index.d.ts

@@ -1,14 +1,13 @@
 import { ToolProvider } from '@aiready/core';
-export { IssueType, Severity, filterBySeverity, getSeverityLabel } from '@aiready/core';
-export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as createRefactorClusters, f as filterClustersByImpact, g as generateSummary, d as getSmartDefaults, e as groupDuplicatesByFilePair } from './index-BwuoiCNm.js';
+export { Severity } from '@aiready/core';
 export { detectDuplicatePatterns } from './detector-entry/index.js';
-export { calculatePatternScore } from './scoring-entry/index.js';
-export { C as CONTEXT_RULES, a as ContextRule, c as calculateSeverity, g as getSeverityThreshold } from './index-szjQDBsm.js';
+export { D as DuplicateGroup, P as PatternDetectOptions, a as PatternSummary, R as RefactorCluster, b as analyzePatterns, c as areBrandSpecificVariants, d as calculateSeverity, e as createRefactorClusters, f as filterBrandSpecificVariants, g as filterBySeverity, h as filterClustersByImpact, i as generateSummary, j as getSeverityLabel, k as getSmartDefaults, l as groupDuplicatesByFilePair, m as logConfiguration } from './index-CWgYOKaK.js';
 export { D as DuplicatePattern, P as PatternType } from './types-DU2mmhwb.js';
+export { calculatePatternScore } from './scoring-entry/index.js';
 
 /**
  * Pattern Detection Tool Provider
  */
-declare const PatternDetectProvider: ToolProvider;
+declare const PATTERN_DETECT_PROVIDER: ToolProvider;
 
-export { PatternDetectProvider };
+export { PATTERN_DETECT_PROVIDER };