@aiready/pattern-detect 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+import { ScanOptions, AnalysisResult } from '@aiready/core';
+
+interface DuplicatePattern {
+    file1: string;
+    file2: string;
+    line1: number;
+    line2: number;
+    similarity: number;
+    snippet: string;
+    patternType: PatternType;
+    tokenCost: number;
+    linesOfCode: number;
+}
+type PatternType = 'function' | 'class-method' | 'api-handler' | 'validator' | 'utility' | 'component' | 'unknown';
+interface FileContent {
+    file: string;
+    content: string;
+}
+interface DetectionOptions {
+    minSimilarity: number;
+    minLines: number;
+}
+/**
+ * Detect duplicate patterns across files with enhanced analysis
+ */
+declare function detectDuplicatePatterns(files: FileContent[], options: DetectionOptions): DuplicatePattern[];
+
+interface PatternDetectOptions extends ScanOptions {
+    minSimilarity?: number;
+    minLines?: number;
+}
+interface PatternSummary {
+    totalPatterns: number;
+    totalTokenCost: number;
+    patternsByType: Record<PatternType, number>;
+    topDuplicates: Array<{
+        file1: string;
+        file2: string;
+        similarity: number;
+        patternType: PatternType;
+        tokenCost: number;
+    }>;
+}
+declare function analyzePatterns(options: PatternDetectOptions): Promise<AnalysisResult[]>;
+/**
+ * Generate a summary of pattern analysis
+ */
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+
+export { type DuplicatePattern, type PatternDetectOptions, type PatternSummary, type PatternType, analyzePatterns, detectDuplicatePatterns, generateSummary };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { ScanOptions, AnalysisResult } from '@aiready/core';
+
+interface DuplicatePattern {
+    file1: string;
+    file2: string;
+    line1: number;
+    line2: number;
+    similarity: number;
+    snippet: string;
+    patternType: PatternType;
+    tokenCost: number;
+    linesOfCode: number;
+}
+type PatternType = 'function' | 'class-method' | 'api-handler' | 'validator' | 'utility' | 'component' | 'unknown';
+interface FileContent {
+    file: string;
+    content: string;
+}
+interface DetectionOptions {
+    minSimilarity: number;
+    minLines: number;
+}
+/**
+ * Detect duplicate patterns across files with enhanced analysis
+ */
+declare function detectDuplicatePatterns(files: FileContent[], options: DetectionOptions): DuplicatePattern[];
+
+interface PatternDetectOptions extends ScanOptions {
+    minSimilarity?: number;
+    minLines?: number;
+}
+interface PatternSummary {
+    totalPatterns: number;
+    totalTokenCost: number;
+    patternsByType: Record<PatternType, number>;
+    topDuplicates: Array<{
+        file1: string;
+        file2: string;
+        similarity: number;
+        patternType: PatternType;
+        tokenCost: number;
+    }>;
+}
+declare function analyzePatterns(options: PatternDetectOptions): Promise<AnalysisResult[]>;
+/**
+ * Generate a summary of pattern analysis
+ */
+declare function generateSummary(results: AnalysisResult[]): PatternSummary;
+
+export { type DuplicatePattern, type PatternDetectOptions, type PatternSummary, type PatternType, analyzePatterns, detectDuplicatePatterns, generateSummary };

package/dist/index.js

@@ -0,0 +1,253 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  analyzePatterns: () => analyzePatterns,
+  detectDuplicatePatterns: () => detectDuplicatePatterns,
+  generateSummary: () => generateSummary
+});
+module.exports = __toCommonJS(index_exports);
+var import_core2 = require("@aiready/core");
+
+// src/detector.ts
+var import_core = require("@aiready/core");
+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")) {
+    return "api-handler";
+  }
+  if (lower.includes("validate") || lower.includes("schema") || lower.includes("zod") || lower.includes("yup") || lower.includes("if") && lower.includes("throw")) {
+    return "validator";
+  }
+  if (lower.includes("return (") || lower.includes("jsx") || lower.includes("component") || lower.includes("props")) {
+    return "component";
+  }
+  if (lower.includes("class ") || lower.includes("this.")) {
+    return "class-method";
+  }
+  if (lower.includes("return ") && !lower.includes("this") && !lower.includes("new ")) {
+    return "utility";
+  }
+  if (lower.includes("function") || lower.includes("=>")) {
+    return "function";
+  }
+  return "unknown";
+}
+function extractCodeBlocks(content, minLines) {
+  const lines = content.split("\n");
+  const blocks = [];
+  let currentBlock = [];
+  let blockStart = 0;
+  let braceDepth = 0;
+  let inFunction = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!inFunction && (trimmed.includes("function ") || trimmed.includes("=>") || trimmed.includes("async ") || /^(export\s+)?(async\s+)?function\s+/.test(trimmed) || /^(export\s+)?const\s+\w+\s*=\s*(async\s*)?\(/.test(trimmed))) {
+      inFunction = true;
+      blockStart = i;
+    }
+    for (const char of line) {
+      if (char === "{") braceDepth++;
+      if (char === "}") braceDepth--;
+    }
+    if (inFunction) {
+      currentBlock.push(line);
+    }
+    if (inFunction && braceDepth === 0 && currentBlock.length >= minLines) {
+      const blockContent = currentBlock.join("\n");
+      const linesOfCode = currentBlock.filter(
+        (l) => l.trim() && !l.trim().startsWith("//")
+      ).length;
+      blocks.push({
+        content: blockContent,
+        startLine: blockStart + 1,
+        patternType: categorizePattern(blockContent),
+        linesOfCode
+      });
+      currentBlock = [];
+      inFunction = false;
+    } else if (inFunction && braceDepth === 0) {
+      currentBlock = [];
+      inFunction = false;
+    }
+  }
+  return blocks;
+}
+function normalizeCode(code) {
+  return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/"[^"]*"/g, '"STR"').replace(/'[^']*'/g, "'STR'").replace(/`[^`]*`/g, "`STR`").replace(/\b\d+\b/g, "NUM").replace(/\s+/g, " ").trim();
+}
+function calculateSimilarity(block1, block2) {
+  const norm1 = normalizeCode(block1);
+  const norm2 = normalizeCode(block2);
+  const baseSimilarity = (0, import_core.similarityScore)(norm1, norm2);
+  const tokens1 = norm1.split(/[\s(){}[\];,]+/).filter(Boolean);
+  const tokens2 = norm2.split(/[\s(){}[\];,]+/).filter(Boolean);
+  const tokenSimilarity = (0, import_core.similarityScore)(tokens1.join(" "), tokens2.join(" "));
+  return baseSimilarity * 0.4 + tokenSimilarity * 0.6;
+}
+function detectDuplicatePatterns(files, options) {
+  const { minSimilarity, minLines } = options;
+  const duplicates = [];
+  const allBlocks = files.flatMap(
+    (file) => extractCodeBlocks(file.content, minLines).map((block) => ({
+      ...block,
+      file: file.file,
+      normalized: normalizeCode(block.content),
+      tokenCost: (0, import_core.estimateTokens)(block.content)
+    }))
+  );
+  console.log(`Extracted ${allBlocks.length} code blocks for analysis`);
+  for (let i = 0; i < allBlocks.length; i++) {
+    for (let j = i + 1; j < allBlocks.length; j++) {
+      const block1 = allBlocks[i];
+      const block2 = allBlocks[j];
+      if (block1.file === block2.file) continue;
+      const similarity = calculateSimilarity(block1.content, block2.content);
+      if (similarity >= minSimilarity) {
+        duplicates.push({
+          file1: block1.file,
+          file2: block2.file,
+          line1: block1.startLine,
+          line2: block2.startLine,
+          similarity,
+          snippet: block1.content.split("\n").slice(0, 5).join("\n") + "\n...",
+          patternType: block1.patternType,
+          tokenCost: block1.tokenCost + block2.tokenCost,
+          linesOfCode: block1.linesOfCode
+        });
+      }
+    }
+  }
+  return duplicates.sort(
+    (a, b) => b.similarity - a.similarity || b.tokenCost - a.tokenCost
+  );
+}
+
+// src/index.ts
+function getRefactoringSuggestion(patternType, similarity) {
+  const baseMessages = {
+    "api-handler": "Extract common middleware or create a base handler class",
+    validator: "Consolidate validation logic into shared schema validators (Zod/Yup)",
+    utility: "Move to a shared utilities file and reuse across modules",
+    "class-method": "Consider inheritance or composition to share behavior",
+    component: "Extract shared logic into a custom hook or HOC",
+    function: "Extract into a shared helper function",
+    unknown: "Extract common logic into a reusable module"
+  };
+  const urgency = similarity > 0.95 ? " (CRITICAL: Nearly identical code)" : similarity > 0.9 ? " (HIGH: Very similar, refactor soon)" : "";
+  return baseMessages[patternType] + urgency;
+}
+async function analyzePatterns(options) {
+  const { minSimilarity = 0.85, minLines = 5, ...scanOptions } = options;
+  const files = await (0, import_core2.scanFiles)(scanOptions);
+  const results = [];
+  const fileContents = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      content: await (0, import_core2.readFileContent)(file)
+    }))
+  );
+  const duplicates = detectDuplicatePatterns(fileContents, {
+    minSimilarity,
+    minLines
+  });
+  for (const file of files) {
+    const fileDuplicates = duplicates.filter(
+      (dup) => dup.file1 === file || dup.file2 === file
+    );
+    const issues = fileDuplicates.map((dup) => {
+      const otherFile = dup.file1 === file ? dup.file2 : dup.file1;
+      const severity = dup.similarity > 0.95 ? "critical" : dup.similarity > 0.9 ? "major" : "minor";
+      return {
+        type: "duplicate-pattern",
+        severity,
+        message: `${dup.patternType} pattern ${Math.round(dup.similarity * 100)}% similar to ${otherFile} (${dup.tokenCost} tokens wasted)`,
+        location: {
+          file,
+          line: dup.file1 === file ? dup.line1 : dup.line2
+        },
+        suggestion: getRefactoringSuggestion(dup.patternType, dup.similarity)
+      };
+    });
+    const totalTokenCost = fileDuplicates.reduce(
+      (sum, dup) => sum + dup.tokenCost,
+      0
+    );
+    results.push({
+      fileName: file,
+      issues,
+      metrics: {
+        tokenCost: totalTokenCost,
+        consistencyScore: Math.max(0, 1 - fileDuplicates.length * 0.1)
+      }
+    });
+  }
+  return results;
+}
+function generateSummary(results) {
+  const allIssues = results.flatMap((r) => r.issues);
+  const totalTokenCost = results.reduce(
+    (sum, r) => sum + (r.metrics.tokenCost || 0),
+    0
+  );
+  const patternsByType = {
+    "api-handler": 0,
+    validator: 0,
+    utility: 0,
+    "class-method": 0,
+    component: 0,
+    function: 0,
+    unknown: 0
+  };
+  allIssues.forEach((issue) => {
+    const match = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    if (match) {
+      const type = match[1];
+      patternsByType[type] = (patternsByType[type] || 0) + 1;
+    }
+  });
+  const topDuplicates = allIssues.slice(0, 10).map((issue) => {
+    const similarityMatch = issue.message.match(/(\d+)% similar/);
+    const tokenMatch = issue.message.match(/\((\d+) tokens/);
+    const typeMatch = issue.message.match(/^(\S+(?:-\S+)*) pattern/);
+    const fileMatch = issue.message.match(/similar to (.+?) \(/);
+    return {
+      file1: issue.location.file,
+      file2: fileMatch?.[1] || "unknown",
+      similarity: similarityMatch ? parseInt(similarityMatch[1]) / 100 : 0,
+      patternType: typeMatch?.[1] || "unknown",
+      tokenCost: tokenMatch ? parseInt(tokenMatch[1]) : 0
+    };
+  });
+  return {
+    totalPatterns: allIssues.length,
+    totalTokenCost,
+    patternsByType,
+    topDuplicates
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  analyzePatterns,
+  detectDuplicatePatterns,
+  generateSummary
+});

package/dist/index.mjs

@@ -0,0 +1,10 @@
+import {
+  analyzePatterns,
+  detectDuplicatePatterns,
+  generateSummary
+} from "./chunk-RLWJXASG.mjs";
+export {
+  analyzePatterns,
+  detectDuplicatePatterns,
+  generateSummary
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@aiready/pattern-detect",
+  "version": "0.1.0",
+  "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",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "aiready-patterns": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "keywords": [
+    "aiready",
+    "duplicate-detection",
+    "semantic-analysis",
+    "code-patterns",
+    "ai-code",
+    "tech-debt",
+    "code-quality",
+    "refactoring",
+    "copilot",
+    "chatgpt",
+    "claude",
+    "ai-assisted-development",
+    "pattern-recognition",
+    "code-similarity",
+    "token-optimization"
+  ],
+  "author": "AIReady Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/caopengau/aiready-pattern-detect.git"
+  },
+  "homepage": "https://github.com/caopengau/aiready-pattern-detect",
+  "bugs": {
+    "url": "https://github.com/caopengau/aiready-pattern-detect/issues"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0",
+    "@aiready/core": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "eslint": "^9.17.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "lint": "eslint src",
+    "clean": "rm -rf dist"
+  }
+}