raggrep 0.1.0

package/dist/index.js

@@ -0,0 +1,1378 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+// src/domain/entities/searchResult.ts
+var init_searchResult = () => {};
+
+// src/domain/entities/config.ts
+function createDefaultConfig() {
+  return {
+    version: "0.1.0",
+    indexDir: ".raggrep",
+    extensions: DEFAULT_EXTENSIONS,
+    ignorePaths: DEFAULT_IGNORE_PATHS,
+    modules: [
+      {
+        id: "semantic",
+        enabled: true,
+        options: {
+          embeddingModel: "all-MiniLM-L6-v2"
+        }
+      }
+    ]
+  };
+}
+var DEFAULT_IGNORE_PATHS, DEFAULT_EXTENSIONS;
+var init_config = __esm(() => {
+  DEFAULT_IGNORE_PATHS = [
+    "node_modules",
+    ".pnpm-store",
+    ".yarn",
+    "vendor",
+    ".git",
+    "dist",
+    "build",
+    "out",
+    ".output",
+    "target",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".vercel",
+    ".netlify",
+    ".cache",
+    ".turbo",
+    ".parcel-cache",
+    ".eslintcache",
+    "coverage",
+    ".nyc_output",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".pytest_cache",
+    "*.egg-info",
+    ".idea",
+    ".raggrep"
+  ];
+  DEFAULT_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".md"
+  ];
+});
+
+// src/domain/entities/index.ts
+var init_entities = __esm(() => {
+  init_searchResult();
+  init_config();
+});
+
+// src/utils/embeddings.ts
+import { pipeline, env } from "@xenova/transformers";
+import * as path from "path";
+import * as os from "os";
+function configureEmbeddings(config) {
+  const newConfig = { ...currentConfig, ...config };
+  if (newConfig.model !== currentConfig.model) {
+    embeddingPipeline = null;
+    currentModelName = null;
+  }
+  currentConfig = newConfig;
+}
+async function initializePipeline() {
+  if (embeddingPipeline && currentModelName === currentConfig.model) {
+    return;
+  }
+  if (isInitializing && initPromise) {
+    return initPromise;
+  }
+  isInitializing = true;
+  initPromise = (async () => {
+    const modelId = EMBEDDING_MODELS[currentConfig.model];
+    if (currentConfig.showProgress) {
+      console.log(`
+  Loading embedding model: ${currentConfig.model}`);
+      console.log(`  Cache: ${CACHE_DIR}`);
+    }
+    try {
+      embeddingPipeline = await pipeline("feature-extraction", modelId, {
+        progress_callback: currentConfig.showProgress ? (progress) => {
+          if (progress.status === "progress" && progress.file) {
+            const pct = progress.progress ? Math.round(progress.progress) : 0;
+            process.stdout.write(`\r  Downloading ${progress.file}: ${pct}%   `);
+          } else if (progress.status === "done" && progress.file) {
+            process.stdout.write(`\r  Downloaded ${progress.file}              
+`);
+          } else if (progress.status === "ready") {}
+        } : undefined
+      });
+      currentModelName = currentConfig.model;
+      if (currentConfig.showProgress) {
+        console.log(`  Model ready.
+`);
+      }
+    } catch (error) {
+      embeddingPipeline = null;
+      currentModelName = null;
+      throw new Error(`Failed to load embedding model: ${error}`);
+    } finally {
+      isInitializing = false;
+      initPromise = null;
+    }
+  })();
+  return initPromise;
+}
+async function getEmbedding(text) {
+  await initializePipeline();
+  if (!embeddingPipeline) {
+    throw new Error("Embedding pipeline not initialized");
+  }
+  const output = await embeddingPipeline(text, {
+    pooling: "mean",
+    normalize: true
+  });
+  return Array.from(output.data);
+}
+async function getEmbeddings(texts) {
+  if (texts.length === 0)
+    return [];
+  await initializePipeline();
+  if (!embeddingPipeline) {
+    throw new Error("Embedding pipeline not initialized");
+  }
+  const results = [];
+  for (let i = 0;i < texts.length; i += BATCH_SIZE) {
+    const batch = texts.slice(i, i + BATCH_SIZE);
+    const outputs = await Promise.all(batch.map(async (text) => {
+      const output = await embeddingPipeline(text, {
+        pooling: "mean",
+        normalize: true
+      });
+      return Array.from(output.data);
+    }));
+    results.push(...outputs);
+  }
+  return results;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error("Vectors must have the same 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];
+  }
+  if (normA === 0 || normB === 0)
+    return 0;
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function getEmbeddingConfig() {
+  return { ...currentConfig };
+}
+var CACHE_DIR, EMBEDDING_MODELS, embeddingPipeline = null, currentModelName = null, isInitializing = false, initPromise = null, DEFAULT_CONFIG, currentConfig, BATCH_SIZE = 32;
+var init_embeddings = __esm(() => {
+  CACHE_DIR = path.join(os.homedir(), ".cache", "raggrep", "models");
+  env.cacheDir = CACHE_DIR;
+  env.allowLocalModels = true;
+  EMBEDDING_MODELS = {
+    "all-MiniLM-L6-v2": "Xenova/all-MiniLM-L6-v2",
+    "all-MiniLM-L12-v2": "Xenova/all-MiniLM-L12-v2",
+    "bge-small-en-v1.5": "Xenova/bge-small-en-v1.5",
+    "paraphrase-MiniLM-L3-v2": "Xenova/paraphrase-MiniLM-L3-v2"
+  };
+  DEFAULT_CONFIG = {
+    model: "all-MiniLM-L6-v2",
+    showProgress: true
+  };
+  currentConfig = { ...DEFAULT_CONFIG };
+});
+
+// src/utils/config.ts
+import * as path2 from "path";
+import * as fs from "fs/promises";
+function getRaggrepDir(rootDir, config = DEFAULT_CONFIG2) {
+  return path2.join(rootDir, config.indexDir);
+}
+function getModuleIndexPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
+  return path2.join(rootDir, config.indexDir, "index", moduleId);
+}
+function getModuleManifestPath(rootDir, moduleId, config = DEFAULT_CONFIG2) {
+  return path2.join(rootDir, config.indexDir, "index", moduleId, "manifest.json");
+}
+function getGlobalManifestPath(rootDir, config = DEFAULT_CONFIG2) {
+  return path2.join(rootDir, config.indexDir, "manifest.json");
+}
+function getConfigPath(rootDir, config = DEFAULT_CONFIG2) {
+  return path2.join(rootDir, config.indexDir, "config.json");
+}
+async function loadConfig(rootDir) {
+  const configPath = getConfigPath(rootDir, DEFAULT_CONFIG2);
+  try {
+    const content = await fs.readFile(configPath, "utf-8");
+    const savedConfig = JSON.parse(content);
+    return { ...DEFAULT_CONFIG2, ...savedConfig };
+  } catch {
+    return DEFAULT_CONFIG2;
+  }
+}
+function getModuleConfig(config, moduleId) {
+  return config.modules.find((m) => m.id === moduleId);
+}
+function getEmbeddingConfigFromModule(moduleConfig) {
+  const options = moduleConfig.options || {};
+  const modelName = options.embeddingModel || "all-MiniLM-L6-v2";
+  if (!(modelName in EMBEDDING_MODELS)) {
+    console.warn(`Unknown embedding model: ${modelName}, falling back to all-MiniLM-L6-v2`);
+    return { model: "all-MiniLM-L6-v2" };
+  }
+  return {
+    model: modelName,
+    showProgress: options.showProgress !== false
+  };
+}
+var DEFAULT_CONFIG2;
+var init_config2 = __esm(() => {
+  init_entities();
+  init_embeddings();
+  DEFAULT_CONFIG2 = createDefaultConfig();
+});
+
+// src/domain/services/bm25.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 1);
+}
+function termFrequency(term, tokens) {
+  return tokens.filter((t) => t === term).length;
+}
+
+class BM25Index {
+  documents = new Map;
+  avgDocLength = 0;
+  documentFrequencies = new Map;
+  totalDocs = 0;
+  addDocuments(documents) {
+    let totalLength = this.avgDocLength * this.totalDocs;
+    for (const doc of documents) {
+      const tokens = doc.tokens ?? tokenize(doc.content);
+      this.documents.set(doc.id, { content: doc.content, tokens });
+      totalLength += tokens.length;
+      this.totalDocs++;
+      const uniqueTerms = new Set(tokens);
+      for (const term of uniqueTerms) {
+        const count = this.documentFrequencies.get(term) || 0;
+        this.documentFrequencies.set(term, count + 1);
+      }
+    }
+    this.avgDocLength = this.totalDocs > 0 ? totalLength / this.totalDocs : 0;
+  }
+  idf(term) {
+    const docFreq = this.documentFrequencies.get(term) || 0;
+    if (docFreq === 0)
+      return 0;
+    return Math.log(1 + (this.totalDocs - docFreq + 0.5) / (docFreq + 0.5));
+  }
+  score(tokens, queryTerms) {
+    const docLength = tokens.length;
+    let score = 0;
+    for (const term of queryTerms) {
+      const tf = termFrequency(term, tokens);
+      if (tf === 0)
+        continue;
+      const idfScore = this.idf(term);
+      const numerator = tf * (BM25_K1 + 1);
+      const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * (docLength / this.avgDocLength));
+      score += idfScore * (numerator / denominator);
+    }
+    return score;
+  }
+  search(query, topK = 10) {
+    const queryTerms = tokenize(query);
+    if (queryTerms.length === 0)
+      return [];
+    const results = [];
+    for (const [id, { tokens }] of this.documents) {
+      const score = this.score(tokens, queryTerms);
+      if (score > 0) {
+        results.push({ id, score });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  get size() {
+    return this.totalDocs;
+  }
+  clear() {
+    this.documents.clear();
+    this.documentFrequencies.clear();
+    this.avgDocLength = 0;
+    this.totalDocs = 0;
+  }
+}
+function normalizeScore(score, midpoint = 5) {
+  return 1 / (1 + Math.exp(-score / midpoint + 1));
+}
+var BM25_K1 = 1.5, BM25_B = 0.75;
+
+// src/utils/bm25.ts
+var init_bm25 = () => {};
+
+// src/modules/semantic/parseCode.ts
+import * as ts from "typescript";
+function parseCode(content, filepath) {
+  const ext = filepath.split(".").pop()?.toLowerCase();
+  if (["ts", "tsx", "js", "jsx", "mts", "cts", "mjs", "cjs"].includes(ext || "")) {
+    return parseTypeScript(content, filepath);
+  }
+  return parseGenericCode(content);
+}
+function parseTypeScript(content, filepath) {
+  const chunks = [];
+  const lines = content.split(`
+`);
+  const sourceFile = ts.createSourceFile(filepath, content, ts.ScriptTarget.Latest, true, filepath.endsWith(".tsx") || filepath.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  function getLineNumbers(node) {
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    return {
+      startLine: start.line + 1,
+      endLine: end.line + 1
+    };
+  }
+  function getNodeText(node) {
+    return node.getText(sourceFile);
+  }
+  function isExported(node) {
+    if (!ts.canHaveModifiers(node))
+      return false;
+    const modifiers = ts.getModifiers(node);
+    return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  }
+  function getJSDoc(node) {
+    const jsDocNodes = ts.getJSDocCommentsAndTags(node);
+    if (jsDocNodes.length === 0)
+      return;
+    return jsDocNodes.map((doc) => doc.getText(sourceFile)).join(`
+`);
+  }
+  function getFunctionName(node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      return node.name.text;
+    }
+    if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      return node.name.text;
+    }
+    return;
+  }
+  function visit(node) {
+    const { startLine, endLine } = getLineNumbers(node);
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "function",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+          chunks.push({
+            content: getNodeText(node),
+            startLine,
+            endLine,
+            type: "function",
+            name,
+            isExported: isExported(node),
+            jsDoc: getJSDoc(node)
+          });
+          return;
+        }
+      }
+    }
+    if (ts.isClassDeclaration(node) && node.name) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "class",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "interface",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "type",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isEnumDeclaration(node)) {
+      chunks.push({
+        content: getNodeText(node),
+        startLine,
+        endLine,
+        type: "enum",
+        name: node.name.text,
+        isExported: isExported(node),
+        jsDoc: getJSDoc(node)
+      });
+      return;
+    }
+    if (ts.isVariableStatement(node) && isExported(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (decl.initializer && (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer))) {
+          continue;
+        }
+        const name = ts.isIdentifier(decl.name) ? decl.name.text : undefined;
+        chunks.push({
+          content: getNodeText(node),
+          startLine,
+          endLine,
+          type: "variable",
+          name,
+          isExported: true,
+          jsDoc: getJSDoc(node)
+        });
+      }
+      return;
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (chunks.length === 0) {
+    return parseGenericCode(content);
+  }
+  return chunks;
+}
+function parseGenericCode(content) {
+  const chunks = [];
+  const lines = content.split(`
+`);
+  const CHUNK_SIZE = 30;
+  const OVERLAP = 5;
+  if (lines.length <= CHUNK_SIZE) {
+    return [
+      {
+        content,
+        startLine: 1,
+        endLine: lines.length,
+        type: "file"
+      }
+    ];
+  }
+  for (let i = 0;i < lines.length; i += CHUNK_SIZE - OVERLAP) {
+    const endIdx = Math.min(i + CHUNK_SIZE, lines.length);
+    chunks.push({
+      content: lines.slice(i, endIdx).join(`
+`),
+      startLine: i + 1,
+      endLine: endIdx,
+      type: "block"
+    });
+    if (endIdx >= lines.length)
+      break;
+  }
+  return chunks;
+}
+function generateChunkId(filepath, startLine, endLine) {
+  const safePath = filepath.replace(/[/\\]/g, "-").replace(/\./g, "_");
+  return `${safePath}-${startLine}-${endLine}`;
+}
+var init_parseCode = () => {};
+
+// src/domain/services/keywords.ts
+function extractKeywords(content, name, maxKeywords = 50) {
+  const keywords = new Set;
+  if (name) {
+    keywords.add(name.toLowerCase());
+    const parts = name.split(/(?=[A-Z])/).map((p) => p.toLowerCase());
+    parts.forEach((p) => p.length > 2 && keywords.add(p));
+  }
+  const identifierRegex = /\b([a-zA-Z_][a-zA-Z0-9_]{2,})\b/g;
+  let match;
+  while ((match = identifierRegex.exec(content)) !== null) {
+    const word = match[1].toLowerCase();
+    if (!COMMON_KEYWORDS.has(word) && word.length > 2) {
+      keywords.add(word);
+    }
+  }
+  return Array.from(keywords).slice(0, maxKeywords);
+}
+function extractPathKeywords(filepath) {
+  return filepath.split(/[/\\.]/).filter((p) => p.length > 2 && !COMMON_KEYWORDS.has(p.toLowerCase())).map((p) => p.toLowerCase());
+}
+var COMMON_KEYWORDS;
+var init_keywords = __esm(() => {
+  COMMON_KEYWORDS = new Set([
+    "const",
+    "let",
+    "var",
+    "function",
+    "class",
+    "interface",
+    "type",
+    "enum",
+    "export",
+    "import",
+    "from",
+    "return",
+    "async",
+    "await",
+    "new",
+    "this",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "if",
+    "else",
+    "for",
+    "while",
+    "switch",
+    "case",
+    "break",
+    "continue",
+    "try",
+    "catch",
+    "finally",
+    "throw",
+    "typeof",
+    "instanceof",
+    "void",
+    "delete",
+    "in",
+    "of",
+    "string",
+    "number",
+    "boolean",
+    "any",
+    "unknown",
+    "never",
+    "object",
+    "public",
+    "private",
+    "protected",
+    "static",
+    "readonly",
+    "abstract",
+    "implements",
+    "extends",
+    "super",
+    "get",
+    "set",
+    "constructor",
+    "the",
+    "and",
+    "for",
+    "not",
+    "with",
+    "are",
+    "was",
+    "has",
+    "have"
+  ]);
+});
+
+// src/utils/tieredIndex.ts
+import * as fs2 from "fs/promises";
+import * as path3 from "path";
+
+class SymbolicIndex {
+  meta = null;
+  fileSummaries = new Map;
+  bm25Index = null;
+  symbolicPath;
+  moduleId;
+  constructor(indexDir, moduleId) {
+    this.symbolicPath = path3.join(indexDir, "index", moduleId, "symbolic");
+    this.moduleId = moduleId;
+  }
+  async initialize() {
+    try {
+      await this.load();
+    } catch {
+      this.meta = {
+        version: "1.0.0",
+        lastUpdated: new Date().toISOString(),
+        moduleId: this.moduleId,
+        fileCount: 0,
+        bm25Data: {
+          avgDocLength: 0,
+          documentFrequencies: {},
+          totalDocs: 0
+        }
+      };
+      this.bm25Index = new BM25Index;
+    }
+  }
+  addFile(summary) {
+    this.fileSummaries.set(summary.filepath, summary);
+  }
+  removeFile(filepath) {
+    return this.fileSummaries.delete(filepath);
+  }
+  buildBM25Index() {
+    this.bm25Index = new BM25Index;
+    for (const [filepath, summary] of this.fileSummaries) {
+      const content = [
+        ...summary.keywords,
+        ...summary.exports,
+        ...extractPathKeywords(filepath)
+      ].join(" ");
+      this.bm25Index.addDocuments([{ id: filepath, content }]);
+    }
+    if (this.meta) {
+      this.meta.fileCount = this.fileSummaries.size;
+      this.meta.bm25Data.totalDocs = this.fileSummaries.size;
+    }
+  }
+  findCandidates(query, maxCandidates = 20) {
+    if (!this.bm25Index) {
+      return Array.from(this.fileSummaries.keys());
+    }
+    const results = this.bm25Index.search(query, maxCandidates);
+    return results.map((r) => r.id);
+  }
+  getAllFiles() {
+    return Array.from(this.fileSummaries.keys());
+  }
+  getFileSummary(filepath) {
+    return this.fileSummaries.get(filepath);
+  }
+  async save() {
+    if (!this.meta)
+      throw new Error("Index not initialized");
+    this.meta.lastUpdated = new Date().toISOString();
+    this.meta.fileCount = this.fileSummaries.size;
+    await fs2.mkdir(this.symbolicPath, { recursive: true });
+    const metaPath = path3.join(this.symbolicPath, "_meta.json");
+    await fs2.writeFile(metaPath, JSON.stringify(this.meta, null, 2));
+    for (const [filepath, summary] of this.fileSummaries) {
+      const summaryPath = this.getFileSummaryPath(filepath);
+      await fs2.mkdir(path3.dirname(summaryPath), { recursive: true });
+      await fs2.writeFile(summaryPath, JSON.stringify(summary, null, 2));
+    }
+  }
+  async load() {
+    const metaPath = path3.join(this.symbolicPath, "_meta.json");
+    const metaContent = await fs2.readFile(metaPath, "utf-8");
+    this.meta = JSON.parse(metaContent);
+    this.fileSummaries.clear();
+    await this.loadFileSummariesRecursive(this.symbolicPath);
+    this.buildBM25Index();
+  }
+  async loadFileSummariesRecursive(dir) {
+    try {
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path3.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await this.loadFileSummariesRecursive(fullPath);
+        } else if (entry.name.endsWith(".json") && entry.name !== "_meta.json") {
+          try {
+            const content = await fs2.readFile(fullPath, "utf-8");
+            const summary = JSON.parse(content);
+            if (summary.filepath) {
+              this.fileSummaries.set(summary.filepath, summary);
+            }
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  getFileSummaryPath(filepath) {
+    const jsonPath = filepath.replace(/\.[^.]+$/, ".json");
+    return path3.join(this.symbolicPath, jsonPath);
+  }
+  async deleteFileSummary(filepath) {
+    try {
+      await fs2.unlink(this.getFileSummaryPath(filepath));
+    } catch {}
+    this.fileSummaries.delete(filepath);
+  }
+  async exists() {
+    try {
+      const metaPath = path3.join(this.symbolicPath, "_meta.json");
+      await fs2.access(metaPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  get size() {
+    return this.fileSummaries.size;
+  }
+  clear() {
+    this.fileSummaries.clear();
+    if (this.meta) {
+      this.meta.fileCount = 0;
+      this.meta.bm25Data = {
+        avgDocLength: 0,
+        documentFrequencies: {},
+        totalDocs: 0
+      };
+    }
+    this.bm25Index = new BM25Index;
+  }
+}
+var init_tieredIndex = __esm(() => {
+  init_keywords();
+  init_keywords();
+});
+
+// src/modules/semantic/index.ts
+var exports_semantic = {};
+__export(exports_semantic, {
+  SemanticModule: () => SemanticModule,
+  DEFAULT_TOP_K: () => DEFAULT_TOP_K,
+  DEFAULT_MIN_SCORE: () => DEFAULT_MIN_SCORE
+});
+import * as path4 from "path";
+
+class SemanticModule {
+  id = "semantic";
+  name = "Semantic Search";
+  description = "Natural language code search using local text embeddings";
+  version = "1.0.0";
+  embeddingConfig = null;
+  symbolicIndex = null;
+  pendingSummaries = new Map;
+  rootDir = "";
+  async initialize(config) {
+    this.embeddingConfig = getEmbeddingConfigFromModule(config);
+    configureEmbeddings(this.embeddingConfig);
+    this.pendingSummaries.clear();
+  }
+  async indexFile(filepath, content, ctx) {
+    this.rootDir = ctx.rootDir;
+    const parsedChunks = parseCode(content, filepath);
+    if (parsedChunks.length === 0) {
+      return null;
+    }
+    const chunkContents = parsedChunks.map((c) => c.content);
+    const embeddings = await getEmbeddings(chunkContents);
+    const chunks = parsedChunks.map((pc) => ({
+      id: generateChunkId(filepath, pc.startLine, pc.endLine),
+      content: pc.content,
+      startLine: pc.startLine,
+      endLine: pc.endLine,
+      type: pc.type,
+      name: pc.name,
+      isExported: pc.isExported,
+      jsDoc: pc.jsDoc
+    }));
+    const references = this.extractReferences(content, filepath);
+    const stats = await ctx.getFileStats(filepath);
+    const currentConfig2 = getEmbeddingConfig();
+    const moduleData = {
+      embeddings,
+      embeddingModel: currentConfig2.model
+    };
+    const chunkTypes = [...new Set(parsedChunks.map((pc) => pc.type))];
+    const exports = parsedChunks.filter((pc) => pc.isExported && pc.name).map((pc) => pc.name);
+    const allKeywords = new Set;
+    for (const pc of parsedChunks) {
+      const keywords = extractKeywords(pc.content, pc.name);
+      keywords.forEach((k) => allKeywords.add(k));
+    }
+    const fileSummary = {
+      filepath,
+      chunkCount: chunks.length,
+      chunkTypes,
+      keywords: Array.from(allKeywords),
+      exports,
+      lastModified: stats.lastModified
+    };
+    this.pendingSummaries.set(filepath, fileSummary);
+    return {
+      filepath,
+      lastModified: stats.lastModified,
+      chunks,
+      moduleData,
+      references
+    };
+  }
+  async finalize(ctx) {
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    this.symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    await this.symbolicIndex.initialize();
+    for (const [filepath, summary] of this.pendingSummaries) {
+      this.symbolicIndex.addFile(summary);
+    }
+    this.symbolicIndex.buildBM25Index();
+    await this.symbolicIndex.save();
+    console.log(`  Symbolic index built with ${this.pendingSummaries.size} file summaries`);
+    this.pendingSummaries.clear();
+  }
+  async search(query, ctx, options = {}) {
+    const { topK = DEFAULT_TOP_K, minScore = DEFAULT_MIN_SCORE, filePatterns } = options;
+    const indexDir = getRaggrepDir(ctx.rootDir, ctx.config);
+    const symbolicIndex = new SymbolicIndex(indexDir, this.id);
+    let candidateFiles;
+    try {
+      await symbolicIndex.initialize();
+      const maxCandidates = topK * TIER1_CANDIDATE_MULTIPLIER;
+      candidateFiles = symbolicIndex.findCandidates(query, maxCandidates);
+      if (candidateFiles.length === 0) {
+        candidateFiles = symbolicIndex.getAllFiles();
+      }
+    } catch {
+      candidateFiles = await ctx.listIndexedFiles();
+    }
+    if (filePatterns && filePatterns.length > 0) {
+      candidateFiles = candidateFiles.filter((filepath) => {
+        return filePatterns.some((pattern) => {
+          if (pattern.startsWith("*.")) {
+            const ext = pattern.slice(1);
+            return filepath.endsWith(ext);
+          }
+          return filepath.includes(pattern);
+        });
+      });
+    }
+    const queryEmbedding = await getEmbedding(query);
+    const bm25Index = new BM25Index;
+    const allChunksData = [];
+    for (const filepath of candidateFiles) {
+      const fileIndex = await ctx.loadFileIndex(filepath);
+      if (!fileIndex)
+        continue;
+      const moduleData = fileIndex.moduleData;
+      if (!moduleData?.embeddings)
+        continue;
+      for (let i = 0;i < fileIndex.chunks.length; i++) {
+        const chunk = fileIndex.chunks[i];
+        const embedding = moduleData.embeddings[i];
+        if (!embedding)
+          continue;
+        allChunksData.push({
+          filepath: fileIndex.filepath,
+          chunk,
+          embedding
+        });
+        bm25Index.addDocuments([{ id: chunk.id, content: chunk.content }]);
+      }
+    }
+    const bm25Results = bm25Index.search(query, topK * 3);
+    const bm25Scores = new Map;
+    for (const result of bm25Results) {
+      bm25Scores.set(result.id, normalizeScore(result.score, 3));
+    }
+    const results = [];
+    for (const { filepath, chunk, embedding } of allChunksData) {
+      const semanticScore = cosineSimilarity(queryEmbedding, embedding);
+      const bm25Score = bm25Scores.get(chunk.id) || 0;
+      const hybridScore = SEMANTIC_WEIGHT * semanticScore + BM25_WEIGHT * bm25Score;
+      if (hybridScore >= minScore || bm25Score > 0.3) {
+        results.push({
+          filepath,
+          chunk,
+          score: hybridScore,
+          moduleId: this.id,
+          context: {
+            semanticScore,
+            bm25Score
+          }
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  extractReferences(content, filepath) {
+    const references = [];
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path4.dirname(filepath);
+        const resolved = path4.normalize(path4.join(dir, importPath));
+        references.push(resolved);
+      }
+    }
+    while ((match = requireRegex.exec(content)) !== null) {
+      const importPath = match[1];
+      if (importPath.startsWith(".")) {
+        const dir = path4.dirname(filepath);
+        const resolved = path4.normalize(path4.join(dir, importPath));
+        references.push(resolved);
+      }
+    }
+    return references;
+  }
+}
+var DEFAULT_MIN_SCORE = 0.15, DEFAULT_TOP_K = 10, SEMANTIC_WEIGHT = 0.7, BM25_WEIGHT = 0.3, TIER1_CANDIDATE_MULTIPLIER = 3;
+var init_semantic = __esm(() => {
+  init_embeddings();
+  init_bm25();
+  init_config2();
+  init_parseCode();
+  init_tieredIndex();
+});
+
+// src/indexer/index.ts
+init_config2();
+import { glob } from "glob";
+import * as fs3 from "fs/promises";
+import * as path5 from "path";
+
+// src/modules/registry.ts
+class ModuleRegistryImpl {
+  modules = new Map;
+  register(module) {
+    if (this.modules.has(module.id)) {
+      console.warn(`Module '${module.id}' is already registered, overwriting...`);
+    }
+    this.modules.set(module.id, module);
+  }
+  get(id) {
+    return this.modules.get(id);
+  }
+  list() {
+    return Array.from(this.modules.values());
+  }
+  getEnabled(config) {
+    const enabledIds = new Set(config.modules.filter((m) => m.enabled).map((m) => m.id));
+    return this.list().filter((m) => enabledIds.has(m.id));
+  }
+}
+var registry = new ModuleRegistryImpl;
+async function registerBuiltInModules() {
+  const { SemanticModule: SemanticModule2 } = await Promise.resolve().then(() => (init_semantic(), exports_semantic));
+  registry.register(new SemanticModule2);
+}
+
+// src/indexer/index.ts
+async function indexDirectory(rootDir, options = {}) {
+  const verbose = options.verbose ?? false;
+  rootDir = path5.resolve(rootDir);
+  console.log(`Indexing directory: ${rootDir}`);
+  const config = await loadConfig(rootDir);
+  await registerBuiltInModules();
+  const enabledModules = registry.getEnabled(config);
+  if (enabledModules.length === 0) {
+    console.log("No modules enabled. Check your configuration.");
+    return [];
+  }
+  console.log(`Enabled modules: ${enabledModules.map((m) => m.id).join(", ")}`);
+  const files = await findFiles(rootDir, config);
+  console.log(`Found ${files.length} files to index`);
+  const results = [];
+  for (const module of enabledModules) {
+    console.log(`
+[${module.name}] Starting indexing...`);
+    const moduleConfig = getModuleConfig(config, module.id);
+    if (module.initialize && moduleConfig) {
+      const configWithOverrides = { ...moduleConfig };
+      if (options.model && module.id === "semantic") {
+        configWithOverrides.options = {
+          ...configWithOverrides.options,
+          embeddingModel: options.model
+        };
+      }
+      await module.initialize(configWithOverrides);
+    }
+    const result = await indexWithModule(rootDir, files, module, config, verbose);
+    results.push(result);
+    if (module.finalize) {
+      console.log(`[${module.name}] Building secondary indexes...`);
+      const ctx = {
+        rootDir,
+        config,
+        readFile: async (filepath) => {
+          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+          return fs3.readFile(fullPath, "utf-8");
+        },
+        getFileStats: async (filepath) => {
+          const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+          const stats = await fs3.stat(fullPath);
+          return { lastModified: stats.mtime.toISOString() };
+        }
+      };
+      await module.finalize(ctx);
+    }
+    console.log(`[${module.name}] Complete: ${result.indexed} indexed, ${result.skipped} skipped, ${result.errors} errors`);
+  }
+  await updateGlobalManifest(rootDir, enabledModules, config);
+  return results;
+}
+async function indexWithModule(rootDir, files, module, config, verbose) {
+  const result = {
+    moduleId: module.id,
+    indexed: 0,
+    skipped: 0,
+    errors: 0
+  };
+  const manifest = await loadModuleManifest(rootDir, module.id, config);
+  const ctx = {
+    rootDir,
+    config,
+    readFile: async (filepath) => {
+      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+      return fs3.readFile(fullPath, "utf-8");
+    },
+    getFileStats: async (filepath) => {
+      const fullPath = path5.isAbsolute(filepath) ? filepath : path5.join(rootDir, filepath);
+      const stats = await fs3.stat(fullPath);
+      return { lastModified: stats.mtime.toISOString() };
+    }
+  };
+  for (const filepath of files) {
+    const relativePath = path5.relative(rootDir, filepath);
+    try {
+      const stats = await fs3.stat(filepath);
+      const lastModified = stats.mtime.toISOString();
+      const existingEntry = manifest.files[relativePath];
+      if (existingEntry && existingEntry.lastModified === lastModified) {
+        if (verbose) {
+          console.log(`  Skipped ${relativePath} (unchanged)`);
+        }
+        result.skipped++;
+        continue;
+      }
+      const content = await fs3.readFile(filepath, "utf-8");
+      if (verbose) {
+        console.log(`  Processing ${relativePath}...`);
+      }
+      const fileIndex = await module.indexFile(relativePath, content, ctx);
+      if (!fileIndex) {
+        if (verbose) {
+          console.log(`  Skipped ${relativePath} (no chunks)`);
+        }
+        result.skipped++;
+        continue;
+      }
+      await writeFileIndex(rootDir, module.id, relativePath, fileIndex, config);
+      manifest.files[relativePath] = {
+        lastModified,
+        chunkCount: fileIndex.chunks.length
+      };
+      result.indexed++;
+    } catch (error) {
+      console.error(`  Error indexing ${relativePath}:`, error);
+      result.errors++;
+    }
+  }
+  manifest.lastUpdated = new Date().toISOString();
+  await writeModuleManifest(rootDir, module.id, manifest, config);
+  return result;
+}
+async function findFiles(rootDir, config) {
+  const patterns = config.extensions.map((ext) => `**/*${ext}`);
+  const ignorePatterns = config.ignorePaths.map((p) => `**/${p}/**`);
+  const files = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, {
+      cwd: rootDir,
+      absolute: true,
+      ignore: ignorePatterns
+    });
+    files.push(...matches);
+  }
+  return [...new Set(files)];
+}
+async function loadModuleManifest(rootDir, moduleId, config) {
+  const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
+  try {
+    const content = await fs3.readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      moduleId,
+      version: "1.0.0",
+      lastUpdated: new Date().toISOString(),
+      files: {}
+    };
+  }
+}
+async function writeModuleManifest(rootDir, moduleId, manifest, config) {
+  const manifestPath = getModuleManifestPath(rootDir, moduleId, config);
+  await fs3.mkdir(path5.dirname(manifestPath), { recursive: true });
+  await fs3.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+}
+async function writeFileIndex(rootDir, moduleId, filepath, fileIndex, config) {
+  const indexPath = getModuleIndexPath(rootDir, moduleId, config);
+  const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+  await fs3.mkdir(path5.dirname(indexFilePath), { recursive: true });
+  await fs3.writeFile(indexFilePath, JSON.stringify(fileIndex, null, 2));
+}
+async function updateGlobalManifest(rootDir, modules, config) {
+  const manifestPath = getGlobalManifestPath(rootDir, config);
+  const manifest = {
+    version: config.version,
+    lastUpdated: new Date().toISOString(),
+    modules: modules.map((m) => m.id)
+  };
+  await fs3.mkdir(path5.dirname(manifestPath), { recursive: true });
+  await fs3.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+}
+async function cleanupIndex(rootDir, options = {}) {
+  const verbose = options.verbose ?? false;
+  rootDir = path5.resolve(rootDir);
+  console.log(`Cleaning up index in: ${rootDir}`);
+  const config = await loadConfig(rootDir);
+  await registerBuiltInModules();
+  const enabledModules = registry.getEnabled(config);
+  if (enabledModules.length === 0) {
+    console.log("No modules enabled.");
+    return [];
+  }
+  const results = [];
+  for (const module of enabledModules) {
+    console.log(`
+[${module.name}] Checking for stale entries...`);
+    const result = await cleanupModuleIndex(rootDir, module.id, config, verbose);
+    results.push(result);
+    console.log(`[${module.name}] Removed ${result.removed} stale entries, kept ${result.kept} valid entries`);
+  }
+  return results;
+}
+async function cleanupModuleIndex(rootDir, moduleId, config, verbose) {
+  const result = {
+    moduleId,
+    removed: 0,
+    kept: 0
+  };
+  const manifest = await loadModuleManifest(rootDir, moduleId, config);
+  const indexPath = getModuleIndexPath(rootDir, moduleId, config);
+  const filesToRemove = [];
+  const updatedFiles = {};
+  for (const [filepath, entry] of Object.entries(manifest.files)) {
+    const fullPath = path5.join(rootDir, filepath);
+    try {
+      await fs3.access(fullPath);
+      updatedFiles[filepath] = entry;
+      result.kept++;
+    } catch {
+      filesToRemove.push(filepath);
+      result.removed++;
+      if (verbose) {
+        console.log(`  Removing stale entry: ${filepath}`);
+      }
+    }
+  }
+  for (const filepath of filesToRemove) {
+    const indexFilePath = path5.join(indexPath, filepath.replace(/\.[^.]+$/, ".json"));
+    try {
+      await fs3.unlink(indexFilePath);
+    } catch {}
+  }
+  manifest.files = updatedFiles;
+  manifest.lastUpdated = new Date().toISOString();
+  await writeModuleManifest(rootDir, moduleId, manifest, config);
+  await cleanupEmptyDirectories(indexPath);
+  return result;
+}
+async function cleanupEmptyDirectories(dir) {
+  try {
+    const entries = await fs3.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const subDir = path5.join(dir, entry.name);
+        await cleanupEmptyDirectories(subDir);
+      }
+    }
+    const remainingEntries = await fs3.readdir(dir);
+    if (remainingEntries.length === 0) {
+      await fs3.rmdir(dir);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// src/search/index.ts
+init_config2();
+import * as fs4 from "fs/promises";
+import * as path6 from "path";
+async function search(rootDir, query, options = {}) {
+  rootDir = path6.resolve(rootDir);
+  console.log(`Searching for: "${query}"`);
+  const config = await loadConfig(rootDir);
+  await registerBuiltInModules();
+  const globalManifest = await loadGlobalManifest(rootDir, config);
+  if (!globalManifest || globalManifest.modules.length === 0) {
+    console.log('No index found. Run "bun run index" first.');
+    return [];
+  }
+  const modulesToSearch = [];
+  for (const moduleId of globalManifest.modules) {
+    const module = registry.get(moduleId);
+    const moduleConfig = getModuleConfig(config, moduleId);
+    if (module && moduleConfig?.enabled) {
+      if (module.initialize) {
+        await module.initialize(moduleConfig);
+      }
+      modulesToSearch.push(module);
+    }
+  }
+  if (modulesToSearch.length === 0) {
+    console.log("No enabled modules with indexes found.");
+    return [];
+  }
+  const allResults = [];
+  for (const module of modulesToSearch) {
+    const ctx = createSearchContext(rootDir, module.id, config);
+    const moduleResults = await module.search(query, ctx, options);
+    allResults.push(...moduleResults);
+  }
+  allResults.sort((a, b) => b.score - a.score);
+  const topK = options.topK ?? 10;
+  return allResults.slice(0, topK);
+}
+function createSearchContext(rootDir, moduleId, config) {
+  const indexPath = getModuleIndexPath(rootDir, moduleId, config);
+  return {
+    rootDir,
+    config,
+    loadFileIndex: async (filepath) => {
+      const hasExtension = /\.[^./]+$/.test(filepath);
+      const indexFilePath = hasExtension ? path6.join(indexPath, filepath.replace(/\.[^.]+$/, ".json")) : path6.join(indexPath, filepath + ".json");
+      try {
+        const content = await fs4.readFile(indexFilePath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return null;
+      }
+    },
+    listIndexedFiles: async () => {
+      const files = [];
+      await traverseDirectory(indexPath, files, indexPath);
+      return files.filter((f) => f.endsWith(".json") && !f.endsWith("manifest.json")).map((f) => {
+        const relative3 = path6.relative(indexPath, f);
+        return relative3.replace(/\.json$/, "");
+      });
+    }
+  };
+}
+async function traverseDirectory(dir, files, basePath) {
+  try {
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path6.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await traverseDirectory(fullPath, files, basePath);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+  } catch {}
+}
+async function loadGlobalManifest(rootDir, config) {
+  const manifestPath = getGlobalManifestPath(rootDir, config);
+  try {
+    const content = await fs4.readFile(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function formatSearchResults(results) {
+  if (results.length === 0) {
+    return "No results found.";
+  }
+  let output = `Found ${results.length} results:
+
+`;
+  for (let i = 0;i < results.length; i++) {
+    const result = results[i];
+    const { chunk } = result;
+    const location = `${result.filepath}:${chunk.startLine}-${chunk.endLine}`;
+    const nameInfo = chunk.name ? ` (${chunk.name})` : "";
+    output += `${i + 1}. ${location}${nameInfo}
+`;
+    output += `   Score: ${(result.score * 100).toFixed(1)}% | Type: ${chunk.type}`;
+    if (chunk.isExported) {
+      output += " | exported";
+    }
+    output += `
+`;
+    const lines = chunk.content.split(`
+`).slice(0, 3);
+    for (const line of lines) {
+      const trimmedLine = line.substring(0, 80);
+      output += `      ${trimmedLine}${line.length > 80 ? "..." : ""}
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+
+// src/index.ts
+async function index(directory, options = {}) {
+  return indexDirectory(directory, options);
+}
+async function search2(directory, query, options = {}) {
+  return search(directory, query, options);
+}
+async function cleanup(directory, options = {}) {
+  return cleanupIndex(directory, options);
+}
+var raggrep = {
+  index,
+  search: search2,
+  cleanup,
+  formatSearchResults
+};
+var src_default = raggrep;
+export {
+  search2 as search,
+  index,
+  formatSearchResults,
+  src_default as default,
+  cleanup
+};
+
+//# debugId=3A2C4D6166478FB764756E2164756E21