uilint-semantic 0.2.138 → 0.2.139

package/dist/chunk-PXUZIL7H.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-PXUZIL7H.js.map

package/dist/chunk-PXUZIL7H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-QDQHFV7C.js

@@ -0,0 +1,605 @@
+// src/eslint-rules/no-semantic-duplicates.ts
+import { createRule, defineRuleMeta } from "uilint-eslint";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "fs";
+import { dirname, join, relative } from "path";
+var logFile = null;
+var logInitialized = false;
+function initLog(projectRoot) {
+  if (logFile) return;
+  const uilintDir = join(projectRoot, ".uilint");
+  if (existsSync(uilintDir)) {
+    logFile = join(uilintDir, "no-semantic-duplicates.log");
+  }
+}
+function log(message) {
+  if (!logFile) return;
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${timestamp}] ${message}
+`;
+    if (!logInitialized) {
+      writeFileSync(logFile, line);
+      logInitialized = true;
+    } else {
+      appendFileSync(logFile, line);
+    }
+  } catch {
+  }
+}
+var meta = defineRuleMeta({
+  id: "no-semantic-duplicates",
+  version: "1.0.0",
+  name: "No Semantic Duplicates",
+  description: "Warn when code is semantically similar to existing code",
+  defaultSeverity: "warn",
+  category: "semantic",
+  icon: "\u{1F50D}",
+  hint: "Finds similar code via embeddings",
+  defaultEnabled: false,
+  plugin: "semantic",
+  eslintImport: "uilint-semantic/eslint-rules/no-semantic-duplicates",
+  customInspector: "duplicates",
+  requirements: [
+    {
+      type: "semantic-index",
+      description: "Requires semantic index for duplicate detection",
+      setupHint: "Run: uilint duplicates index"
+    }
+  ],
+  postInstallInstructions: "Run 'uilint duplicates index' to build the semantic index before using this rule.",
+  defaultOptions: [{
+    threshold: 0.75,
+    indexPath: ".uilint/.duplicates-index",
+    minLines: 3,
+    confidenceLevel: "low",
+    useStructuralBoost: true,
+    includeSameFile: false,
+    kind: "all"
+  }],
+  optionSchema: {
+    fields: [
+      {
+        key: "threshold",
+        label: "Similarity threshold",
+        type: "number",
+        defaultValue: 0.75,
+        description: "Minimum similarity score (0-1) to report as duplicate. Lower values catch more potential duplicates. Recommended: 0.75 (default), 0.85 (strict), 0.65 (lenient)."
+      },
+      {
+        key: "confidenceLevel",
+        label: "Minimum confidence",
+        type: "select",
+        defaultValue: "low",
+        options: [
+          { value: "high", label: "High (\u226590%) - Likely copy-paste" },
+          { value: "medium", label: "Medium (\u226575%) - Semantically similar" },
+          { value: "low", label: "Low (\u226560%) - Possibly related" }
+        ],
+        description: "Only report duplicates at or above this confidence level. High = fewer but more certain matches."
+      },
+      {
+        key: "useStructuralBoost",
+        label: "Use structural similarity",
+        type: "boolean",
+        defaultValue: true,
+        description: "Boost similarity scores based on structural overlap (props, JSX elements, hooks). Helps catch duplicates with different variable names."
+      },
+      {
+        key: "kind",
+        label: "Code kind filter",
+        type: "select",
+        defaultValue: "all",
+        options: [
+          { value: "all", label: "All code" },
+          { value: "component", label: "Components only" },
+          { value: "hook", label: "Hooks only" },
+          { value: "function", label: "Functions only" }
+        ],
+        description: "Only detect duplicates of a specific code type."
+      },
+      {
+        key: "includeSameFile",
+        label: "Include same-file duplicates",
+        type: "boolean",
+        defaultValue: false,
+        description: "Report duplicates within the same file (e.g., Card and CardAlt in cards.tsx)."
+      },
+      {
+        key: "indexPath",
+        label: "Index path",
+        type: "text",
+        defaultValue: ".uilint/.duplicates-index",
+        description: "Path to the semantic duplicates index directory."
+      },
+      {
+        key: "minLines",
+        label: "Minimum lines",
+        type: "number",
+        defaultValue: 3,
+        description: "Minimum number of lines for a chunk to be reported as a potential duplicate."
+      }
+    ]
+  },
+  docs: `
+## What it does
+
+Warns when code (components, hooks, functions) is semantically similar to other
+code in the codebase. Unlike syntactic duplicate detection, this finds code that
+implements similar functionality even if written differently.
+
+## Prerequisites
+
+Before using this rule, you must build the semantic index:
+
+\`\`\`bash
+uilint duplicates index
+\`\`\`
+
+This creates an embedding-based index at \`.uilint/.duplicates-index/\`.
+
+## Why it's useful
+
+- **Reduce Duplication**: Find components/hooks that could be consolidated
+- **Discover Patterns**: Identify similar code that could be abstracted
+- **Code Quality**: Encourage reuse over reimplementation
+- **Fast**: Queries pre-built index, no LLM calls during linting
+
+## How it works
+
+1. The rule checks if the current file is in the semantic index
+2. For each indexed code chunk, it looks up similar chunks
+3. If similar chunks exist above the threshold, it reports a warning
+
+## Examples
+
+### Semantic duplicates detected:
+
+\`\`\`tsx
+// UserCard.tsx - Original component
+export function UserCard({ user }) {
+  return (
+    <div className="card">
+      <img src={user.avatar} />
+      <h3>{user.name}</h3>
+    </div>
+  );
+}
+
+// ProfileCard.tsx - Semantically similar (warning!)
+export function ProfileCard({ profile }) {
+  return (
+    <article className="profile">
+      <img src={profile.avatarUrl} />
+      <h2>{profile.displayName}</h2>
+    </article>
+  );
+}
+\`\`\`
+
+## Configuration
+
+\`\`\`js
+// eslint.config.js
+"uilint/no-semantic-duplicates": ["warn", {
+  // Core detection settings
+  threshold: 0.75,              // Similarity threshold (0-1). Lower = more matches.
+  confidenceLevel: "medium",    // "high" (\u226590%), "medium" (\u226575%), "low" (\u226560%)
+
+  // Detection enhancements
+  useStructuralBoost: true,     // Boost scores based on props/JSX/hooks overlap
+
+  // Filtering
+  kind: "all",                  // "all", "component", "hook", "function"
+  includeSameFile: false,       // Include duplicates within the same file
+  minLines: 3,                  // Minimum lines to report
+
+  // Index location
+  indexPath: ".uilint/.duplicates-index"
+}]
+\`\`\`
+
+### Preset configurations
+
+**Strict** - High-confidence duplicates only:
+\`\`\`js
+{ threshold: 0.85, confidenceLevel: "high" }
+\`\`\`
+
+**Normal** (default) - Balanced detection:
+\`\`\`js
+{ threshold: 0.75, confidenceLevel: "low" }
+\`\`\`
+
+**Lenient** - Catch more potential duplicates:
+\`\`\`js
+{ threshold: 0.65, confidenceLevel: "low" }
+\`\`\`
+
+## Confidence Levels
+
+The rule assigns confidence levels based on similarity scores:
+
+- \u{1F534} **High (\u226590%)** - Likely copy-paste or near-identical code. Strongly recommend consolidation.
+- \u{1F7E1} **Medium (75-89%)** - Semantically similar. Review for potential abstraction.
+- \u{1F7E2} **Low (60-74%)** - Possibly related patterns. Optional review.
+
+## Notes
+
+- Run \`uilint duplicates index\` after significant code changes
+- Use \`uilint duplicates find\` to explore all duplicate groups
+- The rule only reports if the file is in the index
+- Structural boost helps detect duplicates with different variable names (e.g., Badge vs Tag)
+`
+});
+var indexCache = null;
+function clearIndexCache() {
+  indexCache = null;
+}
+function findProjectRoot(startPath, indexPath) {
+  let current = startPath;
+  let lastPackageJson = null;
+  while (current !== dirname(current)) {
+    const uilintDir = join(current, indexPath);
+    if (existsSync(join(uilintDir, "manifest.json"))) {
+      return current;
+    }
+    if (existsSync(join(current, "package.json"))) {
+      lastPackageJson = current;
+    }
+    current = dirname(current);
+  }
+  return lastPackageJson || startPath;
+}
+function loadIndex(projectRoot, indexPath) {
+  const fullIndexPath = join(projectRoot, indexPath);
+  log(`loadIndex called: projectRoot=${projectRoot}, indexPath=${indexPath}`);
+  log(`fullIndexPath=${fullIndexPath}`);
+  if (indexCache && indexCache.projectRoot === projectRoot) {
+    log(`Using cached index (${indexCache.vectorStore.size} vectors, ${indexCache.fileToChunks.size} files)`);
+    return indexCache;
+  }
+  const manifestPath = join(fullIndexPath, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    log(`Index not found: manifest.json missing at ${manifestPath}`);
+    return null;
+  }
+  try {
+    const metadataPath = join(fullIndexPath, "metadata.json");
+    if (!existsSync(metadataPath)) {
+      log(`Index not found: metadata.json missing at ${metadataPath}`);
+      return null;
+    }
+    const metadataContent = readFileSync(metadataPath, "utf-8");
+    const metadataJson = JSON.parse(metadataContent);
+    const entries = metadataJson.entries || metadataJson;
+    log(`Loaded metadata.json: ${Object.keys(entries).length} entries`);
+    const metadataStore = /* @__PURE__ */ new Map();
+    const fileToChunks = /* @__PURE__ */ new Map();
+    for (const [id, meta2] of Object.entries(entries)) {
+      const m = meta2;
+      metadataStore.set(id, {
+        filePath: m.filePath,
+        startLine: m.startLine,
+        endLine: m.endLine,
+        startColumn: m.startColumn ?? 0,
+        endColumn: m.endColumn ?? 0,
+        name: m.name,
+        kind: m.kind
+      });
+      const chunks = fileToChunks.get(m.filePath) || [];
+      chunks.push(id);
+      fileToChunks.set(m.filePath, chunks);
+    }
+    log(`File to chunks mapping:`);
+    for (const [filePath, chunks] of fileToChunks.entries()) {
+      log(`  ${filePath}: ${chunks.length} chunks (${chunks.join(", ")})`);
+    }
+    const vectorsPath = join(fullIndexPath, "embeddings.bin");
+    const idsPath = join(fullIndexPath, "ids.json");
+    const vectorStore = /* @__PURE__ */ new Map();
+    if (existsSync(vectorsPath) && existsSync(idsPath)) {
+      const idsContent = readFileSync(idsPath, "utf-8");
+      const ids = JSON.parse(idsContent);
+      log(`Loaded ids.json: ${ids.length} IDs`);
+      const buffer = readFileSync(vectorsPath);
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const dimension = view.getUint32(0, true);
+      const count = view.getUint32(4, true);
+      log(`Embeddings binary: dimension=${dimension}, count=${count}`);
+      let offset = 8;
+      for (let i = 0; i < count && i < ids.length; i++) {
+        const vector = [];
+        for (let j = 0; j < dimension; j++) {
+          vector.push(view.getFloat32(offset, true));
+          offset += 4;
+        }
+        vectorStore.set(ids[i], vector);
+      }
+      log(`Loaded ${vectorStore.size} vectors into store`);
+    } else {
+      log(`Missing vectors or ids files: vectorsPath=${existsSync(vectorsPath)}, idsPath=${existsSync(idsPath)}`);
+    }
+    indexCache = {
+      projectRoot,
+      vectorStore,
+      metadataStore,
+      fileToChunks
+    };
+    log(`Index loaded successfully: ${vectorStore.size} vectors, ${metadataStore.size} metadata entries, ${fileToChunks.size} files`);
+    return indexCache;
+  } catch (err) {
+    log(`Error loading index: ${err}`);
+    return null;
+  }
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dotProduct / denominator;
+}
+function extractCodeFromFile(filePath, startLine, endLine) {
+  try {
+    if (!existsSync(filePath)) {
+      return null;
+    }
+    const content = readFileSync(filePath, "utf-8");
+    const lines = content.split("\n");
+    const start = Math.max(0, startLine - 1);
+    const end = Math.min(lines.length, endLine);
+    return lines.slice(start, end).join("\n");
+  } catch {
+    return null;
+  }
+}
+function findSimilarChunks(index, chunkId, threshold) {
+  log(`findSimilarChunks: chunkId=${chunkId}, threshold=${threshold}`);
+  const vector = index.vectorStore.get(chunkId);
+  if (!vector) {
+    log(`  No vector found for chunk ${chunkId}`);
+    return [];
+  }
+  log(`  Vector found: dimension=${vector.length}`);
+  const results = [];
+  const allScores = [];
+  for (const [id, vec] of index.vectorStore.entries()) {
+    if (id === chunkId) continue;
+    const score = cosineSimilarity(vector, vec);
+    allScores.push({ id, score });
+    if (score >= threshold) {
+      results.push({ id, score });
+    }
+  }
+  const sortedAll = allScores.sort((a, b) => b.score - a.score).slice(0, 10);
+  log(`  Top 10 similarity scores (threshold=${threshold}):`);
+  for (const { id, score } of sortedAll) {
+    const meta2 = index.metadataStore.get(id);
+    const meetsThreshold = score >= threshold ? "\u2713" : "\u2717";
+    log(`    ${meetsThreshold} ${(score * 100).toFixed(1)}% - ${id} (${meta2?.name || "anonymous"} in ${meta2?.filePath})`);
+  }
+  log(`  Found ${results.length} chunks above threshold`);
+  return results.sort((a, b) => b.score - a.score);
+}
+var no_semantic_duplicates_default = createRule({
+  name: "no-semantic-duplicates",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Warn when code is semantically similar to existing code"
+    },
+    messages: {
+      semanticDuplicate: "This {{kind}} '{{name}}' is {{similarity}}% similar to '{{otherName}}' at {{otherLocation}}. Consider consolidating.",
+      noIndex: "Semantic duplicates index not found. Run 'uilint duplicates index' first."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          threshold: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "Similarity threshold (0-1)"
+          },
+          indexPath: {
+            type: "string",
+            description: "Path to the index directory"
+          },
+          minLines: {
+            type: "integer",
+            minimum: 1,
+            description: "Minimum number of lines for a chunk to be reported"
+          },
+          confidenceLevel: {
+            type: "string",
+            enum: ["high", "medium", "low"],
+            description: "Minimum confidence level to report"
+          },
+          useStructuralBoost: {
+            type: "boolean",
+            description: "Use structural similarity boost (props, JSX, hooks overlap)"
+          },
+          includeSameFile: {
+            type: "boolean",
+            description: "Include duplicates within the same file"
+          },
+          kind: {
+            type: "string",
+            enum: ["component", "hook", "function", "all"],
+            description: "Filter by code kind"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [
+    {
+      threshold: 0.75,
+      indexPath: ".uilint/.duplicates-index",
+      minLines: 3,
+      confidenceLevel: "low",
+      useStructuralBoost: true,
+      includeSameFile: false,
+      kind: "all"
+    }
+  ],
+  create(context) {
+    const options = context.options[0] || {};
+    const threshold = options.threshold ?? 0.85;
+    const indexPath = options.indexPath ?? ".uilint/.duplicates-index";
+    const minLines = options.minLines ?? 3;
+    const filename = context.filename || context.getFilename();
+    const projectRoot = findProjectRoot(dirname(filename), indexPath);
+    const relativeFilename = relative(projectRoot, filename);
+    initLog(projectRoot);
+    log(`
+========== Rule create() ==========`);
+    log(`Filename: ${filename}`);
+    log(`Relative filename: ${relativeFilename}`);
+    log(`Threshold: ${threshold}`);
+    log(`Index path: ${indexPath}`);
+    log(`Min lines: ${minLines}`);
+    log(`Project root: ${projectRoot}`);
+    const index = loadIndex(projectRoot, indexPath);
+    const reportedChunks = /* @__PURE__ */ new Set();
+    function checkForDuplicates(node, name) {
+      log(`checkForDuplicates: name=${name}, file=${relativeFilename}`);
+      if (!index) {
+        log(`  No index loaded`);
+        return;
+      }
+      const fileChunks = index.fileToChunks.get(relativeFilename);
+      log(`  Looking for chunks for file: ${relativeFilename}`);
+      log(`  Files in index: ${Array.from(index.fileToChunks.keys()).join(", ")}`);
+      if (!fileChunks || fileChunks.length === 0) {
+        log(`  No chunks found for this file`);
+        return;
+      }
+      log(`  Found ${fileChunks.length} chunks: ${fileChunks.join(", ")}`);
+      const nodeLine = node.loc?.start.line;
+      if (!nodeLine) {
+        log(`  No node line number`);
+        return;
+      }
+      log(`  Node starts at line ${nodeLine}`);
+      for (const chunkId of fileChunks) {
+        if (reportedChunks.has(chunkId)) {
+          log(`  Chunk ${chunkId} already reported, skipping`);
+          continue;
+        }
+        const meta2 = index.metadataStore.get(chunkId);
+        if (!meta2) {
+          log(`  No metadata for chunk ${chunkId}`);
+          continue;
+        }
+        log(`  Checking chunk ${chunkId}: lines ${meta2.startLine}-${meta2.endLine} (node at line ${nodeLine})`);
+        if (nodeLine >= meta2.startLine && nodeLine <= meta2.endLine) {
+          log(`  Node is within chunk range, searching for similar chunks...`);
+          const similar = findSimilarChunks(index, chunkId, threshold);
+          if (similar.length > 0) {
+            const best = similar[0];
+            const bestMeta = index.metadataStore.get(best.id);
+            if (bestMeta) {
+              const chunkLines = meta2.endLine - meta2.startLine + 1;
+              if (chunkLines < minLines) {
+                log(`  Skipping: chunk has ${chunkLines} lines, below minLines=${minLines}`);
+                continue;
+              }
+              reportedChunks.add(chunkId);
+              const relPath = bestMeta.filePath;
+              const similarity = Math.round(best.score * 100);
+              const sourceCode = extractCodeFromFile(
+                filename,
+                meta2.startLine,
+                meta2.endLine
+              );
+              const targetAbsolutePath = join(projectRoot, bestMeta.filePath);
+              const targetCode = extractCodeFromFile(
+                targetAbsolutePath,
+                bestMeta.startLine,
+                bestMeta.endLine
+              );
+              log(`  REPORTING: ${meta2.kind} '${name || meta2.name}' is ${similarity}% similar to '${bestMeta.name}' at ${relPath}:${bestMeta.startLine}`);
+              context.report({
+                node,
+                loc: {
+                  start: { line: meta2.startLine, column: meta2.startColumn },
+                  end: { line: meta2.endLine, column: meta2.endColumn }
+                },
+                messageId: "semanticDuplicate",
+                data: {
+                  kind: meta2.kind,
+                  name: name || meta2.name || "(anonymous)",
+                  similarity: String(similarity),
+                  otherName: bestMeta.name || "(anonymous)",
+                  otherLocation: `${relPath}:${bestMeta.startLine}`,
+                  // Extended data for inspector panel (use relative paths for portability)
+                  sourceCode: sourceCode || "",
+                  targetCode: targetCode || "",
+                  sourceLocation: JSON.stringify({
+                    filePath: relativeFilename,
+                    startLine: meta2.startLine,
+                    endLine: meta2.endLine,
+                    startColumn: meta2.startColumn,
+                    endColumn: meta2.endColumn
+                  }),
+                  targetLocation: JSON.stringify({
+                    filePath: bestMeta.filePath,
+                    // Already relative from index
+                    startLine: bestMeta.startLine,
+                    endLine: bestMeta.endLine,
+                    startColumn: bestMeta.startColumn,
+                    endColumn: bestMeta.endColumn
+                  }),
+                  sourceName: name || meta2.name || "(anonymous)",
+                  targetName: bestMeta.name || "(anonymous)",
+                  similarityScore: String(best.score)
+                }
+              });
+            }
+          } else {
+            log(`  No similar chunks found above threshold`);
+          }
+        } else {
+          log(`  Node line ${nodeLine} not in chunk range ${meta2.startLine}-${meta2.endLine}`);
+        }
+      }
+    }
+    return {
+      // Check function declarations
+      FunctionDeclaration(node) {
+        const name = node.id?.name || null;
+        checkForDuplicates(node, name);
+      },
+      // Check arrow functions assigned to variables
+      "VariableDeclarator[init.type='ArrowFunctionExpression']"(node) {
+        const name = node.id.type === "Identifier" ? node.id.name : null;
+        if (node.init) {
+          checkForDuplicates(node.init, name);
+        }
+      },
+      // Check function expressions
+      "VariableDeclarator[init.type='FunctionExpression']"(node) {
+        const name = node.id.type === "Identifier" ? node.id.name : null;
+        if (node.init) {
+          checkForDuplicates(node.init, name);
+        }
+      }
+    };
+  }
+});
+
+export {
+  meta,
+  clearIndexCache,
+  no_semantic_duplicates_default
+};
+//# sourceMappingURL=chunk-QDQHFV7C.js.map