mono/packages/kbot/dist-in/source.js

import * as path from 'node:path';
import * as fs from 'node:fs';
import { sync as dir } from '@polymech/fs/dir';
import { createItem as toNode } from '@polymech/fs/inspect';
import { sync as exists } from '@polymech/fs/exists';
import { isFile, forward_slash } from '@polymech/commons';
import { logger } from './index.js';
import { lookup } from 'mime-types';
import { globSync } from 'glob';
import { EXCLUDE_GLOB, MAX_FILE_SIZE } from './constants.js';
import { defaultMimeRegistry } from './mime-handlers.js';
import { supported } from './commands/run-assistant.js';
import { handleWebUrl } from './http.js';
/**
 * @todos
 * - add support for vector stores : https://platform.openai.com/docs/assistants/tools/file-search?lang=node.js
 */
export const default_filters = {
    isFile,
    exists,
    size: (filePath) => toNode(filePath).size < MAX_FILE_SIZE,
};
const isPathInside = (childPath, parentPath) => {
    const relation = path.relative(parentPath, childPath);
    return Boolean(relation &&
        !relation.startsWith('..') &&
        !relation.startsWith('..' + path.sep));
};
export const isPathOutsideSafe = (pathA, pathB) => {
    const realA = fs.realpathSync(pathA);
    const realB = fs.realpathSync(pathB);
    return !isPathInside(realA, realB);
};
export const base64 = (filePath) => {
    try {
        const fileBuffer = fs.readFileSync(filePath);
        const mimeType = lookup(filePath);
        if (!mimeType) {
            throw new Error('Unable to determine MIME type.');
        }
        const base64Data = fileBuffer.toString('base64');
        return `data:${mimeType};base64,${base64Data}`;
    }
    catch (error) {
        logger.error('fileToBase64 : Error reading file:', error);
        return null;
    }
};
export const images = (files) => {
    return files.map((f) => ({
        type: "image_url",
        image_url: { url: base64(f) }
    }));
};
/**
 * Check if a string is a web URL
 */
export const isWebUrl = (str) => {
    return /^https?:\/\//.test(str);
};
export const glob = (projectPath, include = [], exclude = []) => {
    if (!exists(projectPath)) {
        dir(projectPath);
        return { files: [], webUrls: new Set() };
    }
    const filters = new Set();
    const absolutePaths = new Set();
    const webUrls = new Set();
    const ignorePatterns = new Set(EXCLUDE_GLOB);
    include.forEach(pattern => {
        // Check if the pattern is a web URL
        if (isWebUrl(pattern)) {
            webUrls.add(pattern);
            return;
        }
        if (path.isAbsolute(pattern)) {
            if (isPathInside(pattern, projectPath)) {
                filters.add(pattern);
            }
            else {
                absolutePaths.add(pattern);
            }
        }
        else {
            filters.add(pattern);
        }
    });
    // Process exclude patterns
    exclude.forEach(pattern => {
        if (isWebUrl(pattern)) {
            // Web URLs are typically not "excluded" in a file glob sense,
            // but if there's a use case, it needs clarification.
            // For now, we'll assume web URLs in exclude are ignored for globbing.
            return;
        }
        // Add all exclude patterns (absolute or relative) to ignorePatterns
        // globSync handles absolute paths correctly in its `ignore` option when `cwd` is set.
        ignorePatterns.add(pattern);
    });
    const globFiles = globSync([...filters], {
        cwd: projectPath,
        absolute: false,
        ignore: [...ignorePatterns]
    });
    const allFiles = Array.from(new Set([
        ...globFiles.map(file => path.join(projectPath, file)),
        ...Array.from(absolutePaths)
    ]));
    let files = allFiles.filter((f) => Object.keys(default_filters).every((key) => default_filters[key](f)));
    return { files, webUrls };
};
export async function get(projectPath, include = [], options) {
    const { files, webUrls } = glob(projectPath, include, options.exclude);
    // Process file contents
    const fileResults = files.map((fullPath) => {
        try {
            const relativePath = forward_slash(path.relative(projectPath, fullPath));
            if (isFile(fullPath) && exists(fullPath)) {
                const mimeType = lookup(fullPath) || 'text/plain';
                const handler = defaultMimeRegistry.getHandler(mimeType);
                if (handler) {
                    return handler.handle(fullPath, relativePath);
                }
                return defaultMimeRegistry.getHandler('text/*')?.handle(fullPath, relativePath) || null;
            }
            return null;
        }
        catch (error) {
            logger.error(`Error reading file ${fullPath}:`, error);
            return null;
        }
    });
    // Process web URLs
    const webUrlPromises = Array.from(webUrls).map(async (url) => {
        try {
            return await handleWebUrl(url);
        }
        catch (error) {
            logger.error(`Error processing web URL ${url}:`, error);
            return null;
        }
    });
    const webResults = await Promise.all(webUrlPromises);
    // Combine and filter results
    const results = [...fileResults, ...webResults].filter((r) => r !== null);
    return results;
}
export async function vectorize(file, options) {
    if (!options.client) {
        throw new Error('OpenAI client is required for vectorization');
    }
    const ext = path.extname(file).toLowerCase();
    if (!(ext in supported)) {
        throw new Error(`Unsupported file format: ${ext}. Supported formats: ${Object.keys(supported).join(', ')}`);
    }
    try {
        // Create a vector store
        const vectorStore = await options.client.vectorStores.create({
            name: path.basename(file)
        });
        // Upload file to vector store
        const fileStream = fs.createReadStream(file);
        await options.client.vectorStores.fileBatches.uploadAndPoll(vectorStore.id, {
            files: [fileStream]
        });
        // Create meta file path by appending .meta.json to the original file path
        const metaPath = `${file}.meta.json`;
        const metaData = {
            vectorStoreId: vectorStore.id,
            vectorizedAt: new Date().toISOString(),
            originalPath: file,
            mimeType: supported[ext]
        };
        // Write meta data to file
        fs.writeFileSync(metaPath, JSON.stringify(metaData, null, 2));
        return vectorStore.id;
    }
    catch (error) {
        logger.error(`Failed to vectorize file ${file}:`, error);
        throw error;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"source.js","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"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"}