@grumppie/ownsearch 0.1.3

package/dist/chunk-LGXCBOO4.js

@@ -0,0 +1,752 @@
+// src/context.ts
+function buildContextBundle(query, hits, maxChars = 12e3) {
+  const results = [];
+  let totalChars = 0;
+  for (const hit of hits) {
+    if (results.length > 0 && totalChars + hit.content.length > maxChars) {
+      break;
+    }
+    results.push({
+      id: hit.id,
+      score: hit.score,
+      rootId: hit.rootId,
+      rootName: hit.rootName,
+      relativePath: hit.relativePath,
+      chunkIndex: hit.chunkIndex,
+      content: hit.content
+    });
+    totalChars += hit.content.length;
+  }
+  return {
+    query,
+    totalChars,
+    results
+  };
+}
+
+// src/config.ts
+import fsSync from "fs";
+import fs from "fs/promises";
+import os from "os";
+import path2 from "path";
+import dotenv from "dotenv";
+
+// src/constants.ts
+var CONFIG_DIR_NAME = ".ownsearch";
+var CONFIG_FILE_NAME = "config.json";
+var DEFAULT_COLLECTION = "text_gemini_embedding_001_768";
+var DEFAULT_EMBEDDING_MODEL = "gemini-embedding-001";
+var DEFAULT_VECTOR_SIZE = 768;
+var DEFAULT_QDRANT_URL = "http://127.0.0.1:6333";
+var DEFAULT_QDRANT_CONTAINER = "ownsearch-qdrant";
+var DEFAULT_QDRANT_VOLUME = "ownsearch-qdrant-storage";
+var DEFAULT_CHUNK_SIZE = 1200;
+var DEFAULT_CHUNK_OVERLAP = 200;
+var DEFAULT_MAX_FILE_BYTES = 50 * 1024 * 1024;
+var SUPPORTED_TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".c",
+  ".cpp",
+  ".cs",
+  ".css",
+  ".csv",
+  ".env",
+  ".go",
+  ".h",
+  ".hpp",
+  ".html",
+  ".java",
+  ".js",
+  ".json",
+  ".jsx",
+  ".md",
+  ".mdx",
+  ".mjs",
+  ".pdf",
+  ".ps1",
+  ".py",
+  ".rb",
+  ".rs",
+  ".sh",
+  ".sql",
+  ".toml",
+  ".ts",
+  ".tsx",
+  ".txt",
+  ".xml",
+  ".yaml",
+  ".yml"
+]);
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".idea",
+  ".next",
+  ".svn",
+  ".turbo",
+  ".venv",
+  ".vscode",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "venv"
+]);
+
+// src/utils.ts
+import crypto from "crypto";
+import path from "path";
+function toPosixPath(inputPath) {
+  return inputPath.split(path.sep).join("/");
+}
+function sha256(input) {
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+function hashToUuid(input) {
+  const hash = sha256(input);
+  const part1 = hash.slice(0, 8);
+  const part2 = hash.slice(8, 12);
+  const part3 = `5${hash.slice(13, 16)}`;
+  const variantNibble = parseInt(hash.slice(16, 17), 16) & 3 | 8;
+  const part4 = `${variantNibble.toString(16)}${hash.slice(17, 20)}`;
+  const part5 = hash.slice(20, 32);
+  return `${part1}-${part2}-${part3}-${part4}-${part5}`;
+}
+function normalizeVector(values) {
+  const magnitude = Math.sqrt(values.reduce((sum, value) => sum + value * value, 0));
+  if (magnitude === 0) {
+    return values;
+  }
+  return values.map((value) => value / magnitude);
+}
+function slugifyName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+
+// src/config.ts
+function defaultConfig() {
+  return {
+    qdrantUrl: DEFAULT_QDRANT_URL,
+    qdrantCollection: DEFAULT_COLLECTION,
+    qdrantContainerName: DEFAULT_QDRANT_CONTAINER,
+    qdrantVolumeName: DEFAULT_QDRANT_VOLUME,
+    embeddingModel: DEFAULT_EMBEDDING_MODEL,
+    vectorSize: DEFAULT_VECTOR_SIZE,
+    chunkSize: DEFAULT_CHUNK_SIZE,
+    chunkOverlap: DEFAULT_CHUNK_OVERLAP,
+    maxFileBytes: DEFAULT_MAX_FILE_BYTES,
+    roots: []
+  };
+}
+function getConfigDir() {
+  return path2.join(os.homedir(), CONFIG_DIR_NAME);
+}
+function getConfigPath() {
+  return path2.join(getConfigDir(), CONFIG_FILE_NAME);
+}
+function getEnvPath() {
+  return path2.join(getConfigDir(), ".env");
+}
+async function ensureConfigDir() {
+  await fs.mkdir(getConfigDir(), { recursive: true });
+}
+function loadOwnSearchEnv() {
+  for (const envPath of [path2.resolve(process.cwd(), ".env"), getEnvPath()]) {
+    if (!fsSync.existsSync(envPath)) {
+      continue;
+    }
+    const parsed = dotenv.parse(fsSync.readFileSync(envPath, "utf8"));
+    for (const [key, value] of Object.entries(parsed)) {
+      if (process.env[key] === void 0) {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+async function loadConfig() {
+  await ensureConfigDir();
+  const configPath = getConfigPath();
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const config = {
+      ...defaultConfig(),
+      ...parsed,
+      maxFileBytes: Math.max(parsed.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES, DEFAULT_MAX_FILE_BYTES),
+      roots: parsed.roots ?? []
+    };
+    if (config.maxFileBytes !== parsed.maxFileBytes) {
+      await saveConfig(config);
+    }
+    return config;
+  } catch (error) {
+    const config = defaultConfig();
+    await saveConfig(config);
+    return config;
+  }
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  await fs.writeFile(getConfigPath(), `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function saveGeminiApiKey(apiKey) {
+  await ensureConfigDir();
+  await fs.writeFile(getEnvPath(), `GEMINI_API_KEY=${apiKey.trim()}
+`, "utf8");
+}
+function createRootDefinition(rootPath, name) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rootName = name?.trim() || path2.basename(rootPath);
+  return {
+    id: slugifyName(`${rootName}-${rootPath}`),
+    name: rootName,
+    path: path2.resolve(rootPath),
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function upsertRoot(rootPath, name) {
+  const config = await loadConfig();
+  const absolutePath = path2.resolve(rootPath);
+  const existing = config.roots.find((root2) => root2.path === absolutePath);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existing) {
+    existing.name = name?.trim() || existing.name;
+    existing.updatedAt = now;
+    await saveConfig(config);
+    return existing;
+  }
+  const root = createRootDefinition(absolutePath, name);
+  config.roots.push(root);
+  await saveConfig(config);
+  return root;
+}
+async function deleteRootDefinition(rootId) {
+  const config = await loadConfig();
+  const initialLength = config.roots.length;
+  config.roots = config.roots.filter((root) => root.id !== rootId);
+  await saveConfig(config);
+  return config.roots.length !== initialLength;
+}
+async function findRoot(rootId) {
+  const config = await loadConfig();
+  return config.roots.find((root) => root.id === rootId);
+}
+async function listRoots() {
+  const config = await loadConfig();
+  return config.roots;
+}
+
+// src/errors.ts
+var OwnSearchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OwnSearchError";
+  }
+};
+
+// src/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var client;
+var MAX_EMBED_BATCH_SIZE = 20;
+function getClient() {
+  const apiKey = process.env.GEMINI_API_KEY;
+  if (!apiKey) {
+    throw new OwnSearchError("GEMINI_API_KEY is required.");
+  }
+  if (!client) {
+    client = new GoogleGenAI({ apiKey });
+  }
+  return client;
+}
+async function embed(contents, taskType) {
+  const config = await loadConfig();
+  const vectors = [];
+  const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+  for (let index = 0; index < contents.length; index += MAX_EMBED_BATCH_SIZE) {
+    const batch = contents.slice(index, index + MAX_EMBED_BATCH_SIZE);
+    if (debug) {
+      console.log("[ownsearch:embed]", "batch", index / MAX_EMBED_BATCH_SIZE + 1, "size", batch.length, "chars", batch.reduce((sum, text) => sum + text.length, 0));
+    }
+    const response = await getClient().models.embedContent({
+      model: config.embeddingModel,
+      contents: batch,
+      config: {
+        taskType,
+        outputDimensionality: config.vectorSize
+      }
+    });
+    if (!response.embeddings?.length) {
+      throw new OwnSearchError("Gemini returned no embeddings.");
+    }
+    vectors.push(...response.embeddings.map((embedding) => normalizeVector(embedding.values ?? [])));
+  }
+  return vectors;
+}
+async function embedDocuments(contents) {
+  return embed(contents, "RETRIEVAL_DOCUMENT");
+}
+async function embedQuery(query) {
+  const [vector] = await embed([query], "RETRIEVAL_QUERY");
+  return vector;
+}
+
+// src/qdrant.ts
+import { QdrantClient } from "@qdrant/js-client-rest";
+var OwnSearchStore = class {
+  constructor(client2, collectionName, vectorSize) {
+    this.client = client2;
+    this.collectionName = collectionName;
+    this.vectorSize = vectorSize;
+  }
+  async ensureCollection() {
+    const collections = await this.client.getCollections();
+    const exists = collections.collections.some((collection) => collection.name === this.collectionName);
+    if (!exists) {
+      await this.client.createCollection(this.collectionName, {
+        vectors: {
+          size: this.vectorSize,
+          distance: "Cosine"
+        }
+      });
+    } else {
+      const info = await this.client.getCollection(this.collectionName);
+      const vectorConfig = info.config?.params?.vectors;
+      const actualSize = vectorConfig && !Array.isArray(vectorConfig) && "size" in vectorConfig ? Number(vectorConfig.size) : void 0;
+      if (actualSize && actualSize !== this.vectorSize) {
+        throw new Error(
+          `Qdrant collection ${this.collectionName} has vector size ${actualSize}, expected ${this.vectorSize}.`
+        );
+      }
+    }
+    await Promise.allSettled([
+      this.client.createPayloadIndex(this.collectionName, {
+        field_name: "root_id",
+        field_schema: "keyword"
+      }),
+      this.client.createPayloadIndex(this.collectionName, {
+        field_name: "relative_path",
+        field_schema: "keyword"
+      })
+    ]);
+  }
+  async upsertChunks(records, vectors) {
+    const batchSize = 50;
+    for (let index = 0; index < records.length; index += batchSize) {
+      const batchRecords = records.slice(index, index + batchSize);
+      const batchVectors = vectors.slice(index, index + batchSize);
+      const points = batchRecords.map((record, batchIndex) => ({
+        id: record.id,
+        vector: batchVectors[batchIndex],
+        payload: {
+          root_id: record.rootId,
+          root_name: record.rootName,
+          root_path: record.rootPath,
+          file_path: record.filePath,
+          relative_path: record.relativePath,
+          file_extension: record.fileExtension,
+          chunk_index: record.chunkIndex,
+          content: record.content,
+          content_hash: record.contentHash,
+          file_hash: record.fileHash,
+          mtime_ms: record.mtimeMs,
+          size_bytes: record.sizeBytes
+        }
+      }));
+      await this.client.upsert(this.collectionName, {
+        wait: true,
+        points
+      });
+    }
+  }
+  async scrollRootChunks(rootId) {
+    const chunks = [];
+    let offset;
+    do {
+      const result = await this.client.scroll(this.collectionName, {
+        limit: 1024,
+        offset,
+        with_payload: true,
+        with_vector: false,
+        filter: {
+          must: [
+            {
+              key: "root_id",
+              match: {
+                value: rootId
+              }
+            }
+          ]
+        }
+      });
+      chunks.push(
+        ...(result.points ?? []).map((point) => ({
+          id: String(point.id),
+          rootId: String(point.payload?.root_id ?? ""),
+          rootPath: String(point.payload?.root_path ?? ""),
+          rootName: String(point.payload?.root_name ?? ""),
+          filePath: String(point.payload?.file_path ?? ""),
+          relativePath: String(point.payload?.relative_path ?? ""),
+          fileExtension: String(point.payload?.file_extension ?? ""),
+          chunkIndex: Number(point.payload?.chunk_index ?? 0),
+          content: String(point.payload?.content ?? ""),
+          contentHash: String(point.payload?.content_hash ?? ""),
+          fileHash: String(point.payload?.file_hash ?? ""),
+          mtimeMs: Number(point.payload?.mtime_ms ?? 0),
+          sizeBytes: Number(point.payload?.size_bytes ?? 0)
+        }))
+      );
+      offset = result.next_page_offset;
+    } while (offset !== void 0 && offset !== null);
+    return chunks;
+  }
+  async deleteRoot(rootId) {
+    await this.client.delete(this.collectionName, {
+      wait: true,
+      filter: {
+        must: [
+          {
+            key: "root_id",
+            match: {
+              value: rootId
+            }
+          }
+        ]
+      }
+    });
+  }
+  async deleteFiles(rootId, filePaths) {
+    for (const filePath of filePaths) {
+      await this.client.delete(this.collectionName, {
+        wait: true,
+        filter: {
+          must: [
+            {
+              key: "root_id",
+              match: {
+                value: rootId
+              }
+            },
+            {
+              key: "file_path",
+              match: {
+                value: filePath
+              }
+            }
+          ]
+        }
+      });
+    }
+  }
+  async search(vector, filters, limit) {
+    const must = [];
+    if (filters.rootIds?.length) {
+      must.push({
+        key: "root_id",
+        match: {
+          any: filters.rootIds
+        }
+      });
+    }
+    const results = await this.client.search(this.collectionName, {
+      vector,
+      limit: filters.pathSubstring ? Math.max(limit * 3, limit) : limit,
+      with_payload: true,
+      filter: must.length ? { must } : void 0
+    });
+    const hits = results.map((result) => ({
+      id: String(result.id),
+      score: result.score,
+      rootId: String(result.payload?.root_id ?? ""),
+      rootName: String(result.payload?.root_name ?? ""),
+      filePath: String(result.payload?.file_path ?? ""),
+      relativePath: String(result.payload?.relative_path ?? ""),
+      chunkIndex: Number(result.payload?.chunk_index ?? 0),
+      content: String(result.payload?.content ?? "")
+    }));
+    if (!filters.pathSubstring) {
+      return hits.slice(0, limit);
+    }
+    const needle = filters.pathSubstring.toLowerCase();
+    return hits.filter((hit) => hit.relativePath.toLowerCase().includes(needle)).slice(0, limit);
+  }
+  async getChunks(ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+    const points = await this.client.retrieve(this.collectionName, {
+      ids,
+      with_payload: true,
+      with_vector: false
+    });
+    return (points ?? []).map((point) => ({
+      id: String(point.id),
+      rootId: String(point.payload?.root_id ?? ""),
+      rootName: String(point.payload?.root_name ?? ""),
+      filePath: String(point.payload?.file_path ?? ""),
+      relativePath: String(point.payload?.relative_path ?? ""),
+      chunkIndex: Number(point.payload?.chunk_index ?? 0),
+      content: String(point.payload?.content ?? "")
+    }));
+  }
+  async getStatus() {
+    const info = await this.client.getCollection(this.collectionName);
+    return {
+      collection: this.collectionName,
+      status: info.status,
+      pointsCount: info.points_count,
+      indexedVectorsCount: info.indexed_vectors_count,
+      vectorConfig: info.config?.params?.vectors ?? null
+    };
+  }
+};
+async function createStore() {
+  const config = await loadConfig();
+  const client2 = new QdrantClient({ url: config.qdrantUrl, checkCompatibility: false });
+  const store = new OwnSearchStore(client2, config.qdrantCollection, config.vectorSize);
+  await store.ensureCollection();
+  return store;
+}
+
+// src/indexer.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/chunking.ts
+function chunkText(content, chunkSize, chunkOverlap) {
+  const normalized = content.replace(/\r\n/g, "\n").trim();
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  let start = 0;
+  while (start < normalized.length) {
+    let end = Math.min(start + chunkSize, normalized.length);
+    if (end < normalized.length) {
+      const lastBoundary = normalized.lastIndexOf("\n", end);
+      if (lastBoundary > start + Math.floor(chunkSize * 0.5)) {
+        end = lastBoundary;
+      }
+    }
+    const chunk = normalized.slice(start, end).trim();
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    if (end >= normalized.length) {
+      break;
+    }
+    start = Math.max(end - chunkOverlap, start + 1);
+  }
+  return chunks;
+}
+
+// src/files.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+import { PDFParse } from "pdf-parse";
+function sanitizeExtractedText(input) {
+  return input.replace(/\u0000/g, "").replace(/[\u0001-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, " ").replace(/\r\n/g, "\n");
+}
+async function collectTextFiles(rootPath, maxFileBytes) {
+  const files = [];
+  const absoluteRoot = path3.resolve(rootPath);
+  const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+  function debugLog(...parts) {
+    if (debug) {
+      console.log("[ownsearch:index]", ...parts);
+    }
+  }
+  async function parsePdf(filePath) {
+    const buffer = await fs2.readFile(filePath);
+    const parser = new PDFParse({ data: buffer });
+    try {
+      const pdfData = await parser.getText();
+      return pdfData.text ?? "";
+    } finally {
+      await parser.destroy();
+    }
+  }
+  async function walk(currentPath) {
+    const entries = await fs2.readdir(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".env" && entry.name !== ".github") {
+        if (entry.isDirectory()) {
+          continue;
+        }
+      }
+      const nextPath = path3.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRECTORIES.has(entry.name)) {
+          continue;
+        }
+        await walk(nextPath);
+        continue;
+      }
+      const extension = path3.extname(entry.name).toLowerCase();
+      if (!SUPPORTED_TEXT_EXTENSIONS.has(extension)) {
+        debugLog("skip-extension", nextPath, extension);
+        continue;
+      }
+      const stats = await fs2.stat(nextPath);
+      if (stats.size > maxFileBytes) {
+        debugLog("skip-size", nextPath, stats.size);
+        continue;
+      }
+      let content = "";
+      try {
+        if (extension === ".pdf") {
+          content = await parsePdf(nextPath);
+        } else {
+          content = await fs2.readFile(nextPath, "utf8");
+        }
+        content = sanitizeExtractedText(content);
+      } catch (error) {
+        debugLog("skip-parse", nextPath, String(error));
+        continue;
+      }
+      if (!content || !content.trim()) {
+        debugLog("skip-empty", nextPath);
+        continue;
+      }
+      files.push({
+        path: nextPath,
+        relativePath: path3.relative(absoluteRoot, nextPath),
+        extension,
+        sizeBytes: stats.size,
+        mtimeMs: stats.mtimeMs,
+        content
+      });
+    }
+  }
+  await walk(absoluteRoot);
+  return files;
+}
+
+// src/indexer.ts
+function buildChunkId(rootId, relativePath, chunkIndex, fileHash) {
+  return hashToUuid(`${rootId}:${relativePath}:${chunkIndex}:${fileHash}`);
+}
+async function embedRecords(records) {
+  if (records.length === 0) {
+    return { records: [], vectors: [], skipped: 0 };
+  }
+  try {
+    const vectors = await embedDocuments(records.map((record) => record.content));
+    return { records, vectors, skipped: 0 };
+  } catch (error) {
+    if (records.length === 1) {
+      const debug = process.env.OWNSEARCH_DEBUG_INDEX === "1";
+      if (debug) {
+        console.log("[ownsearch:embed]", "skip-chunk", records[0].relativePath, String(error));
+      }
+      return { records: [], vectors: [], skipped: 1 };
+    }
+    const midpoint = Math.floor(records.length / 2);
+    const left = await embedRecords(records.slice(0, midpoint));
+    const right = await embedRecords(records.slice(midpoint));
+    return {
+      records: [...left.records, ...right.records],
+      vectors: [...left.vectors, ...right.vectors],
+      skipped: left.skipped + right.skipped
+    };
+  }
+}
+async function indexPath(rootPath, options = {}) {
+  const absolutePath = path4.resolve(rootPath);
+  const stats = await fs3.stat(absolutePath).catch(() => void 0);
+  if (!stats?.isDirectory()) {
+    throw new OwnSearchError(`Path is not a readable directory: ${absolutePath}`);
+  }
+  const config = await loadConfig();
+  const root = await upsertRoot(absolutePath, options.name);
+  const store = await createStore();
+  const files = await collectTextFiles(root.path, options.maxFileBytes ?? config.maxFileBytes);
+  const existingChunks = await store.scrollRootChunks(root.id);
+  const records = [];
+  const filesByPath = /* @__PURE__ */ new Map();
+  const existingByPath = /* @__PURE__ */ new Map();
+  const refreshAllMetadata = existingChunks.some(
+    (chunk) => chunk.rootName !== root.name || chunk.rootPath !== root.path
+  );
+  for (const file of files) {
+    filesByPath.set(file.path, file);
+  }
+  for (const chunk of existingChunks) {
+    const list = existingByPath.get(chunk.filePath) ?? [];
+    list.push(chunk);
+    existingByPath.set(chunk.filePath, list);
+  }
+  const staleFiles = [];
+  for (const file of files) {
+    const fileHash = sha256(file.content);
+    const chunks = chunkText(file.content, config.chunkSize, config.chunkOverlap);
+    const existing = existingByPath.get(file.path);
+    const existingFileHash = existing?.[0]?.fileHash;
+    const existingChunkCount = existing?.length ?? 0;
+    if (!refreshAllMetadata && existing && existingFileHash === fileHash && existingChunkCount === chunks.length) {
+      continue;
+    }
+    if (existing?.length) {
+      staleFiles.push(file.path);
+    }
+    chunks.forEach((content, chunkIndex) => {
+      records.push({
+        id: buildChunkId(root.id, toPosixPath(file.relativePath), chunkIndex, fileHash),
+        rootId: root.id,
+        rootPath: root.path,
+        rootName: root.name,
+        filePath: file.path,
+        relativePath: toPosixPath(file.relativePath),
+        fileExtension: file.extension,
+        chunkIndex,
+        content,
+        contentHash: sha256(content),
+        fileHash,
+        mtimeMs: file.mtimeMs,
+        sizeBytes: file.sizeBytes
+      });
+    });
+  }
+  for (const [existingFilePath] of existingByPath.entries()) {
+    if (!filesByPath.has(existingFilePath)) {
+      staleFiles.push(existingFilePath);
+    }
+  }
+  if (staleFiles.length > 0) {
+    await store.deleteFiles(root.id, Array.from(new Set(staleFiles)));
+  }
+  if (records.length === 0) {
+    return {
+      root,
+      indexedFiles: files.length,
+      indexedChunks: 0,
+      skippedFiles: 0
+    };
+  }
+  const embedded = await embedRecords(records);
+  if (embedded.records.length > 0) {
+    await store.upsertChunks(embedded.records, embedded.vectors);
+  }
+  return {
+    root,
+    indexedFiles: files.length,
+    indexedChunks: embedded.records.length,
+    skippedFiles: 0
+  };
+}
+
+export {
+  buildContextBundle,
+  getConfigPath,
+  getEnvPath,
+  loadOwnSearchEnv,
+  loadConfig,
+  saveGeminiApiKey,
+  deleteRootDefinition,
+  findRoot,
+  listRoots,
+  OwnSearchError,
+  embedQuery,
+  createStore,
+  indexPath
+};