@fragments-sdk/context 0.1.2 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Conan McNicholl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @fragments-sdk/context
+
+Code intelligence and RAG primitives for codebase indexing and search.
+
+## Modules
+
+### Chunking (`@fragments-sdk/context/chunking`)
+
+Split source files into semantically meaningful chunks for embedding.
+
+- **`chunkFile(content, filePath, language)`** — Auto-selects AST or line-based chunking
+- **`chunkByAST(content, filePath, language, grammar)`** — Tree-sitter AST-aware chunking (preserves functions, classes, etc.)
+- **`chunkByLines(content, filePath, language)`** — Sliding-window fallback
+
+AST chunking supports: TypeScript, TSX, JavaScript, Python, Go, Rust, Java.
+
+```ts
+import { chunkFile } from "@fragments-sdk/context/chunking";
+
+const chunks = await chunkFile(code, "src/auth.ts", "typescript");
+// Each chunk has: content, filePath, startLine, endLine, language, symbolName?, scopeChain?
+```
+
+### Embeddings (`@fragments-sdk/context/embeddings`)
+
+Generate code-optimized embeddings via Voyage AI.
+
+- **`generateEmbeddings(texts, options)`** — Batch embed with `voyage-code-3`
+- **`rerankResults(query, documents, options)`** — Cross-encoder reranking with `rerank-2.5`
+
+```ts
+import { generateEmbeddings } from "@fragments-sdk/context/embeddings";
+
+const vectors = await generateEmbeddings(chunks.map(c => c.content), {
+  apiKey: process.env.VOYAGE_API_KEY!,
+  inputType: "document",
+});
+```
+
+### Search (`@fragments-sdk/context/search`)
+
+Post-retrieval utilities for combining and deduplicating results.
+
+- **`reciprocalRankFusion(resultSets)`** — Merge multiple ranked lists (e.g. vector + keyword)
+- **`deduplicateChunks(chunks)`** — Remove near-duplicate results
+
+### Indexing (`@fragments-sdk/context/indexing`)
+
+File filtering, change detection, and language detection.
+
+- **`shouldIndexFile(path, size)`** — Filter by extension, size, ignored dirs
+- **`detectLanguage(path)`** — Map file extension to language name
+- **`resolveChanges(oldFiles, newFiles)`** — Diff two file trees for incremental re-indexing
+- **`hashContent(content)`** — Content hashing for change detection
+
+## Install
+
+```sh
+pnpm add @fragments-sdk/context
+```
+
+Requires Node.js 18+. Tree-sitter WASM grammars are included as dependencies.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragments-sdk/context",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Code intelligence and RAG primitives for design system and codebase indexing",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,14 +34,6 @@
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "eslint src",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist"
-  },
   "dependencies": {
     "tree-sitter-go": "^0.25.0",
     "tree-sitter-java": "^0.23.5",
@@ -56,5 +48,13 @@
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint src",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
   }
-}
+}

package/dist/chunk-3VPR67FN.js

@@ -1,76 +0,0 @@
-// src/embeddings/voyage.ts
-var VOYAGE_EMBEDDINGS_URL = "https://api.voyageai.com/v1/embeddings";
-var VOYAGE_RERANK_URL = "https://api.voyageai.com/v1/rerank";
-var DEFAULT_MODEL = "voyage-code-3";
-var DEFAULT_RERANK_MODEL = "rerank-2.5";
-var DEFAULT_DIMENSIONS = 1024;
-var DEFAULT_MAX_CHARS = 32e3;
-var DEFAULT_BATCH_SIZE = 128;
-async function generateEmbeddings(texts, options) {
-  if (texts.length === 0) return [];
-  const maxChars = options.maxChars ?? DEFAULT_MAX_CHARS;
-  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
-  const dimensions = options.dimensions ?? DEFAULT_DIMENSIONS;
-  const truncated = texts.map(
-    (t) => t.length > maxChars ? t.slice(0, maxChars) : t
-  );
-  const results = [];
-  for (let i = 0; i < truncated.length; i += batchSize) {
-    const batch = truncated.slice(i, i + batchSize);
-    const response = await fetch(VOYAGE_EMBEDDINGS_URL, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${options.apiKey}`
-      },
-      body: JSON.stringify({
-        model: DEFAULT_MODEL,
-        input: batch,
-        input_type: options.inputType,
-        output_dimension: dimensions
-      })
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Voyage API error ${response.status}: ${body}`);
-    }
-    const data = await response.json();
-    const sorted = data.data.sort((a, b) => a.index - b.index);
-    for (const item of sorted) {
-      results.push(item.embedding);
-    }
-  }
-  return results;
-}
-async function rerankResults(query, documents, options) {
-  if (documents.length === 0) return [];
-  const topK = options.topK ?? 15;
-  const model = options.model ?? DEFAULT_RERANK_MODEL;
-  const response = await fetch(VOYAGE_RERANK_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${options.apiKey}`
-    },
-    body: JSON.stringify({
-      model,
-      query,
-      documents,
-      top_k: topK
-    })
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Voyage Rerank API error ${response.status}: ${body}`);
-  }
-  const data = await response.json();
-  return data.data.map((item) => ({
-    index: item.index,
-    relevanceScore: item.relevance_score
-  }));
-}
-
-export {
-  generateEmbeddings,
-  rerankResults
-};

package/dist/chunk-HINI3FCI.js

@@ -1,42 +0,0 @@
-// src/indexing/hasher.ts
-import { createHash } from "crypto";
-function hashContent(content) {
-  return createHash("sha256").update(content, "utf-8").digest("hex");
-}
-
-// src/indexing/diff-resolver.ts
-function resolveChanges(oldEntries, newEntries) {
-  const oldMap = /* @__PURE__ */ new Map();
-  for (const entry of oldEntries) {
-    oldMap.set(entry.filePath, entry);
-  }
-  const newMap = /* @__PURE__ */ new Map();
-  for (const entry of newEntries) {
-    newMap.set(entry.filePath, entry);
-  }
-  const added = [];
-  const modified = [];
-  const unchanged = [];
-  const deleted = [];
-  for (const [filePath, newEntry] of newMap) {
-    const oldEntry = oldMap.get(filePath);
-    if (!oldEntry) {
-      added.push(filePath);
-    } else if (oldEntry.contentHash !== newEntry.contentHash) {
-      modified.push(filePath);
-    } else {
-      unchanged.push(filePath);
-    }
-  }
-  for (const filePath of oldMap.keys()) {
-    if (!newMap.has(filePath)) {
-      deleted.push(filePath);
-    }
-  }
-  return { added, modified, deleted, unchanged };
-}
-
-export {
-  hashContent,
-  resolveChanges
-};

package/dist/chunk-JFV27WLV.js

@@ -1,168 +0,0 @@
-// src/indexing/file-filter.ts
-var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".ts",
-  ".tsx",
-  ".js",
-  ".jsx",
-  ".mjs",
-  ".cjs",
-  ".py",
-  ".go",
-  ".rs",
-  ".java",
-  ".kt",
-  ".swift",
-  ".c",
-  ".cpp",
-  ".h",
-  ".hpp",
-  ".cs",
-  ".rb",
-  ".php",
-  ".scala",
-  ".sh",
-  ".bash",
-  ".zsh",
-  ".sql",
-  ".graphql",
-  ".gql",
-  ".css",
-  ".scss",
-  ".less",
-  ".html",
-  ".svelte",
-  ".vue",
-  ".md",
-  ".mdx",
-  ".json",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".xml",
-  ".proto",
-  ".tf",
-  ".hcl",
-  ".dockerfile",
-  ".prisma"
-]);
-var IGNORED_DIRS = [
-  "node_modules/",
-  "dist/",
-  ".git/",
-  ".next/",
-  "__pycache__/",
-  ".cache/",
-  "coverage/",
-  "build/",
-  ".turbo/",
-  "vendor/",
-  ".venv/"
-];
-var IGNORED_FILES = [
-  "pnpm-lock.yaml",
-  "package-lock.json",
-  "yarn.lock",
-  "bun.lockb",
-  "Cargo.lock",
-  "go.sum",
-  "poetry.lock",
-  "Pipfile.lock",
-  "composer.lock",
-  "Gemfile.lock"
-];
-var MAX_FILE_SIZE = 100 * 1024;
-function shouldIndexFile(path, size) {
-  if (size > MAX_FILE_SIZE) return false;
-  if (IGNORED_FILES.includes(path.split("/").pop() ?? "")) return false;
-  for (const dir of IGNORED_DIRS) {
-    if (path.includes(dir)) return false;
-  }
-  const ext = getExtension(path);
-  if (!ext) {
-    const basename = path.split("/").pop() ?? "";
-    return basename === "Dockerfile" || basename === "Makefile";
-  }
-  return INDEXABLE_EXTENSIONS.has(ext);
-}
-var LANGUAGE_MAP = {
-  ".ts": { language: "typescript", grammar: "typescript" },
-  ".tsx": { language: "typescript", grammar: "tsx" },
-  ".js": { language: "javascript", grammar: "javascript" },
-  ".jsx": { language: "javascript", grammar: "javascript" },
-  ".mjs": { language: "javascript", grammar: "javascript" },
-  ".cjs": { language: "javascript", grammar: "javascript" },
-  ".py": { language: "python", grammar: "python" },
-  ".go": { language: "go", grammar: "go" },
-  ".rs": { language: "rust", grammar: "rust" },
-  ".java": { language: "java", grammar: "java" },
-  ".kt": { language: "kotlin", grammar: "" },
-  ".swift": { language: "swift", grammar: "" },
-  ".c": { language: "c", grammar: "" },
-  ".cpp": { language: "cpp", grammar: "" },
-  ".h": { language: "c", grammar: "" },
-  ".hpp": { language: "cpp", grammar: "" },
-  ".cs": { language: "csharp", grammar: "" },
-  ".rb": { language: "ruby", grammar: "" },
-  ".php": { language: "php", grammar: "" },
-  ".scala": { language: "scala", grammar: "" },
-  ".sh": { language: "shell", grammar: "" },
-  ".bash": { language: "shell", grammar: "" },
-  ".zsh": { language: "shell", grammar: "" },
-  ".sql": { language: "sql", grammar: "" },
-  ".graphql": { language: "graphql", grammar: "" },
-  ".gql": { language: "graphql", grammar: "" },
-  ".css": { language: "css", grammar: "" },
-  ".scss": { language: "scss", grammar: "" },
-  ".less": { language: "less", grammar: "" },
-  ".html": { language: "html", grammar: "" },
-  ".svelte": { language: "svelte", grammar: "" },
-  ".vue": { language: "vue", grammar: "" },
-  ".md": { language: "markdown", grammar: "" },
-  ".mdx": { language: "markdown", grammar: "" },
-  ".json": { language: "json", grammar: "" },
-  ".yaml": { language: "yaml", grammar: "" },
-  ".yml": { language: "yaml", grammar: "" },
-  ".toml": { language: "toml", grammar: "" },
-  ".xml": { language: "xml", grammar: "" },
-  ".proto": { language: "protobuf", grammar: "" },
-  ".tf": { language: "terraform", grammar: "" },
-  ".hcl": { language: "hcl", grammar: "" },
-  ".dockerfile": { language: "dockerfile", grammar: "" },
-  ".prisma": { language: "prisma", grammar: "" }
-};
-var AST_SUPPORTED_LANGUAGES = /* @__PURE__ */ new Set([
-  "typescript",
-  "tsx",
-  "javascript",
-  "python",
-  "go",
-  "rust",
-  "java"
-]);
-function detectLanguage(path) {
-  const ext = getExtension(path);
-  if (ext && ext in LANGUAGE_MAP) return LANGUAGE_MAP[ext].language;
-  const basename = path.split("/").pop() ?? "";
-  if (basename === "Dockerfile") return "dockerfile";
-  if (basename === "Makefile") return "makefile";
-  return "unknown";
-}
-function getTreeSitterGrammar(path) {
-  const ext = getExtension(path);
-  if (ext && ext in LANGUAGE_MAP) return LANGUAGE_MAP[ext].grammar;
-  return "";
-}
-function getExtension(path) {
-  const basename = path.split("/").pop() ?? "";
-  const dotIdx = basename.lastIndexOf(".");
-  if (dotIdx <= 0) return "";
-  return basename.slice(dotIdx).toLowerCase();
-}
-
-export {
-  INDEXABLE_EXTENSIONS,
-  shouldIndexFile,
-  AST_SUPPORTED_LANGUAGES,
-  detectLanguage,
-  getTreeSitterGrammar
-};

package/dist/chunk-KQIRG24U.js

@@ -1,260 +0,0 @@
-import {
-  AST_SUPPORTED_LANGUAGES,
-  getTreeSitterGrammar
-} from "./chunk-JFV27WLV.js";
-
-// src/chunking/line-chunker.ts
-function chunkByLines(content, filePath, language, options) {
-  const chunkSize = options?.maxChunkLines ?? 50;
-  const overlap = options?.overlapLines ?? 10;
-  const lines = content.split("\n");
-  if (lines.length === 0 || lines.length === 1 && lines[0].trim() === "") {
-    return [];
-  }
-  const header = `// File: ${filePath}
-`;
-  const chunks = [];
-  if (lines.length <= chunkSize) {
-    chunks.push({
-      content: header + lines.join("\n"),
-      filePath,
-      startLine: 1,
-      endLine: lines.length,
-      language,
-      chunkType: "module"
-    });
-    return chunks;
-  }
-  let start = 0;
-  while (start < lines.length) {
-    const end = Math.min(start + chunkSize, lines.length);
-    chunks.push({
-      content: header + lines.slice(start, end).join("\n"),
-      filePath,
-      startLine: start + 1,
-      endLine: end,
-      language,
-      chunkType: "block"
-    });
-    if (end >= lines.length) break;
-    start += chunkSize - overlap;
-  }
-  return chunks;
-}
-
-// src/chunking/ast-chunker.ts
-var SYMBOL_NODE_TYPES = /* @__PURE__ */ new Set([
-  // TypeScript / JavaScript
-  "function_declaration",
-  "method_definition",
-  "arrow_function",
-  "class_declaration",
-  "interface_declaration",
-  "type_alias_declaration",
-  "enum_declaration",
-  "export_statement",
-  "lexical_declaration",
-  "variable_declaration",
-  // Python
-  "function_definition",
-  "class_definition",
-  "decorated_definition",
-  // Go
-  "function_declaration",
-  "method_declaration",
-  "type_declaration",
-  // Rust
-  "function_item",
-  "impl_item",
-  "struct_item",
-  "enum_item",
-  "trait_item",
-  // Java
-  "method_declaration",
-  "class_declaration",
-  "interface_declaration",
-  "enum_declaration",
-  "constructor_declaration"
-]);
-var NAME_FIELD_NODES = /* @__PURE__ */ new Set([
-  "function_declaration",
-  "method_definition",
-  "class_declaration",
-  "interface_declaration",
-  "type_alias_declaration",
-  "enum_declaration",
-  "function_definition",
-  "class_definition",
-  "function_item",
-  "impl_item",
-  "struct_item",
-  "enum_item",
-  "trait_item",
-  "method_declaration",
-  "constructor_declaration"
-]);
-var tsModule = null;
-var initialized = false;
-async function getTreeSitter() {
-  if (!tsModule) {
-    const mod = await import("web-tree-sitter");
-    tsModule = mod;
-  }
-  if (!initialized) {
-    await tsModule.Parser.init();
-    initialized = true;
-  }
-  return tsModule;
-}
-var GRAMMAR_PACKAGES = {
-  typescript: "tree-sitter-typescript/tree-sitter-typescript.wasm",
-  tsx: "tree-sitter-typescript/tree-sitter-tsx.wasm",
-  javascript: "tree-sitter-javascript/tree-sitter-javascript.wasm",
-  python: "tree-sitter-python/tree-sitter-python.wasm",
-  go: "tree-sitter-go/tree-sitter-go.wasm",
-  rust: "tree-sitter-rust/tree-sitter-rust.wasm",
-  java: "tree-sitter-java/tree-sitter-java.wasm"
-};
-var languageCache = /* @__PURE__ */ new Map();
-async function loadLanguage(grammarName, wasmBasePath) {
-  const cached = languageCache.get(grammarName);
-  if (cached) return cached;
-  const { Language } = await getTreeSitter();
-  const grammarFile = GRAMMAR_PACKAGES[grammarName];
-  if (!grammarFile) {
-    throw new Error(`No grammar available for: ${grammarName}`);
-  }
-  let wasmPath;
-  if (wasmBasePath) {
-    wasmPath = `${wasmBasePath}/${grammarFile}`;
-  } else {
-    const { createRequire } = await import("module");
-    const require2 = createRequire(import.meta.url);
-    wasmPath = require2.resolve(grammarFile);
-  }
-  const lang = await Language.load(wasmPath);
-  languageCache.set(grammarName, lang);
-  return lang;
-}
-function getNodeName(node) {
-  if (!NAME_FIELD_NODES.has(node.type)) return void 0;
-  const nameNode = node.childForFieldName("name");
-  return nameNode?.text;
-}
-function getChunkType(nodeType) {
-  if (nodeType.includes("function") || nodeType.includes("method") || nodeType === "arrow_function" || nodeType === "constructor_declaration") {
-    return "function";
-  }
-  if (nodeType.includes("class") || nodeType.includes("impl") || nodeType.includes("struct") || nodeType.includes("trait") || nodeType.includes("interface") || nodeType.includes("enum")) {
-    return "class";
-  }
-  return "block";
-}
-function extractChunks(node, parentScope, maxChars, minChars) {
-  const text = node.text;
-  const charCount = text.length;
-  if (charCount <= maxChars && SYMBOL_NODE_TYPES.has(node.type)) {
-    const name2 = getNodeName(node);
-    const scopeChain = parentScope ? name2 ? `${parentScope}.${name2}` : parentScope : name2;
-    return [{
-      text,
-      startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1,
-      symbolName: name2,
-      scopeChain,
-      chunkType: getChunkType(node.type)
-    }];
-  }
-  if (charCount <= maxChars && node.childCount === 0) {
-    return [{
-      text,
-      startLine: node.startPosition.row + 1,
-      endLine: node.endPosition.row + 1,
-      chunkType: "block"
-    }];
-  }
-  const name = getNodeName(node);
-  const currentScope = parentScope ? name ? `${parentScope}.${name}` : parentScope : name ?? "";
-  const childChunks = [];
-  for (const child of node.namedChildren) {
-    const chunks = extractChunks(child, currentScope, maxChars, minChars);
-    childChunks.push(...chunks);
-  }
-  return mergeSmallChunks(childChunks, maxChars, minChars);
-}
-function mergeSmallChunks(chunks, maxChars, minChars) {
-  if (chunks.length === 0) return chunks;
-  const merged = [];
-  let current = chunks[0];
-  for (let i = 1; i < chunks.length; i++) {
-    const next = chunks[i];
-    const combinedLength = current.text.length + next.text.length + 1;
-    if (combinedLength <= maxChars && current.text.length < minChars) {
-      current = {
-        text: current.text + "\n" + next.text,
-        startLine: current.startLine,
-        endLine: next.endLine,
-        symbolName: current.symbolName ?? next.symbolName,
-        scopeChain: current.scopeChain ?? next.scopeChain,
-        chunkType: current.symbolName ? current.chunkType : next.symbolName ? next.chunkType : "mixed"
-      };
-    } else {
-      merged.push(current);
-      current = next;
-    }
-  }
-  merged.push(current);
-  return merged;
-}
-async function chunkByAST(content, filePath, language, grammarName, options) {
-  const maxChars = options?.maxChunkChars ?? 1500;
-  const minChars = options?.minChunkChars ?? 100;
-  const lang = await loadLanguage(grammarName, options?.wasmBasePath);
-  const { Parser } = await getTreeSitter();
-  const parser = new Parser();
-  parser.setLanguage(lang);
-  const tree = parser.parse(content);
-  const rawChunks = extractChunks(tree.rootNode, "", maxChars, minChars);
-  if (rawChunks.length === 0) {
-    return [{
-      content: `// File: ${filePath}
-${content}`,
-      filePath,
-      startLine: 1,
-      endLine: content.split("\n").length,
-      language,
-      chunkType: "module"
-    }];
-  }
-  return rawChunks.map((chunk) => ({
-    content: `// File: ${filePath}
-${chunk.scopeChain ? `// Scope: ${chunk.scopeChain}
-` : ""}${chunk.text}`,
-    filePath,
-    startLine: chunk.startLine,
-    endLine: chunk.endLine,
-    language,
-    symbolName: chunk.symbolName,
-    scopeChain: chunk.scopeChain,
-    chunkType: chunk.chunkType
-  }));
-}
-
-// src/chunking/index.ts
-async function chunkFile(content, filePath, language, options) {
-  const grammarName = getTreeSitterGrammar(filePath);
-  if (grammarName && AST_SUPPORTED_LANGUAGES.has(grammarName)) {
-    try {
-      return await chunkByAST(content, filePath, language, grammarName, options);
-    } catch (err) {
-      console.warn(`AST chunking failed for ${filePath}, falling back to line-based:`, err);
-    }
-  }
-  return chunkByLines(content, filePath, language, options);
-}
-
-export {
-  chunkByLines,
-  chunkByAST,
-  chunkFile
-};

package/dist/chunk-ZMBYQK43.js

@@ -1,91 +0,0 @@
-// src/search/fusion.ts
-function reciprocalRankFusion(resultSets, k = 60) {
-  const scoreMap = /* @__PURE__ */ new Map();
-  for (const { label, results } of resultSets) {
-    for (let rank = 0; rank < results.length; rank++) {
-      const result = results[rank];
-      const rrfScore = 1 / (k + rank + 1);
-      const existing = scoreMap.get(result.id);
-      if (existing) {
-        existing.score += rrfScore;
-        existing.sources.push(label);
-      } else {
-        scoreMap.set(result.id, {
-          score: rrfScore,
-          sources: [label]
-        });
-      }
-    }
-  }
-  const fused = [];
-  for (const [id, { score, sources }] of scoreMap) {
-    fused.push({ id, fusedScore: score, sources });
-  }
-  fused.sort((a, b) => b.fusedScore - a.fusedScore);
-  return fused;
-}
-
-// src/search/deduplicator.ts
-function deduplicateChunks(chunks) {
-  if (chunks.length <= 1) return chunks;
-  const byFile = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const group = byFile.get(chunk.filePath);
-    if (group) {
-      group.push(chunk);
-    } else {
-      byFile.set(chunk.filePath, [chunk]);
-    }
-  }
-  const result = [];
-  for (const [, fileChunks] of byFile) {
-    if (fileChunks.length === 1) {
-      result.push(fileChunks[0]);
-      continue;
-    }
-    fileChunks.sort((a, b) => a.startLine - b.startLine);
-    const merged = mergeOverlapping(fileChunks);
-    result.push(...merged);
-  }
-  result.sort((a, b) => b.score - a.score);
-  return result;
-}
-function mergeOverlapping(chunks) {
-  const merged = [];
-  let current = { ...chunks[0] };
-  for (let i = 1; i < chunks.length; i++) {
-    const next = chunks[i];
-    if (next.startLine <= current.endLine + 1) {
-      const currentLines = current.content.split("\n");
-      const nextLines = next.content.split("\n");
-      const overlapStart = next.startLine - current.startLine;
-      const newLines = nextLines.slice(current.endLine - next.startLine + 1);
-      if (newLines.length > 0) {
-        current = {
-          ...current,
-          content: currentLines.join("\n") + "\n" + newLines.join("\n"),
-          endLine: Math.max(current.endLine, next.endLine),
-          score: Math.max(current.score, next.score),
-          // Keep symbolName from higher-scored chunk
-          symbolName: current.score >= next.score ? current.symbolName : next.symbolName
-        };
-      } else {
-        current = {
-          ...current,
-          endLine: Math.max(current.endLine, next.endLine),
-          score: Math.max(current.score, next.score)
-        };
-      }
-    } else {
-      merged.push(current);
-      current = { ...next };
-    }
-  }
-  merged.push(current);
-  return merged;
-}
-
-export {
-  reciprocalRankFusion,
-  deduplicateChunks
-};

package/dist/chunking/index.d.ts

@@ -1,53 +0,0 @@
-interface CodeChunk {
-    content: string;
-    filePath: string;
-    startLine: number;
-    endLine: number;
-    language: string;
-    /** Name of the top-level symbol (function, class, etc.) this chunk represents. */
-    symbolName?: string;
-    /** Dot-separated scope chain, e.g. "UserService.login". */
-    scopeChain?: string;
-    /** What kind of AST node this chunk represents. */
-    chunkType?: "function" | "class" | "module" | "block" | "mixed";
-}
-interface ChunkOptions {
-    /** Max characters per chunk (default: 1500). */
-    maxChunkChars?: number;
-    /** Min characters to avoid tiny chunks (default: 100). */
-    minChunkChars?: number;
-    /** Number of overlap lines for line-based fallback (default: 10). */
-    overlapLines?: number;
-    /** Max lines per chunk for line-based fallback (default: 50). */
-    maxChunkLines?: number;
-}
-
-interface ASTChunkerOptions extends ChunkOptions {
-    /** Base path for WASM grammar files. If not set, resolves from node_modules. */
-    wasmBasePath?: string;
-}
-/**
- * AST-aware chunker using tree-sitter.
- *
- * Algorithm: parse AST → if node fits budget, keep as one chunk →
- * if too large, recurse into children → greedily merge adjacent small siblings.
- *
- * Each chunk is enriched with file path, scope chain, and symbol name.
- */
-declare function chunkByAST(content: string, filePath: string, language: string, grammarName: string, options?: ASTChunkerOptions): Promise<CodeChunk[]>;
-
-/**
- * Line-based chunker — splits file content into fixed-size chunks with overlap.
- * Used as fallback when AST parsing is unavailable for a language.
- */
-declare function chunkByLines(content: string, filePath: string, language: string, options?: ChunkOptions): CodeChunk[];
-
-/**
- * Main entry point for chunking a file.
- *
- * Tries AST-aware chunking if tree-sitter supports the language,
- * falls back to line-based chunking otherwise.
- */
-declare function chunkFile(content: string, filePath: string, language: string, options?: ASTChunkerOptions): Promise<CodeChunk[]>;
-
-export { type ASTChunkerOptions, type ChunkOptions, type CodeChunk, chunkByAST, chunkByLines, chunkFile };

package/dist/chunking/index.js

@@ -1,11 +0,0 @@
-import {
-  chunkByAST,
-  chunkByLines,
-  chunkFile
-} from "../chunk-KQIRG24U.js";
-import "../chunk-JFV27WLV.js";
-export {
-  chunkByAST,
-  chunkByLines,
-  chunkFile
-};

package/dist/embeddings/voyage.d.ts

@@ -1,44 +0,0 @@
-interface EmbeddingOptions {
-    /** API key for the embedding provider. */
-    apiKey: string;
-    /** Whether the input is a document (for indexing) or a query (for search). */
-    inputType: "document" | "query";
-    /** Number of dimensions for the embedding vector (default: 1024). */
-    dimensions?: number;
-    /** Max characters per text before truncation (default: 32000). */
-    maxChars?: number;
-    /** Number of texts to embed per API call (default: 128). */
-    batchSize?: number;
-}
-interface RerankOptions {
-    /** API key for the reranking provider. */
-    apiKey: string;
-    /** Number of top results to return (default: 15). */
-    topK?: number;
-    /** Model to use for reranking (default: "rerank-2.5"). */
-    model?: string;
-}
-interface EmbeddingResult {
-    embedding: number[];
-    index: number;
-}
-interface RerankResult {
-    index: number;
-    relevanceScore: number;
-}
-
-/**
- * Generate embeddings using Voyage AI's code-optimized model.
- *
- * Supports asymmetric embedding: use inputType "document" for indexing
- * and "query" for search queries.
- */
-declare function generateEmbeddings(texts: string[], options: EmbeddingOptions): Promise<number[][]>;
-/**
- * Rerank documents using Voyage AI's cross-encoder model.
- *
- * Takes a query and candidate documents, returns them reranked by relevance.
- */
-declare function rerankResults(query: string, documents: string[], options: RerankOptions): Promise<RerankResult[]>;
-
-export { type EmbeddingOptions, type EmbeddingResult, type RerankOptions, type RerankResult, generateEmbeddings, rerankResults };

package/dist/embeddings/voyage.js

@@ -1,8 +0,0 @@
-import {
-  generateEmbeddings,
-  rerankResults
-} from "../chunk-3VPR67FN.js";
-export {
-  generateEmbeddings,
-  rerankResults
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { ASTChunkerOptions, ChunkOptions, CodeChunk, chunkByAST, chunkByLines, chunkFile } from './chunking/index.js';
-export { EmbeddingOptions, EmbeddingResult, RerankOptions, RerankResult, generateEmbeddings, rerankResults } from './embeddings/voyage.js';
-export { FusedResult, RankedResult, ScoredChunk, SearchResult, deduplicateChunks, reciprocalRankFusion } from './search/index.js';
-export { AST_SUPPORTED_LANGUAGES, ChangedFiles, FileEntry, GrammarMapping, INDEXABLE_EXTENSIONS, detectLanguage, getTreeSitterGrammar, hashContent, resolveChanges, shouldIndexFile } from './indexing/index.js';

package/dist/index.js

@@ -1,40 +0,0 @@
-import {
-  chunkByAST,
-  chunkByLines,
-  chunkFile
-} from "./chunk-KQIRG24U.js";
-import {
-  generateEmbeddings,
-  rerankResults
-} from "./chunk-3VPR67FN.js";
-import {
-  deduplicateChunks,
-  reciprocalRankFusion
-} from "./chunk-ZMBYQK43.js";
-import {
-  hashContent,
-  resolveChanges
-} from "./chunk-HINI3FCI.js";
-import {
-  AST_SUPPORTED_LANGUAGES,
-  INDEXABLE_EXTENSIONS,
-  detectLanguage,
-  getTreeSitterGrammar,
-  shouldIndexFile
-} from "./chunk-JFV27WLV.js";
-export {
-  AST_SUPPORTED_LANGUAGES,
-  INDEXABLE_EXTENSIONS,
-  chunkByAST,
-  chunkByLines,
-  chunkFile,
-  deduplicateChunks,
-  detectLanguage,
-  generateEmbeddings,
-  getTreeSitterGrammar,
-  hashContent,
-  reciprocalRankFusion,
-  rerankResults,
-  resolveChanges,
-  shouldIndexFile
-};

package/dist/indexing/index.d.ts

@@ -1,52 +0,0 @@
-/**
- * Compute a SHA-256 hash of the given content.
- * Used for incremental indexing — only re-embed files whose hash has changed.
- */
-declare function hashContent(content: string): string;
-
-interface FileEntry {
-    /** File path relative to repo root. */
-    filePath: string;
-    /** SHA-256 content hash. */
-    contentHash: string;
-    /** Optional: IDs of chunks generated from this file. */
-    chunkIds?: string[];
-}
-interface ChangedFiles {
-    /** Files that are new (not in old set). */
-    added: string[];
-    /** Files that exist in both but have different content hashes. */
-    modified: string[];
-    /** Files that were in old set but not in new set. */
-    deleted: string[];
-    /** Files that are unchanged. */
-    unchanged: string[];
-}
-/** Mapping from file extension to tree-sitter grammar name. */
-interface GrammarMapping {
-    extension: string;
-    language: string;
-    treeSitterGrammar: string;
-}
-
-/**
- * Compare old and new file entry lists to determine which files were
- * added, modified, deleted, or unchanged.
- *
- * Uses content hashes for comparison — two files with identical content
- * are considered unchanged even if their metadata differs.
- */
-declare function resolveChanges(oldEntries: FileEntry[], newEntries: FileEntry[]): ChangedFiles;
-
-declare const INDEXABLE_EXTENSIONS: Set<string>;
-declare function shouldIndexFile(path: string, size: number): boolean;
-/** Languages that have tree-sitter grammar support for AST chunking. */
-declare const AST_SUPPORTED_LANGUAGES: Set<string>;
-declare function detectLanguage(path: string): string;
-/**
- * Get the tree-sitter grammar name for a file extension.
- * Returns empty string if no grammar is available (falls back to line chunker).
- */
-declare function getTreeSitterGrammar(path: string): string;
-
-export { AST_SUPPORTED_LANGUAGES, type ChangedFiles, type FileEntry, type GrammarMapping, INDEXABLE_EXTENSIONS, detectLanguage, getTreeSitterGrammar, hashContent, resolveChanges, shouldIndexFile };

package/dist/indexing/index.js

@@ -1,20 +0,0 @@
-import {
-  hashContent,
-  resolveChanges
-} from "../chunk-HINI3FCI.js";
-import {
-  AST_SUPPORTED_LANGUAGES,
-  INDEXABLE_EXTENSIONS,
-  detectLanguage,
-  getTreeSitterGrammar,
-  shouldIndexFile
-} from "../chunk-JFV27WLV.js";
-export {
-  AST_SUPPORTED_LANGUAGES,
-  INDEXABLE_EXTENSIONS,
-  detectLanguage,
-  getTreeSitterGrammar,
-  hashContent,
-  resolveChanges,
-  shouldIndexFile
-};

package/dist/search/index.d.ts

@@ -1,64 +0,0 @@
-interface SearchResult {
-    /** Unique identifier for the result. */
-    id: string;
-    /** Rank position in the result list (0-indexed). */
-    rank: number;
-    /** Optional score from the search system. */
-    score?: number;
-}
-interface RankedResult extends SearchResult {
-    /** The content or document associated with this result. */
-    content: string;
-    /** File path of the source. */
-    filePath: string;
-    /** Start line in the source file. */
-    startLine: number;
-    /** End line in the source file. */
-    endLine: number;
-}
-interface FusedResult {
-    /** Unique identifier for the result. */
-    id: string;
-    /** Fused RRF score across all result sets. */
-    fusedScore: number;
-    /** Which result sets contributed to this result. */
-    sources: string[];
-}
-interface ScoredChunk {
-    id: string;
-    content: string;
-    filePath: string;
-    startLine: number;
-    endLine: number;
-    language: string;
-    score: number;
-    symbolName?: string;
-    chunkType?: string;
-}
-
-/**
- * Reciprocal Rank Fusion (RRF) — merges multiple ranked result lists
- * into a single ranking using the formula: score = sum(1 / (k + rank))
- *
- * This is a standard technique for combining results from different
- * search systems (e.g., vector search + BM25 full-text search).
- *
- * @param resultSets - Array of result sets, each with a label and ranked results
- * @param k - Smoothing constant (default: 60, as per the original RRF paper)
- * @returns Fused results sorted by combined score (highest first)
- */
-declare function reciprocalRankFusion(resultSets: Array<{
-    label: string;
-    results: SearchResult[];
-}>, k?: number): FusedResult[];
-
-/**
- * Deduplicate and merge overlapping chunks from the same file.
- *
- * When hybrid search + reranking returns multiple chunks from the same file
- * with overlapping line ranges, merge them into a single contiguous block
- * to avoid redundancy in the LLM context window.
- */
-declare function deduplicateChunks(chunks: ScoredChunk[]): ScoredChunk[];
-
-export { type FusedResult, type RankedResult, type ScoredChunk, type SearchResult, deduplicateChunks, reciprocalRankFusion };

package/dist/search/index.js

@@ -1,8 +0,0 @@
-import {
-  deduplicateChunks,
-  reciprocalRankFusion
-} from "../chunk-ZMBYQK43.js";
-export {
-  deduplicateChunks,
-  reciprocalRankFusion
-};