@bndynet/ragbox 0.1.0

package/dist/src/config-file.d.ts

@@ -0,0 +1,69 @@
+import { PageIndexOptions } from "./folder-index/types";
+export declare const RAGBOX_CONFIG_FILE = "ragbox.config.json";
+export type RagboxPageIndexConfig = {
+    cli?: string;
+    concurrency?: number;
+    extraArgs?: string[];
+    outputArg?: string;
+    python?: string;
+};
+export type RagboxLlmConfig = {
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+};
+export type RagboxIndexConfig = {
+    exclude?: string[];
+    include?: string[];
+    outputDir?: string;
+};
+export type RagboxConfigSource = RagboxIndexConfig & {
+    index?: RagboxIndexConfig;
+    llm?: RagboxLlmConfig;
+    pageIndex?: RagboxPageIndexConfig;
+    rootDir: string;
+};
+export type RagboxConfig = {
+    version: 1;
+    docs?: RagboxConfigSource;
+    index?: RagboxIndexConfig;
+    llm?: RagboxLlmConfig;
+    pageIndex?: RagboxPageIndexConfig;
+    sources?: Record<string, RagboxConfigSource>;
+};
+export type ResolvedRagboxConfig = {
+    config?: RagboxConfig;
+    configDir: string;
+    configPath?: string;
+    pageIndexOptions: PageIndexOptions;
+    rootDir?: string;
+    sourceName?: string;
+};
+export type ResolveRagboxConfigOptions = {
+    configPath?: string;
+    cwd?: string;
+    source?: string;
+};
+export type WriteDefaultRagboxConfigOptions = {
+    configPath?: string;
+    cwd?: string;
+    docsDir?: string;
+    force?: boolean;
+    outputDir?: string;
+};
+export type WritePageIndexSetupConfigOptions = {
+    cliPath: string;
+    configPath?: string;
+    cwd?: string;
+    pythonPath?: string;
+};
+export declare function createDefaultRagboxConfig(options?: Pick<WriteDefaultRagboxConfigOptions, "docsDir" | "outputDir">): RagboxConfig;
+export declare function listRagboxConfigSourceNames(config: RagboxConfig | undefined): string[];
+export declare function writeDefaultRagboxConfig(options?: WriteDefaultRagboxConfigOptions): Promise<string>;
+export declare function writePageIndexSetupConfig(options: WritePageIndexSetupConfigOptions): Promise<string>;
+export declare function readRagboxConfig(configPath?: string, cwd?: string): Promise<{
+    config?: RagboxConfig;
+    configPath?: string;
+    configDir: string;
+}>;
+export declare function resolveRagboxConfig(options?: ResolveRagboxConfigOptions): Promise<ResolvedRagboxConfig>;

package/dist/src/config-file.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RAGBOX_CONFIG_FILE = void 0;
+exports.createDefaultRagboxConfig = createDefaultRagboxConfig;
+exports.listRagboxConfigSourceNames = listRagboxConfigSourceNames;
+exports.writeDefaultRagboxConfig = writeDefaultRagboxConfig;
+exports.writePageIndexSetupConfig = writePageIndexSetupConfig;
+exports.readRagboxConfig = readRagboxConfig;
+exports.resolveRagboxConfig = resolveRagboxConfig;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.RAGBOX_CONFIG_FILE = "ragbox.config.json";
+const DEFAULT_INCLUDE = ["**/*.md", "**/*.mdx"];
+const DEFAULT_EXCLUDE = ["node_modules/**", ".git/**", ".pageindex/**", "dist/**", "build/**"];
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function configFileName(name) {
+    return name ? `ragbox.config.${name}.json` : exports.RAGBOX_CONFIG_FILE;
+}
+function looksLikeConfigName(value) {
+    return !value.endsWith(".json") && !value.includes("/") && !value.includes("\\");
+}
+async function findConfigPath(cwd, name) {
+    let currentDir = node_path_1.default.resolve(cwd);
+    while (true) {
+        const candidate = node_path_1.default.join(currentDir, configFileName(name));
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+        const parent = node_path_1.default.dirname(currentDir);
+        if (parent === currentDir) {
+            return undefined;
+        }
+        currentDir = parent;
+    }
+}
+async function resolveConfigPath(configPath, cwd) {
+    if (!configPath) {
+        return undefined;
+    }
+    if (looksLikeConfigName(configPath)) {
+        return (await findConfigPath(cwd, configPath)) ?? node_path_1.default.resolve(cwd, configFileName(configPath));
+    }
+    return node_path_1.default.resolve(cwd, configPath);
+}
+function resolveConfigRelativePath(configDir, value) {
+    if (!value) {
+        return undefined;
+    }
+    return node_path_1.default.isAbsolute(value) ? value : node_path_1.default.resolve(configDir, value);
+}
+function resolveConfigCommandPath(configDir, value) {
+    if (!value || node_path_1.default.isAbsolute(value)) {
+        return value;
+    }
+    if (value.startsWith(".") || value.includes("/") || value.includes("\\")) {
+        return node_path_1.default.resolve(configDir, value);
+    }
+    return value;
+}
+function normalizeConfigRelativePath(value) {
+    return value.split(node_path_1.default.sep).join("/");
+}
+function toConfigRelativeCommandPath(configDir, cwd, value) {
+    const absolutePath = node_path_1.default.isAbsolute(value) ? value : node_path_1.default.resolve(cwd, value);
+    const relativePath = normalizeConfigRelativePath(node_path_1.default.relative(configDir, absolutePath));
+    if (!relativePath || relativePath.startsWith("..")) {
+        return normalizeConfigRelativePath(absolutePath);
+    }
+    return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+}
+function mergePageIndexConfig(...configs) {
+    return Object.assign({}, ...configs.filter(Boolean));
+}
+function mergeLlmConfig(...configs) {
+    return Object.assign({}, ...configs.filter(Boolean));
+}
+function mergeIndexConfig(...configs) {
+    return Object.assign({}, ...configs.filter(Boolean));
+}
+function pageIndexConfigToOptions(configDir, config) {
+    return {
+        cliPath: resolveConfigCommandPath(configDir, config.cli),
+        concurrency: config.concurrency,
+        extraArgs: config.extraArgs,
+        outputArg: config.outputArg,
+        pythonPath: resolveConfigCommandPath(configDir, config.python)
+    };
+}
+function llmConfigToOptions(config) {
+    return {
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl,
+        model: config.model
+    };
+}
+function indexConfigToOptions(configDir, config) {
+    return {
+        exclude: config.exclude,
+        include: config.include,
+        outputDir: resolveConfigRelativePath(configDir, config.outputDir)
+    };
+}
+function createDefaultRagboxConfig(options = {}) {
+    const docsDir = options.docsDir ?? "./docs";
+    const outputDir = options.outputDir ?? "./.ragbox-index";
+    return {
+        version: 1,
+        pageIndex: {
+            cli: "/path/to/PageIndex/run_pageindex.py"
+        },
+        llm: {
+            baseUrl: "https://api.openai.com/v1",
+            model: "gpt-4o-mini"
+        },
+        docs: {
+            rootDir: docsDir,
+            outputDir
+        }
+    };
+}
+function inferSourceName(config, requestedSource) {
+    if (requestedSource) {
+        return requestedSource;
+    }
+    if (config?.docs) {
+        return "docs";
+    }
+    const sourceNames = Object.keys(config?.sources ?? {});
+    return sourceNames.length === 1 ? sourceNames[0] : undefined;
+}
+function findSource(config, sourceName) {
+    if (!sourceName) {
+        return undefined;
+    }
+    if (sourceName === "docs" && config?.docs) {
+        return config.docs;
+    }
+    return config?.sources?.[sourceName];
+}
+function listRagboxConfigSourceNames(config) {
+    if (!config) {
+        return [];
+    }
+    const names = new Set();
+    if (config.docs) {
+        names.add("docs");
+    }
+    for (const sourceName of Object.keys(config.sources ?? {})) {
+        names.add(sourceName);
+    }
+    return [...names];
+}
+async function writeDefaultRagboxConfig(options = {}) {
+    const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+    const configPath = node_path_1.default.resolve(cwd, options.configPath ?? exports.RAGBOX_CONFIG_FILE);
+    if (!options.force && (await pathExists(configPath))) {
+        throw new Error(`Config file already exists: ${configPath}`);
+    }
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(createDefaultRagboxConfig({ docsDir: options.docsDir, outputDir: options.outputDir }), null, 2)}\n`, "utf8");
+    return configPath;
+}
+async function writePageIndexSetupConfig(options) {
+    const cwd = node_path_1.default.resolve(options.cwd ?? process.cwd());
+    const configPath = (await resolveConfigPath(options.configPath, cwd)) ?? (await findConfigPath(cwd)) ?? node_path_1.default.resolve(cwd, exports.RAGBOX_CONFIG_FILE);
+    const configDir = node_path_1.default.dirname(configPath);
+    let config = createDefaultRagboxConfig();
+    if (await pathExists(configPath)) {
+        config = JSON.parse(await promises_1.default.readFile(configPath, "utf8"));
+        if (config.version !== 1) {
+            throw new Error(`Unsupported ragbox config version in ${configPath}: ${String(config.version)}`);
+        }
+    }
+    const pageIndex = {
+        ...(config.pageIndex ?? {}),
+        cli: toConfigRelativeCommandPath(configDir, cwd, options.cliPath)
+    };
+    if (options.pythonPath) {
+        pageIndex.python = toConfigRelativeCommandPath(configDir, cwd, options.pythonPath);
+    }
+    else {
+        delete pageIndex.python;
+    }
+    config.pageIndex = pageIndex;
+    await promises_1.default.mkdir(node_path_1.default.dirname(configPath), { recursive: true });
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    return configPath;
+}
+async function readRagboxConfig(configPath, cwd = process.cwd()) {
+    const resolvedConfigPath = (await resolveConfigPath(configPath, cwd)) ?? (await findConfigPath(cwd));
+    if (!resolvedConfigPath) {
+        return {
+            configDir: node_path_1.default.resolve(cwd)
+        };
+    }
+    const config = JSON.parse(await promises_1.default.readFile(resolvedConfigPath, "utf8"));
+    if (config.version !== 1) {
+        throw new Error(`Unsupported ragbox config version in ${resolvedConfigPath}: ${String(config.version)}`);
+    }
+    return {
+        config,
+        configDir: node_path_1.default.dirname(resolvedConfigPath),
+        configPath: resolvedConfigPath
+    };
+}
+async function resolveRagboxConfig(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const { config, configDir, configPath } = await readRagboxConfig(options.configPath, cwd);
+    const sourceName = inferSourceName(config, options.source);
+    const source = findSource(config, sourceName);
+    if (options.source && !source) {
+        throw new Error(`Source not found in ragbox config: ${options.source}`);
+    }
+    const pageIndexConfig = mergePageIndexConfig(config?.pageIndex, source?.pageIndex);
+    const llmConfig = mergeLlmConfig(config?.llm, source?.llm);
+    const indexConfig = mergeIndexConfig(config?.index, source
+        ? {
+            exclude: source.exclude,
+            include: source.include,
+            outputDir: source.outputDir
+        }
+        : undefined, source?.index);
+    return {
+        config,
+        configDir,
+        configPath,
+        pageIndexOptions: {
+            ...pageIndexConfigToOptions(configDir, pageIndexConfig),
+            ...llmConfigToOptions(llmConfig),
+            ...indexConfigToOptions(configDir, indexConfig)
+        },
+        rootDir: resolveConfigRelativePath(configDir, source?.rootDir),
+        sourceName
+    };
+}

package/dist/src/folder-index/config.d.ts

@@ -0,0 +1,2 @@
+import { PageIndexOptions } from "./types";
+export declare function loadPageIndexConfig(overrides?: PageIndexOptions): Required<Pick<PageIndexOptions, "pythonPath" | "model" | "baseUrl" | "concurrency">> & PageIndexOptions;

package/dist/src/folder-index/config.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPageIndexConfig = loadPageIndexConfig;
+function parsePositiveInt(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function parseNonNegativeInt(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function parseBoolean(value, fallback = false) {
+    if (!value) {
+        return fallback;
+    }
+    return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function parseExtraArgs(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed.split(/\s+/) : undefined;
+}
+function loadPageIndexConfig(overrides = {}) {
+    const env = overrides.env ?? process.env;
+    return {
+        pythonPath: overrides.pythonPath ?? env.PAGEINDEX_PYTHON ?? "python3",
+        cliPath: overrides.cliPath ?? env.PAGEINDEX_CLI,
+        model: overrides.model ?? env.PAGEINDEX_MODEL ?? env.LLM_MODEL ?? "gpt-4o-mini",
+        baseUrl: overrides.baseUrl ?? env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+        apiKey: overrides.apiKey ?? env.OPENAI_API_KEY,
+        concurrency: overrides.concurrency ?? parsePositiveInt(env.PAGEINDEX_CONCURRENCY, 1),
+        exclude: overrides.exclude,
+        include: overrides.include,
+        outputDir: overrides.outputDir ?? env.RAGBOX_OUTPUT_DIR,
+        outputArg: overrides.outputArg ?? env.PAGEINDEX_OUTPUT_ARG,
+        extraArgs: overrides.extraArgs ?? parseExtraArgs(env.PAGEINDEX_EXTRA_ARGS),
+        progress: overrides.progress,
+        trace: overrides.trace,
+        watchDebounceMs: overrides.watchDebounceMs ?? parseNonNegativeInt(env.RAGBOX_WATCH_DEBOUNCE_MS, 500),
+        watchHealthFile: overrides.watchHealthFile ?? env.RAGBOX_WATCH_HEALTH_FILE,
+        watchLockFile: overrides.watchLockFile ?? env.RAGBOX_WATCH_LOCK_FILE,
+        watchProgress: overrides.watchProgress,
+        watchRetryAttempts: overrides.watchRetryAttempts ?? parseNonNegativeInt(env.RAGBOX_WATCH_RETRY_ATTEMPTS, 0),
+        watchRetryDelayMs: overrides.watchRetryDelayMs ?? parseNonNegativeInt(env.RAGBOX_WATCH_RETRY_DELAY_MS, 1000),
+        watchStaging: overrides.watchStaging ??
+            (parseBoolean(env.RAGBOX_WATCH_STAGING) || Boolean(overrides.watchStagingOutputDir ?? env.RAGBOX_WATCH_STAGING_OUTPUT_DIR)),
+        watchStagingOutputDir: overrides.watchStagingOutputDir ?? env.RAGBOX_WATCH_STAGING_OUTPUT_DIR,
+        watchWebhookUrl: overrides.watchWebhookUrl ?? env.RAGBOX_WATCH_WEBHOOK_URL,
+        env
+    };
+}

package/dist/src/folder-index/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashFile(filePath: string): Promise<string>;

package/dist/src/folder-index/hash.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashFile = hashFile;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+async function hashFile(filePath) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    const stream = (0, node_fs_1.createReadStream)(filePath);
+    return await new Promise((resolve, reject) => {
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("error", reject);
+        stream.on("end", () => resolve(`sha256:${hash.digest("hex")}`));
+    });
+}

package/dist/src/folder-index/indexer.d.ts

@@ -0,0 +1,2 @@
+import { IndexFolderResult, PageIndexOptions } from "./types";
+export declare function indexFolder(folder: string, options?: PageIndexOptions): Promise<IndexFolderResult>;

package/dist/src/folder-index/indexer.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexFolder = indexFolder;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+const manifest_1 = require("./manifest");
+const pageindex_runner_1 = require("./pageindex-runner");
+const queue_1 = require("./queue");
+const root_tree_1 = require("./root-tree");
+const scan_1 = require("./scan");
+const path_utils_1 = require("./path-utils");
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function reportProgress(options, event) {
+    try {
+        options.progress?.(event);
+    }
+    catch {
+        // Progress reporting must never change indexing behavior.
+    }
+}
+async function findStaleIndexFiles(rootDir, files, outputDir) {
+    const staleFiles = [];
+    for (const file of files) {
+        try {
+            const stat = await promises_1.default.stat((0, manifest_1.resolveDocumentIndexPath)(rootDir, file.indexPath, outputDir));
+            if (stat.mtimeMs < file.mtimeMs - 1) {
+                staleFiles.push(file);
+            }
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                staleFiles.push(file);
+                continue;
+            }
+            throw error;
+        }
+    }
+    return staleFiles;
+}
+async function indexFolder(folder, options = {}) {
+    const rootDir = node_path_1.default.resolve(folder);
+    const config = (0, config_1.loadPageIndexConfig)(options);
+    const outputDir = (0, manifest_1.resolvePageIndexDir)(rootDir, config.outputDir);
+    const manifestPath = node_path_1.default.join(outputDir, "manifest.json");
+    const rootTreePath = node_path_1.default.join(outputDir, "root-tree.json");
+    const excludedDirs = (0, path_utils_1.isStrictSubPath)(rootDir, outputDir) ? [outputDir] : [];
+    const previousManifest = await (0, manifest_1.readManifest)(rootDir, config.outputDir);
+    const scannedFiles = await (0, scan_1.scanMarkdownFiles)(rootDir, {
+        exclude: config.exclude,
+        excludedDirs,
+        include: config.include
+    });
+    const diff = (0, manifest_1.diffManifest)(previousManifest, scannedFiles);
+    const staleIndexFiles = await findStaleIndexFiles(rootDir, diff.unchanged, config.outputDir);
+    const staleIndexPaths = new Set(staleIndexFiles.map((file) => file.path));
+    const unchanged = diff.unchanged.filter((file) => !staleIndexPaths.has(file.path));
+    const toIndex = [...diff.toIndex, ...staleIndexFiles];
+    const previousByPath = new Map(previousManifest.documents.map((record) => [record.path, record]));
+    reportProgress(config, {
+        type: "scan",
+        rootDir,
+        outputDir,
+        total: scannedFiles.length,
+        toIndex: toIndex.length,
+        unchanged: unchanged.length,
+        deleted: diff.deleted.length
+    });
+    await promises_1.default.mkdir(node_path_1.default.join(outputDir, manifest_1.INDEXES_DIR), { recursive: true });
+    await (0, manifest_1.removeDeletedIndexFiles)(rootDir, diff.deleted, config.outputDir);
+    const indexedRecords = await (0, queue_1.runWithConcurrency)(toIndex, config.concurrency, async (scannedFile, index) => {
+        const absoluteOutputPath = (0, manifest_1.resolveDocumentIndexPath)(rootDir, scannedFile.indexPath, config.outputDir);
+        const progressIndex = index + 1;
+        const progressTotal = toIndex.length;
+        reportProgress(config, { type: "index-start", path: scannedFile.path, index: progressIndex, total: progressTotal });
+        try {
+            await (0, pageindex_runner_1.runPageIndex)(scannedFile.absolutePath, absoluteOutputPath, config);
+            const summary = await (0, pageindex_runner_1.readPageIndexSummary)(absoluteOutputPath);
+            reportProgress(config, {
+                type: "index-done",
+                path: scannedFile.path,
+                index: progressIndex,
+                total: progressTotal,
+                summary
+            });
+            return (0, manifest_1.recordFromScannedFile)(scannedFile, { status: "ready", summary });
+        }
+        catch (error) {
+            const previous = previousByPath.get(scannedFile.path);
+            reportProgress(config, {
+                type: "index-failed",
+                path: scannedFile.path,
+                index: progressIndex,
+                total: progressTotal,
+                error: errorMessage(error)
+            });
+            return (0, manifest_1.recordFromScannedFile)(scannedFile, {
+                status: "failed",
+                summary: previous?.summary,
+                error: errorMessage(error)
+            });
+        }
+    });
+    const indexedByPath = new Map(indexedRecords.map((record) => [record.path, record]));
+    const documents = [];
+    for (const scannedFile of scannedFiles) {
+        const indexedRecord = indexedByPath.get(scannedFile.path);
+        if (indexedRecord) {
+            documents.push(indexedRecord);
+            continue;
+        }
+        const previous = previousByPath.get(scannedFile.path);
+        documents.push((0, manifest_1.recordFromScannedFile)(scannedFile, {
+            status: previous?.status === "ready" ? "ready" : "failed",
+            summary: previous?.summary,
+            error: previous?.status === "failed" ? previous.error : undefined
+        }));
+    }
+    documents.sort((left, right) => left.path.localeCompare(right.path));
+    const manifest = {
+        version: 1,
+        rootDir: (0, path_utils_1.normalizeAbsolutePath)(rootDir),
+        generatedAt: new Date().toISOString(),
+        documents
+    };
+    const rootTree = (0, root_tree_1.generateRootTree)(manifest);
+    await (0, manifest_1.writeManifest)(rootDir, manifest, config.outputDir);
+    await (0, root_tree_1.writeRootTree)(rootDir, rootTree, config.outputDir);
+    await (0, manifest_1.writeFileState)(rootDir, manifest, config.outputDir);
+    reportProgress(config, {
+        type: "write",
+        manifestPath,
+        rootTreePath
+    });
+    return {
+        manifest,
+        rootTree,
+        outputDir,
+        manifestPath,
+        rootTreePath,
+        added: diff.added.length,
+        modified: diff.modified.length + staleIndexFiles.length,
+        retryFailed: diff.retryFailed.length,
+        unchanged: unchanged.length,
+        deleted: diff.deleted.length,
+        failed: documents.filter((record) => record.status === "failed").length,
+        ready: documents.filter((record) => record.status === "ready").length
+    };
+}

package/dist/src/folder-index/llm-client.d.ts

@@ -0,0 +1,3 @@
+import { ChatMessage, PageIndexOptions } from "./types";
+export declare function chatCompletionsUrl(baseUrl: string): string;
+export declare function chatCompletion(messages: ChatMessage[], options?: PageIndexOptions): Promise<string>;

package/dist/src/folder-index/llm-client.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCompletionsUrl = chatCompletionsUrl;
+exports.chatCompletion = chatCompletion;
+const config_1 = require("./config");
+function chatCompletionsUrl(baseUrl) {
+    const trimmed = baseUrl.replace(/\/$/, "");
+    return trimmed.endsWith("/chat/completions") ? trimmed : `${trimmed}/chat/completions`;
+}
+async function chatCompletion(messages, options = {}) {
+    const config = (0, config_1.loadPageIndexConfig)(options);
+    const request = {
+        messages,
+        model: config.model,
+        temperature: 0
+    };
+    if (options.llmClient) {
+        return await options.llmClient.chatCompletion(request);
+    }
+    if (!config.apiKey) {
+        throw new Error("OPENAI_API_KEY is required for query");
+    }
+    const response = await fetch(chatCompletionsUrl(config.baseUrl), {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+            model: request.model,
+            messages: request.messages,
+            temperature: request.temperature
+        })
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`LLM request failed with ${response.status}: ${body}`);
+    }
+    const payload = (await response.json());
+    const content = payload.choices?.[0]?.message?.content;
+    if (!content) {
+        throw new Error("LLM response did not contain message content");
+    }
+    return content;
+}

package/dist/src/folder-index/manifest.d.ts

@@ -0,0 +1,17 @@
+import { DocumentRecord, Manifest, ManifestDiff, ScannedFile } from "./types";
+export declare const PAGEINDEX_DIR = ".pageindex";
+export declare const INDEXES_DIR = "indexes";
+export declare const MANIFEST_FILE = "manifest.json";
+export declare const ROOT_TREE_FILE = "root-tree.json";
+export declare const FILE_STATE_FILE: string;
+export declare function createEmptyManifest(rootDir: string): Manifest;
+export declare function resolvePageIndexDir(rootDir: string, outputDir?: string): string;
+export declare function getPageIndexPath(rootDir: string, relativePath: string, outputDir?: string): string;
+export declare function resolveDocumentIndexPath(rootDir: string, indexPath: string, outputDir?: string): string;
+export declare function readManifest(rootDir: string, outputDir?: string): Promise<Manifest>;
+export declare function diffManifest(previous: Manifest, scannedFiles: ScannedFile[]): ManifestDiff;
+export declare function recordFromScannedFile(scannedFile: ScannedFile, fields?: Partial<DocumentRecord>): DocumentRecord;
+export declare function atomicWriteJson(filePath: string, value: unknown): Promise<void>;
+export declare function writeManifest(rootDir: string, manifest: Manifest, outputDir?: string): Promise<void>;
+export declare function writeFileState(rootDir: string, manifest: Manifest, outputDir?: string): Promise<void>;
+export declare function removeDeletedIndexFiles(rootDir: string, deletedRecords: DocumentRecord[], outputDir?: string): Promise<void>;