uilint-duplicates 0.2.27

package/dist/chunk-DURWZZLU.js

@@ -0,0 +1,1941 @@
+// src/embeddings/chunker.ts
+import { parse, AST_NODE_TYPES } from "@typescript-eslint/typescript-estree";
+var DEFAULT_MAX_LINES = 100;
+var MIN_SECTION_LINES = 3;
+function hashChunk(content, filePath, startLine) {
+  let hash = 5381;
+  const input = `${filePath}:${startLine}:${content}`;
+  for (let i = 0; i < input.length; i++) {
+    hash = hash * 33 ^ input.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function chunkFile(filePath, content, options = {}) {
+  const {
+    minLines = 3,
+    maxLines = DEFAULT_MAX_LINES,
+    includeAnonymous = false,
+    kinds,
+    splitStrategy = "jsx-children"
+  } = options;
+  let ast;
+  try {
+    ast = parse(content, {
+      jsx: true,
+      loc: true,
+      range: true,
+      tokens: false,
+      comment: false
+    });
+  } catch (error) {
+    console.warn(`Failed to parse ${filePath}:`, error);
+    return [];
+  }
+  const chunks = [];
+  const lines = content.split("\n");
+  const exportedNames = /* @__PURE__ */ new Set();
+  let defaultExportName = null;
+  for (const node of ast.body) {
+    if (node.type === AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (node.declaration) {
+        const names = getDeclarationNames(node.declaration);
+        names.forEach((name) => exportedNames.add(name));
+      }
+      if (node.specifiers) {
+        node.specifiers.forEach((spec) => {
+          if (spec.type === AST_NODE_TYPES.ExportSpecifier) {
+            exportedNames.add(
+              spec.exported.type === AST_NODE_TYPES.Identifier ? spec.exported.name : spec.exported.value
+            );
+          }
+        });
+      }
+    } else if (node.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
+      if (node.declaration.type === AST_NODE_TYPES.Identifier) {
+        defaultExportName = node.declaration.name;
+      } else if (node.declaration.type === AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        defaultExportName = node.declaration.id.name;
+      }
+    }
+  }
+  function visit(node) {
+    if (node.type === AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      const chunk = processFunction(
+        node,
+        node.id.name,
+        filePath,
+        content,
+        lines,
+        exportedNames,
+        defaultExportName
+      );
+      if (chunk && shouldIncludeChunk(chunk, minLines, includeAnonymous, kinds)) {
+        const lineCount = chunk.endLine - chunk.startLine + 1;
+        if (lineCount > maxLines && splitStrategy !== "none") {
+          const splitChunks = splitLargeChunk(node, chunk, content, lines, maxLines, splitStrategy);
+          chunks.push(...splitChunks.filter((c) => shouldIncludeChunk(c, minLines, includeAnonymous, kinds)));
+        } else {
+          chunks.push(chunk);
+        }
+      }
+    }
+    if (node.type === AST_NODE_TYPES.VariableDeclaration) {
+      for (const decl of node.declarations) {
+        if (decl.id.type === AST_NODE_TYPES.Identifier && decl.init && (decl.init.type === AST_NODE_TYPES.ArrowFunctionExpression || decl.init.type === AST_NODE_TYPES.FunctionExpression)) {
+          const chunk = processFunction(
+            decl.init,
+            decl.id.name,
+            filePath,
+            content,
+            lines,
+            exportedNames,
+            defaultExportName,
+            node
+            // Use the variable declaration for location
+          );
+          if (chunk && shouldIncludeChunk(chunk, minLines, includeAnonymous, kinds)) {
+            const lineCount = chunk.endLine - chunk.startLine + 1;
+            if (lineCount > maxLines && splitStrategy !== "none") {
+              const splitChunks = splitLargeChunk(decl.init, chunk, content, lines, maxLines, splitStrategy);
+              chunks.push(...splitChunks.filter((c) => shouldIncludeChunk(c, minLines, includeAnonymous, kinds)));
+            } else {
+              chunks.push(chunk);
+            }
+          }
+        }
+      }
+    }
+    for (const key of Object.keys(node)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      const child = node[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          child.forEach((c) => {
+            if (c && typeof c === "object" && "type" in c) {
+              visit(c);
+            }
+          });
+        } else if ("type" in child) {
+          visit(child);
+        }
+      }
+    }
+  }
+  visit(ast);
+  return chunks;
+}
+function processFunction(node, name, filePath, content, lines, exportedNames, defaultExportName, locationNode) {
+  const loc = (locationNode || node).loc;
+  if (!loc) return null;
+  const startLine = loc.start.line;
+  const endLine = loc.end.line;
+  const startColumn = loc.start.column;
+  const endColumn = loc.end.column;
+  const chunkContent = lines.slice(startLine - 1, endLine).join("\n");
+  const kind = classifyFunction(name, node);
+  const metadata = extractMetadata(node, name, exportedNames, defaultExportName);
+  return {
+    id: hashChunk(chunkContent, filePath, startLine),
+    filePath,
+    startLine,
+    endLine,
+    startColumn,
+    endColumn,
+    kind,
+    name,
+    content: chunkContent,
+    metadata
+  };
+}
+function classifyFunction(name, node) {
+  if (/^use[A-Z]/.test(name)) {
+    return "hook";
+  }
+  if (/^[A-Z]/.test(name) && containsJSX(node)) {
+    return "component";
+  }
+  if (containsJSX(node)) {
+    return "jsx-fragment";
+  }
+  return "function";
+}
+function containsJSX(node) {
+  let found = false;
+  function search(n) {
+    if (found) return;
+    if (n.type === AST_NODE_TYPES.JSXElement || n.type === AST_NODE_TYPES.JSXFragment) {
+      found = true;
+      return;
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      const child = n[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          child.forEach((c) => {
+            if (c && typeof c === "object" && "type" in c) {
+              search(c);
+            }
+          });
+        } else if ("type" in child) {
+          search(child);
+        }
+      }
+    }
+  }
+  search(node);
+  return found;
+}
+function extractMetadata(node, name, exportedNames, defaultExportName) {
+  const metadata = {
+    isExported: exportedNames.has(name) || defaultExportName === name,
+    isDefaultExport: defaultExportName === name
+  };
+  const params = node.params;
+  if (params.length > 0) {
+    const firstParam = params[0];
+    const props = extractPropsFromParam(firstParam);
+    if (props.length > 0) {
+      metadata.props = props;
+    }
+  }
+  const hooks = [];
+  const jsxElements = [];
+  function searchForHooksAndJSX(n) {
+    if (n.type === AST_NODE_TYPES.CallExpression && n.callee.type === AST_NODE_TYPES.Identifier && /^use[A-Z]/.test(n.callee.name)) {
+      hooks.push(n.callee.name);
+    }
+    if (n.type === AST_NODE_TYPES.JSXOpeningElement) {
+      if (n.name.type === AST_NODE_TYPES.JSXIdentifier) {
+        jsxElements.push(n.name.name);
+      } else if (n.name.type === AST_NODE_TYPES.JSXMemberExpression) {
+        const parts = [];
+        let current = n.name;
+        while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
+          if (current.property.type === AST_NODE_TYPES.JSXIdentifier) {
+            parts.unshift(current.property.name);
+          }
+          current = current.object;
+        }
+        if (current.type === AST_NODE_TYPES.JSXIdentifier) {
+          parts.unshift(current.name);
+        }
+        jsxElements.push(parts.join("."));
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      const child = n[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          child.forEach((c) => {
+            if (c && typeof c === "object" && "type" in c) {
+              searchForHooksAndJSX(c);
+            }
+          });
+        } else if ("type" in child) {
+          searchForHooksAndJSX(child);
+        }
+      }
+    }
+  }
+  searchForHooksAndJSX(node);
+  if (hooks.length > 0) {
+    metadata.hooks = [...new Set(hooks)];
+  }
+  if (jsxElements.length > 0) {
+    metadata.jsxElements = [...new Set(jsxElements)];
+  }
+  return metadata;
+}
+function extractPropsFromParam(param) {
+  const props = [];
+  if (param.type === AST_NODE_TYPES.ObjectPattern) {
+    for (const prop of param.properties) {
+      if (prop.type === AST_NODE_TYPES.Property && prop.key.type === AST_NODE_TYPES.Identifier) {
+        props.push(prop.key.name);
+      } else if (prop.type === AST_NODE_TYPES.RestElement && prop.argument.type === AST_NODE_TYPES.Identifier) {
+        props.push(`...${prop.argument.name}`);
+      }
+    }
+  } else if (param.type === AST_NODE_TYPES.Identifier) {
+    props.push(param.name);
+  }
+  return props;
+}
+function getDeclarationNames(decl) {
+  const names = [];
+  if (decl.type === AST_NODE_TYPES.FunctionDeclaration && decl.id) {
+    names.push(decl.id.name);
+  } else if (decl.type === AST_NODE_TYPES.VariableDeclaration) {
+    for (const d of decl.declarations) {
+      if (d.id.type === AST_NODE_TYPES.Identifier) {
+        names.push(d.id.name);
+      }
+    }
+  } else if (decl.type === AST_NODE_TYPES.ClassDeclaration && decl.id) {
+    names.push(decl.id.name);
+  }
+  return names;
+}
+function shouldIncludeChunk(chunk, minLines, includeAnonymous, kinds) {
+  const lineCount = chunk.endLine - chunk.startLine + 1;
+  if (lineCount < minLines) {
+    return false;
+  }
+  if (!includeAnonymous && chunk.name === null) {
+    return false;
+  }
+  if (kinds && !kinds.includes(chunk.kind)) {
+    return false;
+  }
+  return true;
+}
+var DEFAULT_MAX_EMBEDDING_CHARS = 6e3;
+function prepareEmbeddingInput(chunk, options = {}) {
+  const { maxChars = DEFAULT_MAX_EMBEDDING_CHARS } = options;
+  const parts = [];
+  if (chunk.kind === "component") {
+    parts.push(`React component: ${chunk.name || "anonymous"}`);
+    if (chunk.metadata.props?.length) {
+      parts.push(`Props: ${chunk.metadata.props.join(", ")}`);
+    }
+  } else if (chunk.kind === "component-summary") {
+    parts.push(`React component summary: ${chunk.name || "anonymous"}`);
+    if (chunk.metadata.props?.length) {
+      parts.push(`Props: ${chunk.metadata.props.join(", ")}`);
+    }
+    parts.push("(Large component - see sections for JSX details)");
+  } else if (chunk.kind === "jsx-section") {
+    const parentName = chunk.name || "anonymous";
+    const label = chunk.sectionLabel || `section-${chunk.sectionIndex}`;
+    parts.push(`JSX section from ${parentName}: ${label}`);
+  } else if (chunk.kind === "hook") {
+    parts.push(`React hook: ${chunk.name || "anonymous"}`);
+  } else if (chunk.kind === "function") {
+    parts.push(`Function: ${chunk.name || "anonymous"}`);
+  } else if (chunk.kind === "function-summary") {
+    parts.push(`Function summary: ${chunk.name || "anonymous"}`);
+    parts.push("(Large function - split into sections)");
+  } else if (chunk.kind === "function-section") {
+    const parentName = chunk.name || "anonymous";
+    const label = chunk.sectionLabel || `section-${chunk.sectionIndex}`;
+    parts.push(`Function section from ${parentName}: ${label}`);
+  } else if (chunk.kind === "jsx-fragment") {
+    parts.push(`JSX fragment: ${chunk.name || "anonymous"}`);
+  }
+  parts.push(chunk.content);
+  if (chunk.metadata.jsxElements?.length) {
+    parts.push(`JSX elements: ${chunk.metadata.jsxElements.join(", ")}`);
+  }
+  if (chunk.metadata.hooks?.length) {
+    parts.push(`Hooks used: ${chunk.metadata.hooks.join(", ")}`);
+  }
+  let result = parts.join("\n\n");
+  if (result.length > maxChars) {
+    result = result.slice(0, maxChars - 50) + "\n\n[... content truncated for embedding ...]";
+  }
+  return result;
+}
+function splitLargeChunk(node, originalChunk, content, lines, maxLines, strategy) {
+  if (strategy === "jsx-children" && originalChunk.kind === "component") {
+    const jsxChunks = splitByJSXChildren(node, originalChunk, content, lines);
+    if (jsxChunks.length > 0) {
+      return jsxChunks;
+    }
+  }
+  return splitByLines(originalChunk, lines, maxLines);
+}
+function splitByJSXChildren(node, originalChunk, content, lines) {
+  const returnStatement = findJSXReturnStatement(node);
+  if (!returnStatement || !returnStatement.argument) {
+    return [];
+  }
+  const jsxRoot = getJSXRoot(returnStatement.argument);
+  if (!jsxRoot) {
+    return [];
+  }
+  const children = getSignificantJSXChildren(jsxRoot);
+  if (children.length < 2) {
+    return [];
+  }
+  const chunks = [];
+  const summaryChunk = createSummaryChunk(node, originalChunk, returnStatement, lines);
+  chunks.push(summaryChunk);
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    const sectionChunk = createJSXSectionChunk(
+      originalChunk,
+      child,
+      lines,
+      i,
+      summaryChunk.id
+    );
+    if (sectionChunk) {
+      chunks.push(sectionChunk);
+    }
+  }
+  return chunks;
+}
+function findJSXReturnStatement(node) {
+  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression && node.expression) {
+    if (isJSXNode(node.body)) {
+      return {
+        type: AST_NODE_TYPES.ReturnStatement,
+        argument: node.body,
+        loc: node.body.loc,
+        range: node.body.range,
+        parent: node
+      };
+    }
+    return null;
+  }
+  const body = node.body;
+  if (body.type !== AST_NODE_TYPES.BlockStatement) {
+    return null;
+  }
+  for (const stmt of body.body) {
+    if (stmt.type === AST_NODE_TYPES.ReturnStatement && stmt.argument && isJSXNode(stmt.argument)) {
+      return stmt;
+    }
+  }
+  return null;
+}
+function isJSXNode(node) {
+  return node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment;
+}
+function getJSXRoot(node) {
+  if (node.type === AST_NODE_TYPES.JSXElement) {
+    return node;
+  }
+  if (node.type === AST_NODE_TYPES.JSXFragment) {
+    return node;
+  }
+  return null;
+}
+function getSignificantJSXChildren(jsxRoot) {
+  const children = [];
+  for (const child of jsxRoot.children) {
+    if (child.type === AST_NODE_TYPES.JSXText) {
+      if (child.value.trim() === "") {
+        continue;
+      }
+    }
+    if (child.type === AST_NODE_TYPES.JSXElement || child.type === AST_NODE_TYPES.JSXFragment || child.type === AST_NODE_TYPES.JSXExpressionContainer) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function createSummaryChunk(node, originalChunk, returnStatement, lines) {
+  const startLine = originalChunk.startLine;
+  const returnLine = returnStatement.loc?.start.line || originalChunk.endLine;
+  const summaryEndLine = Math.min(returnLine, originalChunk.endLine);
+  const summaryLines = lines.slice(startLine - 1, summaryEndLine);
+  const summaryContent = summaryLines.join("\n") + "\n    // ... JSX content (see sections)\n  );";
+  return {
+    id: hashChunk(summaryContent, originalChunk.filePath, startLine),
+    filePath: originalChunk.filePath,
+    startLine,
+    endLine: summaryEndLine,
+    startColumn: originalChunk.startColumn,
+    endColumn: originalChunk.endColumn,
+    kind: "component-summary",
+    name: originalChunk.name,
+    content: summaryContent,
+    metadata: {
+      ...originalChunk.metadata,
+      // Keep hooks but clear JSX elements (they're in the sections)
+      jsxElements: void 0
+    }
+  };
+}
+function createJSXSectionChunk(originalChunk, jsxChild, lines, index, parentId) {
+  const loc = jsxChild.loc;
+  if (!loc) {
+    return null;
+  }
+  const startLine = loc.start.line;
+  const endLine = loc.end.line;
+  const lineCount = endLine - startLine + 1;
+  if (lineCount < MIN_SECTION_LINES) {
+    return null;
+  }
+  const sectionContent = lines.slice(startLine - 1, endLine).join("\n");
+  const label = inferSectionLabel(jsxChild, index);
+  const jsxElements = extractJSXElementsFromNode(jsxChild);
+  return {
+    id: hashChunk(sectionContent, originalChunk.filePath, startLine),
+    filePath: originalChunk.filePath,
+    startLine,
+    endLine,
+    startColumn: loc.start.column,
+    endColumn: loc.end.column,
+    kind: "jsx-section",
+    name: originalChunk.name,
+    content: sectionContent,
+    metadata: {
+      jsxElements: jsxElements.length > 0 ? jsxElements : void 0,
+      isExported: originalChunk.metadata.isExported,
+      isDefaultExport: originalChunk.metadata.isDefaultExport
+    },
+    parentId,
+    sectionIndex: index,
+    sectionLabel: label
+  };
+}
+function inferSectionLabel(jsxChild, index) {
+  if (jsxChild.type === AST_NODE_TYPES.JSXElement) {
+    const opening = jsxChild.openingElement;
+    for (const attr of opening.attributes) {
+      if (attr.type === AST_NODE_TYPES.JSXAttribute && attr.name.type === AST_NODE_TYPES.JSXIdentifier) {
+        const attrName = attr.name.name;
+        if (attrName === "aria-label" || attrName === "aria-labelledby") {
+          if (attr.value?.type === AST_NODE_TYPES.Literal && typeof attr.value.value === "string") {
+            return attr.value.value.toLowerCase().replace(/\s+/g, "-").slice(0, 30);
+          }
+        }
+        if (attrName === "className" || attrName === "class") {
+          if (attr.value?.type === AST_NODE_TYPES.Literal && typeof attr.value.value === "string") {
+            const className = attr.value.value;
+            const classes = className.split(/\s+/);
+            for (const cls of classes) {
+              if (!cls.match(/^(bg-|text-|p-|m-|w-|h-|flex|grid|border|rounded|shadow|hover:|focus:)/)) {
+                return cls.slice(0, 30);
+              }
+            }
+          }
+        }
+      }
+    }
+    if (opening.name.type === AST_NODE_TYPES.JSXIdentifier) {
+      return `${opening.name.name}-${index}`;
+    }
+  }
+  return `section-${index}`;
+}
+function extractJSXElementsFromNode(node) {
+  const elements = [];
+  function search(n) {
+    if (n.type === AST_NODE_TYPES.JSXOpeningElement) {
+      if (n.name.type === AST_NODE_TYPES.JSXIdentifier) {
+        elements.push(n.name.name);
+      } else if (n.name.type === AST_NODE_TYPES.JSXMemberExpression) {
+        const parts = [];
+        let current = n.name;
+        while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
+          if (current.property.type === AST_NODE_TYPES.JSXIdentifier) {
+            parts.unshift(current.property.name);
+          }
+          current = current.object;
+        }
+        if (current.type === AST_NODE_TYPES.JSXIdentifier) {
+          parts.unshift(current.name);
+        }
+        elements.push(parts.join("."));
+      }
+    }
+    for (const key of Object.keys(n)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      const child = n[key];
+      if (child && typeof child === "object") {
+        if (Array.isArray(child)) {
+          child.forEach((c) => {
+            if (c && typeof c === "object" && "type" in c) {
+              search(c);
+            }
+          });
+        } else if ("type" in child) {
+          search(child);
+        }
+      }
+    }
+  }
+  search(node);
+  return [...new Set(elements)];
+}
+function splitByLines(originalChunk, lines, maxLines) {
+  const totalLines = originalChunk.endLine - originalChunk.startLine + 1;
+  if (totalLines <= maxLines) {
+    return [originalChunk];
+  }
+  const isComponent = originalChunk.kind === "component" || originalChunk.kind === "jsx-fragment";
+  const summaryKind = isComponent ? "component-summary" : "function-summary";
+  const sectionKind = isComponent ? "jsx-section" : "function-section";
+  const chunks = [];
+  const overlap = Math.min(10, Math.floor(maxLines / 5));
+  let currentStart = originalChunk.startLine;
+  let sectionIndex = 0;
+  while (currentStart <= originalChunk.endLine) {
+    const currentEnd = Math.min(currentStart + maxLines - 1, originalChunk.endLine);
+    const sectionContent = lines.slice(currentStart - 1, currentEnd).join("\n");
+    const isFirstSection = sectionIndex === 0;
+    chunks.push({
+      id: hashChunk(sectionContent, originalChunk.filePath, currentStart),
+      filePath: originalChunk.filePath,
+      startLine: currentStart,
+      endLine: currentEnd,
+      startColumn: isFirstSection ? originalChunk.startColumn : 0,
+      endColumn: currentEnd === originalChunk.endLine ? originalChunk.endColumn : lines[currentEnd - 1]?.length || 0,
+      kind: isFirstSection ? summaryKind : sectionKind,
+      name: originalChunk.name,
+      content: sectionContent,
+      metadata: isFirstSection ? originalChunk.metadata : {
+        isExported: originalChunk.metadata.isExported,
+        isDefaultExport: originalChunk.metadata.isDefaultExport
+      },
+      parentId: isFirstSection ? void 0 : chunks[0]?.id,
+      sectionIndex: isFirstSection ? void 0 : sectionIndex,
+      sectionLabel: isFirstSection ? void 0 : `lines-${currentStart}-${currentEnd}`
+    });
+    currentStart = currentEnd - overlap + 1;
+    sectionIndex++;
+    if (currentStart <= originalChunk.startLine + sectionIndex * (maxLines - overlap)) {
+      currentStart = originalChunk.startLine + sectionIndex * (maxLines - overlap);
+    }
+  }
+  return chunks;
+}
+
+// src/embeddings/ollama-embeddings.ts
+var DEFAULT_BASE_URL = "http://localhost:11434";
+var DEFAULT_MODEL = "nomic-embed-text";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_BATCH_SIZE = 10;
+var OllamaEmbeddingClient = class {
+  baseUrl;
+  model;
+  timeout;
+  batchSize;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+    this.model = options.model || DEFAULT_MODEL;
+    this.timeout = options.timeout || DEFAULT_TIMEOUT;
+    this.batchSize = options.batchSize || DEFAULT_BATCH_SIZE;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async embed(text) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          input: text
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      const embedding = data.embeddings?.[0] || data.embedding;
+      if (!embedding || !Array.isArray(embedding)) {
+        throw new Error("Invalid embedding response from Ollama");
+      }
+      return {
+        embedding,
+        model: this.model,
+        promptTokens: data.prompt_eval_count
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts
+   * Automatically batches large inputs
+   */
+  async embedBatch(texts) {
+    if (texts.length === 0) {
+      return [];
+    }
+    if (texts.length <= this.batchSize) {
+      return this.embedBatchDirect(texts);
+    }
+    const results = [];
+    for (let i = 0; i < texts.length; i += this.batchSize) {
+      const batch = texts.slice(i, i + this.batchSize);
+      const batchResults = await this.embedBatchDirect(batch);
+      results.push(...batchResults);
+    }
+    return results;
+  }
+  /**
+   * Embed a batch directly (no chunking)
+   */
+  async embedBatchDirect(texts) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/api/embed`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          input: texts
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+      }
+      const data = await response.json();
+      const embeddings = data.embeddings;
+      if (!embeddings || !Array.isArray(embeddings)) {
+        throw new Error("Invalid batch embedding response from Ollama");
+      }
+      return embeddings.map((embedding) => ({
+        embedding,
+        model: this.model
+      }));
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Check if Ollama is available
+   */
+  async isAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if the embedding model is available
+   */
+  async isModelAvailable() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!response.ok) return false;
+      const data = await response.json();
+      const models = data.models || [];
+      return models.some(
+        (m) => m.name === this.model || m.name.startsWith(`${this.model}:`)
+      );
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Pull the embedding model if not available
+   */
+  async ensureModel() {
+    const available = await this.isModelAvailable();
+    if (available) return;
+    console.log(`Pulling embedding model ${this.model}...`);
+    const response = await fetch(`${this.baseUrl}/api/pull`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: this.model,
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to pull model ${this.model}: ${errorText}`);
+    }
+  }
+  /**
+   * Get the embedding dimension for the current model
+   * (Requires generating a test embedding)
+   */
+  async getEmbeddingDimension() {
+    const result = await this.embed("test");
+    return result.embedding.length;
+  }
+  /**
+   * Get the current model name
+   */
+  getModel() {
+    return this.model;
+  }
+  /**
+   * Set the model name
+   */
+  setModel(model) {
+    this.model = model;
+  }
+};
+var defaultClient = null;
+function getOllamaEmbeddingClient(options) {
+  if (!defaultClient || options) {
+    defaultClient = new OllamaEmbeddingClient(options);
+  }
+  return defaultClient;
+}
+
+// src/query/api.ts
+import { resolve } from "path";
+
+// src/cache/incremental-indexer.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4, relative } from "path";
+import { glob } from "glob";
+
+// src/index/vector-store.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`Vector dimension mismatch: ${a.length} vs ${b.length}`);
+  }
+  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];
+  }
+  normA = Math.sqrt(normA);
+  normB = Math.sqrt(normB);
+  if (normA === 0 || normB === 0) {
+    return 0;
+  }
+  return dotProduct / (normA * normB);
+}
+var VectorStore = class {
+  vectors = /* @__PURE__ */ new Map();
+  dimension = null;
+  idIndex = [];
+  // Ordered list of IDs for binary storage
+  constructor(options = {}) {
+    if (options.dimension) {
+      this.dimension = options.dimension;
+    }
+  }
+  /**
+   * Add a vector to the store
+   */
+  add(id, vector) {
+    if (this.dimension === null) {
+      this.dimension = vector.length;
+    } else if (vector.length !== this.dimension) {
+      throw new Error(
+        `Vector dimension mismatch: expected ${this.dimension}, got ${vector.length}`
+      );
+    }
+    if (!this.vectors.has(id)) {
+      this.idIndex.push(id);
+    }
+    this.vectors.set(id, vector);
+  }
+  /**
+   * Add multiple vectors at once
+   */
+  addBatch(items) {
+    for (const { id, vector } of items) {
+      this.add(id, vector);
+    }
+  }
+  /**
+   * Remove a vector from the store
+   */
+  remove(id) {
+    if (!this.vectors.has(id)) {
+      return false;
+    }
+    this.vectors.delete(id);
+    this.idIndex = this.idIndex.filter((i) => i !== id);
+    return true;
+  }
+  /**
+   * Get a vector by ID
+   */
+  get(id) {
+    return this.vectors.get(id) || null;
+  }
+  /**
+   * Check if a vector exists
+   */
+  has(id) {
+    return this.vectors.has(id);
+  }
+  /**
+   * Find the most similar vectors to a query vector
+   */
+  findSimilar(query, k = 10, threshold = 0) {
+    if (this.dimension !== null && query.length !== this.dimension) {
+      throw new Error(
+        `Query vector dimension mismatch: expected ${this.dimension}, got ${query.length}`
+      );
+    }
+    const results = [];
+    for (const [id, vector] of this.vectors) {
+      const score = cosineSimilarity(query, vector);
+      if (score >= threshold) {
+        results.push({
+          id,
+          score,
+          distance: 1 - score
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, k);
+  }
+  /**
+   * Get the number of vectors in the store
+   */
+  size() {
+    return this.vectors.size;
+  }
+  /**
+   * Get the dimension of vectors
+   */
+  getDimension() {
+    return this.dimension;
+  }
+  /**
+   * Get all IDs
+   */
+  getIds() {
+    return [...this.idIndex];
+  }
+  /**
+   * Clear all vectors
+   */
+  clear() {
+    this.vectors.clear();
+    this.idIndex = [];
+    this.dimension = null;
+  }
+  /**
+   * Save the vector store to disk
+   *
+   * Format:
+   * - embeddings.bin: Binary Float32 vectors
+   * - ids.json: Ordered array of IDs matching vector positions
+   */
+  async save(dirPath) {
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+    const idsPath = join(dirPath, "ids.json");
+    writeFileSync(idsPath, JSON.stringify(this.idIndex), "utf-8");
+    const embeddingsPath = join(dirPath, "embeddings.bin");
+    if (this.vectors.size === 0) {
+      const header = new Uint32Array([0, 0]);
+      writeFileSync(embeddingsPath, Buffer.from(header.buffer));
+      return;
+    }
+    const dimension = this.dimension;
+    const count = this.vectors.size;
+    const headerSize = 8;
+    const vectorsSize = count * dimension * 4;
+    const buffer = Buffer.alloc(headerSize + vectorsSize);
+    buffer.writeUInt32LE(dimension, 0);
+    buffer.writeUInt32LE(count, 4);
+    let offset = headerSize;
+    for (const id of this.idIndex) {
+      const vector = this.vectors.get(id);
+      for (const value of vector) {
+        buffer.writeFloatLE(value, offset);
+        offset += 4;
+      }
+    }
+    writeFileSync(embeddingsPath, buffer);
+  }
+  /**
+   * Load the vector store from disk
+   */
+  async load(dirPath) {
+    const idsPath = join(dirPath, "ids.json");
+    const embeddingsPath = join(dirPath, "embeddings.bin");
+    if (!existsSync(idsPath) || !existsSync(embeddingsPath)) {
+      throw new Error(`Vector store files not found in ${dirPath}`);
+    }
+    this.clear();
+    const idsContent = readFileSync(idsPath, "utf-8");
+    this.idIndex = JSON.parse(idsContent);
+    const buffer = readFileSync(embeddingsPath);
+    const dimension = buffer.readUInt32LE(0);
+    const count = buffer.readUInt32LE(4);
+    if (count === 0) {
+      return;
+    }
+    this.dimension = dimension;
+    let offset = 8;
+    for (let i = 0; i < count; i++) {
+      const vector = [];
+      for (let j = 0; j < dimension; j++) {
+        vector.push(buffer.readFloatLE(offset));
+        offset += 4;
+      }
+      this.vectors.set(this.idIndex[i], vector);
+    }
+  }
+  /**
+   * Iterate over all vectors
+   */
+  *entries() {
+    for (const id of this.idIndex) {
+      yield [id, this.vectors.get(id)];
+    }
+  }
+  /**
+   * Get stats about the store
+   */
+  getStats() {
+    const memoryBytes = this.dimension ? this.vectors.size * this.dimension * 4 + this.idIndex.length * 50 : 0;
+    return {
+      size: this.vectors.size,
+      dimension: this.dimension,
+      memoryBytes
+    };
+  }
+};
+
+// src/index/metadata-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var MetadataStore = class {
+  chunks = /* @__PURE__ */ new Map();
+  /**
+   * Add or update chunk metadata
+   */
+  set(id, metadata) {
+    this.chunks.set(id, metadata);
+  }
+  /**
+   * Add multiple chunks at once
+   */
+  setBatch(items) {
+    for (const { id, metadata } of items) {
+      this.set(id, metadata);
+    }
+  }
+  /**
+   * Get chunk metadata by ID
+   */
+  get(id) {
+    return this.chunks.get(id) || null;
+  }
+  /**
+   * Check if a chunk exists
+   */
+  has(id) {
+    return this.chunks.has(id);
+  }
+  /**
+   * Remove chunk metadata
+   */
+  remove(id) {
+    return this.chunks.delete(id);
+  }
+  /**
+   * Remove all chunks for a given file path
+   */
+  removeByFilePath(filePath) {
+    const removedIds = [];
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.filePath === filePath) {
+        this.chunks.delete(id);
+        removedIds.push(id);
+      }
+    }
+    return removedIds;
+  }
+  /**
+   * Get all chunks for a given file path
+   */
+  getByFilePath(filePath) {
+    const results = [];
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.filePath === filePath) {
+        results.push({ id, metadata });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get chunk by content hash
+   */
+  getByContentHash(contentHash) {
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.contentHash === contentHash) {
+        return { id, metadata };
+      }
+    }
+    return null;
+  }
+  /**
+   * Get chunk at a specific location
+   */
+  getAtLocation(filePath, line) {
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.filePath === filePath && metadata.startLine <= line && metadata.endLine >= line) {
+        return { id, metadata };
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all unique file paths
+   */
+  getFilePaths() {
+    const paths = /* @__PURE__ */ new Set();
+    for (const metadata of this.chunks.values()) {
+      paths.add(metadata.filePath);
+    }
+    return [...paths];
+  }
+  /**
+   * Get number of chunks
+   */
+  size() {
+    return this.chunks.size;
+  }
+  /**
+   * Clear all metadata
+   */
+  clear() {
+    this.chunks.clear();
+  }
+  /**
+   * Iterate over all chunks
+   */
+  *entries() {
+    yield* this.chunks.entries();
+  }
+  /**
+   * Get all IDs
+   */
+  getIds() {
+    return [...this.chunks.keys()];
+  }
+  /**
+   * Save to disk
+   */
+  async save(dirPath) {
+    if (!existsSync2(dirPath)) {
+      mkdirSync2(dirPath, { recursive: true });
+    }
+    const metadataPath = join2(dirPath, "metadata.json");
+    const data = Object.fromEntries(this.chunks);
+    writeFileSync2(metadataPath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  /**
+   * Load from disk
+   */
+  async load(dirPath) {
+    const metadataPath = join2(dirPath, "metadata.json");
+    if (!existsSync2(metadataPath)) {
+      throw new Error(`Metadata file not found: ${metadataPath}`);
+    }
+    this.clear();
+    const content = readFileSync2(metadataPath, "utf-8");
+    const data = JSON.parse(content);
+    for (const [id, metadata] of Object.entries(data)) {
+      this.chunks.set(id, metadata);
+    }
+  }
+  /**
+   * Filter chunks by kind
+   */
+  filterByKind(kind) {
+    const results = [];
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.kind === kind) {
+        results.push({ id, metadata });
+      }
+    }
+    return results;
+  }
+  /**
+   * Search by name (case-insensitive partial match)
+   */
+  searchByName(query) {
+    const lowerQuery = query.toLowerCase();
+    const results = [];
+    for (const [id, metadata] of this.chunks) {
+      if (metadata.name && metadata.name.toLowerCase().includes(lowerQuery)) {
+        results.push({ id, metadata });
+      }
+    }
+    return results;
+  }
+};
+
+// src/cache/file-tracker.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  statSync
+} from "fs";
+import { join as join3 } from "path";
+var xxhashInstance = null;
+async function getXxhash() {
+  if (!xxhashInstance) {
+    const xxhash = await import("xxhash-wasm");
+    xxhashInstance = await xxhash.default();
+  }
+  return xxhashInstance;
+}
+function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = hash * 33 ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16);
+}
+async function hashContent(content) {
+  try {
+    const xxhash = await getXxhash();
+    return xxhash.h64ToString(content);
+  } catch {
+    return djb2Hash(content);
+  }
+}
+function hashContentSync(content) {
+  return djb2Hash(content);
+}
+var HASH_STORE_VERSION = 1;
+var FileTracker = class {
+  store = {
+    version: HASH_STORE_VERSION,
+    files: {}
+  };
+  /**
+   * Get the hash entry for a file
+   */
+  getEntry(filePath) {
+    return this.store.files[filePath] || null;
+  }
+  /**
+   * Set the hash entry for a file
+   */
+  setEntry(filePath, entry) {
+    this.store.files[filePath] = entry;
+  }
+  /**
+   * Remove the hash entry for a file
+   */
+  removeEntry(filePath) {
+    if (this.store.files[filePath]) {
+      delete this.store.files[filePath];
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get all tracked file paths
+   */
+  getTrackedFiles() {
+    return Object.keys(this.store.files);
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.store = {
+      version: HASH_STORE_VERSION,
+      files: {}
+    };
+  }
+  /**
+   * Detect changes between current files and stored hashes
+   */
+  async detectChanges(files) {
+    const changes = [];
+    const currentFiles = new Set(files);
+    for (const storedPath of Object.keys(this.store.files)) {
+      if (!currentFiles.has(storedPath)) {
+        changes.push({
+          path: storedPath,
+          type: "deleted",
+          oldHash: this.store.files[storedPath].contentHash
+        });
+      }
+    }
+    for (const filePath of files) {
+      try {
+        const content = readFileSync3(filePath, "utf-8");
+        const newHash = await hashContent(content);
+        const stat = statSync(filePath);
+        const entry = this.store.files[filePath];
+        if (!entry) {
+          changes.push({
+            path: filePath,
+            type: "added",
+            newHash
+          });
+        } else if (entry.contentHash !== newHash) {
+          changes.push({
+            path: filePath,
+            type: "modified",
+            oldHash: entry.contentHash,
+            newHash
+          });
+        }
+      } catch (error) {
+        if (this.store.files[filePath]) {
+          changes.push({
+            path: filePath,
+            type: "deleted",
+            oldHash: this.store.files[filePath].contentHash
+          });
+        }
+      }
+    }
+    return changes;
+  }
+  /**
+   * Update stored hash for a file
+   */
+  async updateFile(filePath, content, chunkIds) {
+    const hash = await hashContent(content);
+    const stat = statSync(filePath);
+    this.store.files[filePath] = {
+      contentHash: hash,
+      mtimeMs: stat.mtimeMs,
+      chunkIds
+    };
+  }
+  /**
+   * Save to disk
+   */
+  async save(dirPath) {
+    if (!existsSync3(dirPath)) {
+      mkdirSync3(dirPath, { recursive: true });
+    }
+    const hashesPath = join3(dirPath, "hashes.json");
+    writeFileSync3(hashesPath, JSON.stringify(this.store, null, 2), "utf-8");
+  }
+  /**
+   * Load from disk
+   */
+  async load(dirPath) {
+    const hashesPath = join3(dirPath, "hashes.json");
+    if (!existsSync3(hashesPath)) {
+      this.clear();
+      return;
+    }
+    const content = readFileSync3(hashesPath, "utf-8");
+    const data = JSON.parse(content);
+    if (data.version !== HASH_STORE_VERSION) {
+      this.clear();
+      return;
+    }
+    this.store = data;
+  }
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      trackedFiles: Object.keys(this.store.files).length
+    };
+  }
+};
+
+// src/cache/incremental-indexer.ts
+var INDEX_DIR = ".uilint/.duplicates-index";
+var MANIFEST_FILE = "manifest.json";
+var MANIFEST_VERSION = 1;
+var IncrementalIndexer = class {
+  vectorStore;
+  metadataStore;
+  fileTracker;
+  embeddingClient;
+  projectRoot;
+  indexDir;
+  options;
+  manifest = null;
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = projectRoot;
+    this.indexDir = join4(projectRoot, INDEX_DIR);
+    this.options = options;
+    this.vectorStore = new VectorStore();
+    this.metadataStore = new MetadataStore();
+    this.fileTracker = new FileTracker();
+    this.embeddingClient = new OllamaEmbeddingClient({
+      model: options.model,
+      baseUrl: options.baseUrl
+    });
+  }
+  /**
+   * Get the include patterns
+   */
+  getIncludePatterns() {
+    return this.options.include || ["**/*.{ts,tsx,js,jsx}"];
+  }
+  /**
+   * Get the exclude patterns
+   */
+  getExcludePatterns() {
+    return [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/build/**",
+      "**/.git/**",
+      "**/*.test.{ts,tsx,js,jsx}",
+      "**/*.spec.{ts,tsx,js,jsx}",
+      "**/__tests__/**",
+      ...this.options.exclude || []
+    ];
+  }
+  /**
+   * Find all files to index
+   */
+  async findFiles() {
+    const files = [];
+    for (const pattern of this.getIncludePatterns()) {
+      const matches = await glob(pattern, {
+        cwd: this.projectRoot,
+        ignore: this.getExcludePatterns(),
+        absolute: true,
+        nodir: true
+      });
+      files.push(...matches);
+    }
+    return [...new Set(files)];
+  }
+  /**
+   * Load existing index from disk
+   */
+  async load() {
+    if (!existsSync4(this.indexDir)) {
+      return;
+    }
+    try {
+      const manifestPath = join4(this.indexDir, MANIFEST_FILE);
+      if (existsSync4(manifestPath)) {
+        const content = readFileSync4(manifestPath, "utf-8");
+        this.manifest = JSON.parse(content);
+      }
+      await this.vectorStore.load(this.indexDir);
+      await this.metadataStore.load(this.indexDir);
+      await this.fileTracker.load(this.indexDir);
+    } catch (error) {
+      this.vectorStore = new VectorStore();
+      this.metadataStore = new MetadataStore();
+      this.fileTracker = new FileTracker();
+      this.manifest = null;
+    }
+  }
+  /**
+   * Save index to disk
+   */
+  async save() {
+    if (!existsSync4(this.indexDir)) {
+      mkdirSync4(this.indexDir, { recursive: true });
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const dimension = this.vectorStore.getDimension();
+    this.manifest = {
+      version: MANIFEST_VERSION,
+      createdAt: this.manifest?.createdAt || now,
+      updatedAt: now,
+      embeddingModel: this.embeddingClient.getModel(),
+      dimension: dimension || 0,
+      fileCount: this.fileTracker.getTrackedFiles().length,
+      chunkCount: this.metadataStore.size()
+    };
+    const manifestPath = join4(this.indexDir, MANIFEST_FILE);
+    writeFileSync4(
+      manifestPath,
+      JSON.stringify(this.manifest, null, 2),
+      "utf-8"
+    );
+    await this.vectorStore.save(this.indexDir);
+    await this.metadataStore.save(this.indexDir);
+    await this.fileTracker.save(this.indexDir);
+  }
+  /**
+   * Index all files from scratch
+   */
+  async indexAll(force = false) {
+    const startTime = Date.now();
+    const log = this.options.onProgress || (() => {
+    });
+    const available = await this.embeddingClient.isAvailable();
+    if (!available) {
+      throw new Error(
+        "Ollama is not available. Make sure it's running at " + (this.options.baseUrl || "http://localhost:11434")
+      );
+    }
+    if (force) {
+      this.vectorStore.clear();
+      this.metadataStore.clear();
+      this.fileTracker.clear();
+    } else {
+      await this.load();
+    }
+    log("Finding files...");
+    const files = await this.findFiles();
+    log(`Found ${files.length} files`);
+    const changes = force ? files.map((path) => ({ path, type: "added", newHash: "" })) : await this.fileTracker.detectChanges(files);
+    const result = await this.processChanges(changes, log);
+    log("Saving index...");
+    await this.save();
+    return {
+      ...result,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Update index incrementally
+   */
+  async update() {
+    const startTime = Date.now();
+    const log = this.options.onProgress || (() => {
+    });
+    await this.load();
+    const available = await this.embeddingClient.isAvailable();
+    if (!available) {
+      throw new Error("Ollama is not available");
+    }
+    log("Detecting changes...");
+    const files = await this.findFiles();
+    const changes = await this.fileTracker.detectChanges(files);
+    if (changes.length === 0) {
+      log("No changes detected");
+      return {
+        added: 0,
+        modified: 0,
+        deleted: 0,
+        totalChunks: this.metadataStore.size(),
+        duration: Date.now() - startTime
+      };
+    }
+    log(`Found ${changes.length} changed files`);
+    const result = await this.processChanges(changes, log);
+    log("Saving index...");
+    await this.save();
+    return {
+      ...result,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Process file changes
+   */
+  async processChanges(changes, log) {
+    let added = 0;
+    let modified = 0;
+    let deleted = 0;
+    const deletedFiles = changes.filter((c) => c.type === "deleted");
+    for (const change of deletedFiles) {
+      const removedIds = this.metadataStore.removeByFilePath(change.path);
+      for (const id of removedIds) {
+        this.vectorStore.remove(id);
+      }
+      this.fileTracker.removeEntry(change.path);
+      deleted++;
+    }
+    const filesToProcess = changes.filter((c) => c.type !== "deleted");
+    for (let i = 0; i < filesToProcess.length; i++) {
+      const change = filesToProcess[i];
+      log(
+        `Processing ${relative(this.projectRoot, change.path)}`,
+        i + 1,
+        filesToProcess.length
+      );
+      try {
+        const content = readFileSync4(change.path, "utf-8");
+        if (change.type === "modified") {
+          const removedIds = this.metadataStore.removeByFilePath(change.path);
+          for (const id of removedIds) {
+            this.vectorStore.remove(id);
+          }
+          modified++;
+        } else {
+          added++;
+        }
+        const chunks = chunkFile(change.path, content, this.options.chunking);
+        if (chunks.length === 0) {
+          await this.fileTracker.updateFile(change.path, content, []);
+          continue;
+        }
+        const embeddingInputs = chunks.map((c) => prepareEmbeddingInput(c));
+        const embeddings = await this.embeddingClient.embedBatch(embeddingInputs);
+        const chunkIds = [];
+        for (let j = 0; j < chunks.length; j++) {
+          const chunk = chunks[j];
+          const embedding = embeddings[j].embedding;
+          this.vectorStore.add(chunk.id, embedding);
+          const metadata = {
+            filePath: chunk.filePath,
+            startLine: chunk.startLine,
+            endLine: chunk.endLine,
+            startColumn: chunk.startColumn,
+            endColumn: chunk.endColumn,
+            kind: chunk.kind,
+            name: chunk.name,
+            contentHash: hashContentSync(chunk.content),
+            metadata: {
+              props: chunk.metadata.props,
+              hooks: chunk.metadata.hooks,
+              jsxElements: chunk.metadata.jsxElements,
+              isExported: chunk.metadata.isExported,
+              isDefaultExport: chunk.metadata.isDefaultExport
+            }
+          };
+          this.metadataStore.set(chunk.id, metadata);
+          chunkIds.push(chunk.id);
+        }
+        await this.fileTracker.updateFile(change.path, content, chunkIds);
+      } catch (error) {
+        console.warn(`Error processing ${change.path}:`, error);
+      }
+    }
+    return {
+      added,
+      modified,
+      deleted,
+      totalChunks: this.metadataStore.size()
+    };
+  }
+  /**
+   * Get index statistics
+   */
+  getStats() {
+    return {
+      totalFiles: this.fileTracker.getTrackedFiles().length,
+      totalChunks: this.metadataStore.size(),
+      indexSizeBytes: this.vectorStore.getStats().memoryBytes,
+      manifest: this.manifest
+    };
+  }
+  /**
+   * Get the vector store (for queries)
+   */
+  getVectorStore() {
+    return this.vectorStore;
+  }
+  /**
+   * Get the metadata store (for queries)
+   */
+  getMetadataStore() {
+    return this.metadataStore;
+  }
+  /**
+   * Check if index exists
+   */
+  hasIndex() {
+    return existsSync4(join4(this.indexDir, MANIFEST_FILE));
+  }
+};
+function createIndexer(projectRoot, options) {
+  return new IncrementalIndexer(projectRoot, options);
+}
+
+// src/detection/scorer.ts
+function calculateSizeRatio(chunk1, chunk2) {
+  const lines1 = chunk1.endLine - chunk1.startLine + 1;
+  const lines2 = chunk2.endLine - chunk2.startLine + 1;
+  const minLines = Math.min(lines1, lines2);
+  const maxLines = Math.max(lines1, lines2);
+  return maxLines > 0 ? minLines / maxLines : 1;
+}
+function calculateDuplicateScore(similarity, chunk1, chunk2) {
+  const sizeRatio = calculateSizeRatio(chunk1, chunk2);
+  const combinedScore = similarity * 0.85 + sizeRatio * 0.15;
+  return {
+    similarity,
+    sizeRatio,
+    combinedScore
+  };
+}
+function calculateGroupAverageSimilarity(similarities) {
+  if (similarities.length === 0) return 0;
+  return similarities.reduce((sum, s) => sum + s, 0) / similarities.length;
+}
+function sortDuplicateGroups(groups) {
+  return [...groups].sort((a, b) => {
+    const countDiff = b.members.length - a.members.length;
+    if (countDiff !== 0) return countDiff;
+    return b.avgSimilarity - a.avgSimilarity;
+  });
+}
+
+// src/detection/duplicate-finder.ts
+function findDuplicateGroups(vectorStore, metadataStore, options = {}) {
+  const {
+    threshold = 0.85,
+    minGroupSize = 2,
+    kind,
+    excludePaths = []
+  } = options;
+  const groups = [];
+  const processed = /* @__PURE__ */ new Set();
+  let entries = [...metadataStore.entries()];
+  if (kind) {
+    entries = entries.filter(([, meta]) => meta.kind === kind);
+  }
+  if (excludePaths.length > 0) {
+    entries = entries.filter(
+      ([, meta]) => !excludePaths.some((p) => meta.filePath.includes(p))
+    );
+  }
+  for (const [id, metadata] of entries) {
+    if (processed.has(id)) continue;
+    const vector = vectorStore.get(id);
+    if (!vector) continue;
+    const similar = vectorStore.findSimilar(vector, 50, threshold);
+    let candidates = similar.filter((s) => {
+      if (s.id === id) return false;
+      if (processed.has(s.id)) return false;
+      const candidateMeta = metadataStore.get(s.id);
+      if (!candidateMeta) return false;
+      if (kind && candidateMeta.kind !== kind) return false;
+      if (excludePaths.some((p) => candidateMeta.filePath.includes(p)))
+        return false;
+      return true;
+    });
+    if (!kind && candidates.length > 0) {
+      const sameKindCandidates = candidates.filter((c) => {
+        const meta = metadataStore.get(c.id);
+        return meta?.kind === metadata.kind;
+      });
+      if (sameKindCandidates.length > 0) {
+        candidates = sameKindCandidates;
+      }
+    }
+    if (candidates.length >= minGroupSize - 1) {
+      const members = [
+        { id, metadata, score: 1 }
+        // First member (reference)
+      ];
+      const similarities = [];
+      for (const candidate of candidates) {
+        const candidateMeta = metadataStore.get(candidate.id);
+        if (candidateMeta) {
+          members.push({
+            id: candidate.id,
+            metadata: candidateMeta,
+            score: candidate.score
+          });
+          similarities.push(candidate.score);
+          processed.add(candidate.id);
+        }
+      }
+      processed.add(id);
+      groups.push({
+        members,
+        avgSimilarity: calculateGroupAverageSimilarity(similarities),
+        kind: metadata.kind
+      });
+    }
+  }
+  return sortDuplicateGroups(groups);
+}
+function findSimilarToLocation(vectorStore, metadataStore, filePath, line, options = {}) {
+  const { top = 10, threshold = 0.5 } = options;
+  const chunk = metadataStore.getAtLocation(filePath, line);
+  if (!chunk) {
+    return [];
+  }
+  const vector = vectorStore.get(chunk.id);
+  if (!vector) {
+    return [];
+  }
+  const similar = vectorStore.findSimilar(vector, top + 1, threshold);
+  return similar.filter((s) => s.id !== chunk.id).slice(0, top);
+}
+function findSimilarToQuery(vectorStore, queryEmbedding, options = {}) {
+  const { top = 10, threshold = 0.5 } = options;
+  return vectorStore.findSimilar(queryEmbedding, top, threshold);
+}
+
+// src/query/api.ts
+var indexerCache = /* @__PURE__ */ new Map();
+function getIndexer(path, options) {
+  const projectRoot = resolve(path);
+  const cacheKey = projectRoot;
+  let indexer = indexerCache.get(cacheKey);
+  if (!indexer) {
+    indexer = createIndexer(projectRoot, options);
+    indexerCache.set(cacheKey, indexer);
+  }
+  return indexer;
+}
+function clearIndexerCache(path) {
+  if (path) {
+    const projectRoot = resolve(path);
+    indexerCache.delete(projectRoot);
+  } else {
+    indexerCache.clear();
+  }
+}
+async function indexDirectory(path, options = {}) {
+  const projectRoot = resolve(path);
+  clearIndexerCache(projectRoot);
+  const indexer = createIndexer(projectRoot, {
+    model: options.model,
+    baseUrl: options.baseUrl,
+    exclude: options.exclude,
+    onProgress: options.onProgress
+  });
+  indexerCache.set(projectRoot, indexer);
+  if (options.force) {
+    return await indexer.indexAll(true);
+  }
+  if (indexer.hasIndex()) {
+    return await indexer.update();
+  }
+  return await indexer.indexAll(false);
+}
+async function findDuplicates(options = {}) {
+  const projectRoot = resolve(options.path || process.cwd());
+  const indexer = getIndexer(projectRoot);
+  await indexer.load();
+  if (!indexer.hasIndex()) {
+    throw new Error(
+      `No index found at ${projectRoot}. Run 'uilint duplicates index' first.`
+    );
+  }
+  const vectorStore = indexer.getVectorStore();
+  const metadataStore = indexer.getMetadataStore();
+  const groups = findDuplicateGroups(vectorStore, metadataStore, {
+    threshold: options.threshold,
+    minGroupSize: options.minGroupSize,
+    kind: options.kind
+  });
+  return groups.map((group) => ({
+    members: group.members.map((m) => ({
+      filePath: m.metadata.filePath,
+      startLine: m.metadata.startLine,
+      endLine: m.metadata.endLine,
+      name: m.metadata.name,
+      kind: m.metadata.kind,
+      score: m.score
+    })),
+    avgSimilarity: group.avgSimilarity,
+    kind: group.kind
+  }));
+}
+async function searchSimilar(query, options = {}) {
+  const projectRoot = resolve(options.path || process.cwd());
+  const indexer = getIndexer(projectRoot);
+  await indexer.load();
+  if (!indexer.hasIndex()) {
+    throw new Error(
+      `No index found at ${projectRoot}. Run 'uilint duplicates index' first.`
+    );
+  }
+  const embeddingClient = new OllamaEmbeddingClient({
+    model: options.model,
+    baseUrl: options.baseUrl
+  });
+  const queryResult = await embeddingClient.embed(query);
+  const vectorStore = indexer.getVectorStore();
+  const metadataStore = indexer.getMetadataStore();
+  const results = findSimilarToQuery(vectorStore, queryResult.embedding, {
+    top: options.top,
+    threshold: options.threshold
+  });
+  return results.map((r) => {
+    const metadata = metadataStore.get(r.id);
+    if (!metadata) return null;
+    return {
+      filePath: metadata.filePath,
+      startLine: metadata.startLine,
+      endLine: metadata.endLine,
+      name: metadata.name,
+      kind: metadata.kind,
+      score: r.score
+    };
+  }).filter((r) => r !== null);
+}
+async function findSimilarAtLocation(options) {
+  const projectRoot = resolve(options.path || process.cwd());
+  const indexer = getIndexer(projectRoot);
+  await indexer.load();
+  if (!indexer.hasIndex()) {
+    throw new Error(
+      `No index found at ${projectRoot}. Run 'uilint duplicates index' first.`
+    );
+  }
+  const vectorStore = indexer.getVectorStore();
+  const metadataStore = indexer.getMetadataStore();
+  const results = findSimilarToLocation(
+    vectorStore,
+    metadataStore,
+    options.filePath,
+    options.line,
+    {
+      top: options.top,
+      threshold: options.threshold
+    }
+  );
+  return results.map((r) => {
+    const metadata = metadataStore.get(r.id);
+    if (!metadata) return null;
+    return {
+      filePath: metadata.filePath,
+      startLine: metadata.startLine,
+      endLine: metadata.endLine,
+      name: metadata.name,
+      kind: metadata.kind,
+      score: r.score
+    };
+  }).filter((r) => r !== null);
+}
+function hasIndex(path = process.cwd()) {
+  const projectRoot = resolve(path);
+  const indexer = getIndexer(projectRoot);
+  return indexer.hasIndex();
+}
+async function getIndexStats(path = process.cwd()) {
+  const projectRoot = resolve(path);
+  const indexer = getIndexer(projectRoot);
+  await indexer.load();
+  const stats = indexer.getStats();
+  return {
+    totalFiles: stats.totalFiles,
+    totalChunks: stats.totalChunks,
+    indexSizeBytes: stats.indexSizeBytes,
+    embeddingModel: stats.manifest?.embeddingModel || null,
+    lastUpdated: stats.manifest?.updatedAt || null
+  };
+}
+
+export {
+  chunkFile,
+  prepareEmbeddingInput,
+  OllamaEmbeddingClient,
+  getOllamaEmbeddingClient,
+  VectorStore,
+  MetadataStore,
+  hashContent,
+  hashContentSync,
+  FileTracker,
+  IncrementalIndexer,
+  createIndexer,
+  calculateSizeRatio,
+  calculateDuplicateScore,
+  calculateGroupAverageSimilarity,
+  sortDuplicateGroups,
+  findDuplicateGroups,
+  findSimilarToLocation,
+  findSimilarToQuery,
+  clearIndexerCache,
+  indexDirectory,
+  findDuplicates,
+  searchSimilar,
+  findSimilarAtLocation,
+  hasIndex,
+  getIndexStats
+};
+//# sourceMappingURL=chunk-DURWZZLU.js.map