llm-kb 0.2.0 → 0.4.0

package/test/config.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { loadConfig, ensureConfig, DEFAULT_INDEX_MODEL, DEFAULT_QUERY_MODEL } from "../src/config.js";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { existsSync } from "node:fs";
+
+describe("config", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "llm-kb-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe("loadConfig", () => {
+    it("returns defaults when no config file exists", async () => {
+      const config = await loadConfig(tempDir);
+      expect(config.indexModel).toBe(DEFAULT_INDEX_MODEL);
+      expect(config.queryModel).toBe(DEFAULT_QUERY_MODEL);
+    });
+
+    it("reads config from .llm-kb/config.json", async () => {
+      const { mkdir, writeFile } = await import("node:fs/promises");
+      await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+      await writeFile(
+        join(tempDir, ".llm-kb", "config.json"),
+        JSON.stringify({ indexModel: "custom-haiku", queryModel: "custom-sonnet" })
+      );
+
+      const config = await loadConfig(tempDir);
+      expect(config.indexModel).toBe("custom-haiku");
+      expect(config.queryModel).toBe("custom-sonnet");
+    });
+
+    it("env vars override config file", async () => {
+      const { mkdir, writeFile } = await import("node:fs/promises");
+      await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+      await writeFile(
+        join(tempDir, ".llm-kb", "config.json"),
+        JSON.stringify({ indexModel: "from-file", queryModel: "from-file" })
+      );
+
+      process.env.LLM_KB_INDEX_MODEL = "from-env";
+      process.env.LLM_KB_QUERY_MODEL = "from-env";
+
+      try {
+        const config = await loadConfig(tempDir);
+        expect(config.indexModel).toBe("from-env");
+        expect(config.queryModel).toBe("from-env");
+      } finally {
+        delete process.env.LLM_KB_INDEX_MODEL;
+        delete process.env.LLM_KB_QUERY_MODEL;
+      }
+    });
+
+    it("handles malformed config gracefully", async () => {
+      const { mkdir, writeFile } = await import("node:fs/promises");
+      await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+      await writeFile(join(tempDir, ".llm-kb", "config.json"), "not json{{{");
+
+      const config = await loadConfig(tempDir);
+      expect(config.indexModel).toBe(DEFAULT_INDEX_MODEL);
+      expect(config.queryModel).toBe(DEFAULT_QUERY_MODEL);
+    });
+  });
+
+  describe("ensureConfig", () => {
+    it("creates config.json with defaults when none exists", async () => {
+      const config = await ensureConfig(tempDir);
+      expect(config.indexModel).toBe(DEFAULT_INDEX_MODEL);
+      expect(config.queryModel).toBe(DEFAULT_QUERY_MODEL);
+
+      const path = join(tempDir, ".llm-kb", "config.json");
+      expect(existsSync(path)).toBe(true);
+
+      const raw = JSON.parse(await readFile(path, "utf-8"));
+      expect(raw.indexModel).toBe(DEFAULT_INDEX_MODEL);
+    });
+
+    it("does not overwrite existing config", async () => {
+      const { mkdir, writeFile } = await import("node:fs/promises");
+      await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+      await writeFile(
+        join(tempDir, ".llm-kb", "config.json"),
+        JSON.stringify({ indexModel: "my-model", queryModel: "my-model" })
+      );
+
+      const config = await ensureConfig(tempDir);
+      expect(config.indexModel).toBe("my-model");
+    });
+  });
+});

package/test/md-stream.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import { MarkdownStream } from "../src/md-stream.js";
+
+describe("MarkdownStream", () => {
+  describe("non-TTY (passthrough)", () => {
+    it("returns chunks unchanged", () => {
+      const md = new MarkdownStream(false);
+      expect(md.push("**bold**")).toBe("**bold**");
+      expect(md.push("# Header\n")).toBe("# Header\n");
+    });
+  });
+
+  describe("TTY mode", () => {
+    it("renders bold text", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("**hello**\n");
+      expect(out).not.toContain("**");
+      expect(out).toContain("hello");
+    });
+
+    it("renders italic text", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("*world*\n");
+      expect(out).not.toContain("*world*");
+      expect(out).toContain("world");
+    });
+
+    it("renders inline code", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("`code`\n");
+      expect(out).not.toContain("`");
+      expect(out).toContain("code");
+    });
+
+    it("renders headers without # symbols", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("## Section Title\n");
+      expect(out).not.toContain("##");
+      expect(out).toContain("Section Title");
+    });
+
+    it("renders bullet points with •", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("- item one\n");
+      expect(out).toContain("•");
+      expect(out).toContain("item one");
+      expect(out).not.toMatch(/^- /m);
+    });
+
+    it("renders horizontal rules as ─", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("---\n");
+      expect(out).toContain("─");
+      expect(out).not.toContain("---");
+    });
+
+    it("renders block quotes with │", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("> quoted text\n");
+      expect(out).toContain("│");
+      expect(out).toContain("quoted text");
+    });
+
+    it("handles incomplete patterns by buffering", () => {
+      const md = new MarkdownStream(true);
+      // Push "**bo" — bold is incomplete, should buffer
+      const out1 = md.push("**bo");
+      // Push "ld**\n" — completes the bold
+      const out2 = md.push("ld**\n");
+      const combined = out1 + out2;
+      expect(combined).toContain("bold");
+      expect(combined).not.toContain("**");
+    });
+
+    it("flushes remaining buffer on end()", () => {
+      const md = new MarkdownStream(true);
+      // Push incomplete bold — gets buffered
+      const out1 = md.push("**unfin");
+      expect(out1).toBe(""); // buffered, not yet flushed
+      const out2 = md.end();
+      expect(out2).toContain("unfin"); // force-flushed
+    });
+
+    it("renders table separator rows as dim", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("|---|---|\n");
+      expect(out).toContain("---|---");
+    });
+
+    it("renders links by showing label and dim URL", () => {
+      const md = new MarkdownStream(true);
+      const out = md.push("[Click here](https://example.com)\n");
+      expect(out).toContain("Click here");
+      expect(out).toContain("example.com");
+      expect(out).not.toContain("[Click here]");
+    });
+  });
+});

package/test/resolve-kb.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { resolveKnowledgeBase } from "../src/resolve-kb.js";
+import { mkdtemp, rm, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("resolveKnowledgeBase", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "llm-kb-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("returns null when no .llm-kb directory exists", () => {
+    expect(resolveKnowledgeBase(tempDir)).toBeNull();
+  });
+
+  it("finds .llm-kb in the current directory", async () => {
+    await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+    expect(resolveKnowledgeBase(tempDir)).toBe(tempDir);
+  });
+
+  it("walks up to find .llm-kb in parent directory", async () => {
+    const child = join(tempDir, "subdir", "deep");
+    await mkdir(child, { recursive: true });
+    await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+    expect(resolveKnowledgeBase(child)).toBe(tempDir);
+  });
+});

package/test/scan.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { scan, summarize } from "../src/scan.js";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("scan", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "llm-kb-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("finds supported files", async () => {
+    await writeFile(join(tempDir, "doc.pdf"), "");
+    await writeFile(join(tempDir, "data.xlsx"), "");
+    await writeFile(join(tempDir, "notes.md"), "");
+    await writeFile(join(tempDir, "ignore.exe"), "");
+
+    const files = await scan(tempDir);
+    expect(files.length).toBe(3);
+    expect(files.map((f) => f.ext).sort()).toEqual([".md", ".pdf", ".xlsx"]);
+  });
+
+  it("skips .llm-kb internal directory", async () => {
+    await mkdir(join(tempDir, ".llm-kb"), { recursive: true });
+    await writeFile(join(tempDir, ".llm-kb", "index.md"), "");
+    await writeFile(join(tempDir, "real.pdf"), "");
+
+    const files = await scan(tempDir);
+    expect(files.length).toBe(1);
+    expect(files[0].name).toBe("real.pdf");
+  });
+
+  it("returns empty for empty directory", async () => {
+    const files = await scan(tempDir);
+    expect(files.length).toBe(0);
+  });
+
+  it("scans subdirectories", async () => {
+    await mkdir(join(tempDir, "sub"), { recursive: true });
+    await writeFile(join(tempDir, "sub", "nested.pdf"), "");
+
+    const files = await scan(tempDir);
+    expect(files.length).toBe(1);
+    expect(files[0].path).toContain("sub");
+  });
+});
+
+describe("summarize", () => {
+  it("summarizes file counts by extension", () => {
+    const files = [
+      { name: "a.pdf", path: "a.pdf", ext: ".pdf" },
+      { name: "b.pdf", path: "b.pdf", ext: ".pdf" },
+      { name: "c.xlsx", path: "c.xlsx", ext: ".xlsx" },
+    ];
+    const result = summarize(files);
+    expect(result).toContain("2 PDF");
+    expect(result).toContain("1 XLSX");
+  });
+});

package/test/trace-builder.test.ts

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { buildTrace, saveTrace, appendToQueryLog, KBTrace } from "../src/trace-builder.js";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { existsSync } from "node:fs";
+
+describe("trace-builder", () => {
+  let tempDir: string;
+  let sourcesDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "llm-kb-test-"));
+    sourcesDir = join(tempDir, ".llm-kb", "wiki", "sources");
+    await mkdir(sourcesDir, { recursive: true });
+    // Create some source files
+    await writeFile(join(sourcesDir, "doc1.md"), "# Doc 1");
+    await writeFile(join(sourcesDir, "doc2.md"), "# Doc 2");
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  function makeSessionJsonl(entries: {
+    header?: any;
+    modelChange?: any;
+    sessionInfo?: any;
+    messages?: any[];
+  }): string {
+    const lines: string[] = [];
+    const header = entries.header ?? {
+      type: "session", version: 3, id: "test-session-id",
+      timestamp: "2026-04-06T10:00:00Z", cwd: tempDir,
+    };
+    lines.push(JSON.stringify(header));
+
+    if (entries.modelChange) lines.push(JSON.stringify(entries.modelChange));
+    if (entries.sessionInfo) lines.push(JSON.stringify(entries.sessionInfo));
+    for (const msg of entries.messages ?? []) lines.push(JSON.stringify(msg));
+
+    return lines.join("\n");
+  }
+
+  describe("buildTrace", () => {
+    it("returns null for incomplete sessions (no stop message)", async () => {
+      const jsonl = makeSessionJsonl({
+        messages: [
+          {
+            type: "message", id: "m1", parentId: null, timestamp: "2026-04-06T10:00:01Z",
+            message: { role: "user", content: [{ type: "text", text: "Hello" }], timestamp: 1 },
+          },
+          {
+            type: "message", id: "m2", parentId: "m1", timestamp: "2026-04-06T10:00:02Z",
+            message: { role: "assistant", content: [{ type: "text", text: "Hi" }], stopReason: "toolUse", timestamp: 2 },
+          },
+        ],
+      });
+      const file = join(tempDir, "session.jsonl");
+      await writeFile(file, jsonl);
+      expect(await buildTrace(file, sourcesDir)).toBeNull();
+    });
+
+    it("parses a complete query session", async () => {
+      const jsonl = makeSessionJsonl({
+        modelChange: { type: "model_change", id: "mc1", parentId: null, timestamp: "2026-04-06T10:00:00Z", provider: "anthropic", modelId: "claude-sonnet-4-6" },
+        sessionInfo: { type: "session_info", id: "si1", parentId: "mc1", timestamp: "2026-04-06T10:00:00Z", name: "query: What is doc1?" },
+        messages: [
+          {
+            type: "message", id: "m1", parentId: "si1", timestamp: "2026-04-06T10:00:01Z",
+            message: { role: "user", content: [{ type: "text", text: "What is doc1?" }], timestamp: 1000 },
+          },
+          {
+            type: "message", id: "m2", parentId: "m1", timestamp: "2026-04-06T10:00:05Z",
+            message: {
+              role: "assistant",
+              content: [
+                { type: "toolCall", id: "tc1", name: "read", arguments: { path: ".llm-kb/wiki/sources/doc1.md" } },
+                { type: "text", text: "Doc 1 is about X." },
+              ],
+              model: "claude-sonnet-4-6", stopReason: "stop", timestamp: 5000,
+            },
+          },
+        ],
+      });
+
+      const file = join(tempDir, "session.jsonl");
+      await writeFile(file, jsonl);
+      const trace = await buildTrace(file, sourcesDir);
+
+      expect(trace).not.toBeNull();
+      expect(trace!.mode).toBe("query");
+      expect(trace!.question).toBe("What is doc1?");
+      expect(trace!.answer).toBe("Doc 1 is about X.");
+      expect(trace!.model).toBe("claude-sonnet-4-6");
+      expect(trace!.filesRead).toContain(".llm-kb/wiki/sources/doc1.md");
+      expect(trace!.filesAvailable).toContain("doc1.md");
+      expect(trace!.filesSkipped).toContain("doc2.md");
+      expect(trace!.durationMs).toBe(4000);
+    });
+
+    it("identifies index sessions by session name", async () => {
+      const jsonl = makeSessionJsonl({
+        sessionInfo: { type: "session_info", id: "si1", parentId: null, timestamp: "2026-04-06T10:00:00Z", name: "index: 2026-04-06" },
+        messages: [
+          {
+            type: "message", id: "m1", parentId: "si1", timestamp: "2026-04-06T10:00:01Z",
+            message: { role: "user", content: "Build the index", timestamp: 1 },
+          },
+          {
+            type: "message", id: "m2", parentId: "m1", timestamp: "2026-04-06T10:00:05Z",
+            message: { role: "assistant", content: [{ type: "text", text: "Done" }], stopReason: "stop", timestamp: 2 },
+          },
+        ],
+      });
+
+      const file = join(tempDir, "session.jsonl");
+      await writeFile(file, jsonl);
+      const trace = await buildTrace(file, sourcesDir);
+      expect(trace!.mode).toBe("index");
+    });
+
+    it("returns null for files with fewer than 2 lines", async () => {
+      const file = join(tempDir, "empty.jsonl");
+      await writeFile(file, '{"type":"session"}\n');
+      expect(await buildTrace(file, sourcesDir)).toBeNull();
+    });
+  });
+
+  describe("saveTrace", () => {
+    it("writes trace JSON to .llm-kb/traces/", async () => {
+      const trace: KBTrace = {
+        sessionId: "abc123",
+        sessionFile: "session.jsonl",
+        timestamp: "2026-04-06T10:00:00Z",
+        mode: "query",
+        question: "test?",
+        answer: "yes",
+        filesRead: [],
+        filesAvailable: [],
+        filesSkipped: [],
+        model: "test-model",
+      };
+
+      await saveTrace(tempDir, trace);
+      const path = join(tempDir, ".llm-kb", "traces", "abc123.json");
+      expect(existsSync(path)).toBe(true);
+
+      const saved = JSON.parse(await readFile(path, "utf-8"));
+      expect(saved.sessionId).toBe("abc123");
+      expect(saved.question).toBe("test?");
+    });
+  });
+
+  describe("appendToQueryLog", () => {
+    it("creates queries.md with header on first call", async () => {
+      const trace: KBTrace = {
+        sessionId: "abc",
+        sessionFile: "s.jsonl",
+        timestamp: "2026-04-06T10:00:00Z",
+        mode: "query",
+        question: "What is X?",
+        answer: "X is Y.",
+        filesRead: ["doc1.md"],
+        filesAvailable: ["doc1.md"],
+        filesSkipped: [],
+        model: "test",
+      };
+
+      await appendToQueryLog(tempDir, trace);
+      const logPath = join(tempDir, ".llm-kb", "wiki", "queries.md");
+      expect(existsSync(logPath)).toBe(true);
+
+      const content = await readFile(logPath, "utf-8");
+      expect(content).toContain("# Query Log");
+      expect(content).toContain("## What is X?");
+      expect(content).toContain("X is Y.");
+    });
+
+    it("skips non-query traces", async () => {
+      const trace: KBTrace = {
+        sessionId: "abc",
+        sessionFile: "s.jsonl",
+        timestamp: "2026-04-06T10:00:00Z",
+        mode: "index",
+        filesRead: [],
+        filesAvailable: [],
+        filesSkipped: [],
+      };
+
+      await appendToQueryLog(tempDir, trace);
+      const logPath = join(tempDir, ".llm-kb", "wiki", "queries.md");
+      expect(existsSync(logPath)).toBe(false);
+    });
+
+    it("prepends new entries to existing log", async () => {
+      const trace1: KBTrace = {
+        sessionId: "a", sessionFile: "s.jsonl", timestamp: "2026-04-06T10:00:00Z",
+        mode: "query", question: "First?", answer: "One", filesRead: [], filesAvailable: [], filesSkipped: [],
+      };
+      const trace2: KBTrace = {
+        sessionId: "b", sessionFile: "s.jsonl", timestamp: "2026-04-06T11:00:00Z",
+        mode: "query", question: "Second?", answer: "Two", filesRead: [], filesAvailable: [], filesSkipped: [],
+      };
+
+      await appendToQueryLog(tempDir, trace1);
+      await appendToQueryLog(tempDir, trace2);
+
+      const content = await readFile(join(tempDir, ".llm-kb", "wiki", "queries.md"), "utf-8");
+      const firstIdx = content.indexOf("Second?");
+      const secondIdx = content.indexOf("First?");
+      expect(firstIdx).toBeLessThan(secondIdx); // newest first
+    });
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["test/**/*.test.ts"],
+    testTimeout: 10000,
+  },
+});

package/bin/chunk-MYQ36JJB.js

@@ -1,118 +0,0 @@
-// src/indexer.ts
-import {
-  createAgentSession,
-  createBashTool,
-  createReadTool,
-  createWriteTool,
-  DefaultResourceLoader,
-  SessionManager,
-  SettingsManager
-} from "@mariozechner/pi-coding-agent";
-import { readdir, readFile } from "fs/promises";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-function getNodeModulesPath() {
-  let dir = __dirname;
-  for (let i = 0; i < 5; i++) {
-    const candidate = join(dir, "node_modules");
-    try {
-      return candidate;
-    } catch {
-      dir = dirname(dir);
-    }
-  }
-  return join(process.cwd(), "node_modules");
-}
-function buildAgentsContent(sourcesDir, files) {
-  const sourceList = files.filter((f) => f.endsWith(".md")).map((f) => `  - ${f}`).join("\n");
-  return `# llm-kb Knowledge Base
-
-## How to access documents
-
-### PDFs (pre-parsed)
-PDFs have been parsed to markdown with bounding boxes.
-Read the markdown versions in \`.llm-kb/wiki/sources/\` instead of the raw PDFs.
-
-Available parsed sources:
-${sourceList}
-
-### Other file types (Excel, Word, PowerPoint, CSV, images)
-You have bash and read tools. These libraries are pre-installed and available:
-- **exceljs** \u2014 for .xlsx/.xls files
-- **mammoth** \u2014 for .docx files  
-- **officeparser** \u2014 for .pptx files
-- **csv-parse** \u2014 built into Node.js, use fs + split for .csv
-
-Write a quick Node.js script to extract content when needed.
-
-## Index file
-Write the index to \`.llm-kb/wiki/index.md\`.
-
-The index should be a markdown file with:
-1. A title and last-updated timestamp
-2. A summary table with columns: Source, Type, Pages/Size, Summary, Key Topics
-3. Each source gets a one-line summary (read the first ~500 chars of each file to generate it)
-4. Total word count across all sources
-`;
-}
-async function buildIndex(folder, sourcesDir, onOutput) {
-  const files = await readdir(sourcesDir);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-  if (mdFiles.length === 0) {
-    throw new Error("No source files found to index");
-  }
-  const agentsContent = buildAgentsContent(sourcesDir, files);
-  const nodeModulesPath = getNodeModulesPath();
-  process.env.NODE_PATH = nodeModulesPath;
-  const loader = new DefaultResourceLoader({
-    cwd: folder,
-    agentsFilesOverride: (current) => ({
-      agentsFiles: [
-        ...current.agentsFiles,
-        { path: ".llm-kb/AGENTS.md", content: agentsContent }
-      ]
-    })
-  });
-  await loader.reload();
-  const { session } = await createAgentSession({
-    cwd: folder,
-    resourceLoader: loader,
-    tools: [
-      createReadTool(folder),
-      createBashTool(folder),
-      createWriteTool(folder)
-    ],
-    sessionManager: SessionManager.inMemory(),
-    settingsManager: SettingsManager.inMemory({
-      compaction: { enabled: false }
-    })
-  });
-  if (onOutput) {
-    session.subscribe((event) => {
-      if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
-        onOutput(event.assistantMessageEvent.delta);
-      }
-    });
-  }
-  const prompt = `Read each file in .llm-kb/wiki/sources/ (one at a time, just the first 500 characters of each).
-Then write .llm-kb/wiki/index.md with a summary table of all sources.
-
-Include: Source filename, Type (PDF/Excel/Word/etc), Pages (from the JSON if available), a one-line summary, and key topics.
-Add a total word count estimate at the bottom.`;
-  await session.prompt(prompt);
-  const indexPath = join(sourcesDir, "..", "index.md");
-  try {
-    const content = await readFile(indexPath, "utf-8");
-    session.dispose();
-    return content;
-  } catch {
-    session.dispose();
-    throw new Error("Agent did not create index.md");
-  }
-}
-
-export {
-  buildIndex
-};

package/bin/indexer-LSYSZXZX.js

@@ -1,6 +0,0 @@
-import {
-  buildIndex
-} from "./chunk-MYQ36JJB.js";
-export {
-  buildIndex
-};