@steipete/oracle 1.0.7 → 1.1.0

package/dist/oracle/src/oracle/files.js

@@ -0,0 +1,220 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { FileValidationError } from './errors.js';
+const MAX_FILE_SIZE_BYTES = 1 * 1024 * 1024; // 1 MB
+const DEFAULT_FS = fs;
+export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEFAULT_FS, maxFileSizeBytes = MAX_FILE_SIZE_BYTES } = {}) {
+    if (!filePaths || filePaths.length === 0) {
+        return [];
+    }
+    const partitioned = await partitionFileInputs(filePaths, cwd, fsModule);
+    const useNativeFilesystem = fsModule === DEFAULT_FS;
+    let candidatePaths = [];
+    if (useNativeFilesystem) {
+        candidatePaths = await expandWithNativeGlob(partitioned, cwd);
+    }
+    else {
+        if (partitioned.globPatterns.length > 0 || partitioned.excludePatterns.length > 0) {
+            throw new Error('Glob patterns and exclusions are only supported for on-disk files.');
+        }
+        candidatePaths = await expandWithCustomFs(partitioned, fsModule);
+    }
+    if (candidatePaths.length === 0) {
+        throw new FileValidationError('No files matched the provided --file patterns.', {
+            patterns: partitioned.globPatterns,
+            excludes: partitioned.excludePatterns,
+        });
+    }
+    const oversized = [];
+    const accepted = [];
+    for (const filePath of candidatePaths) {
+        let stats;
+        try {
+            stats = await fsModule.stat(filePath);
+        }
+        catch (error) {
+            throw new FileValidationError(`Missing file or directory: ${relativePath(filePath, cwd)}`, { path: filePath }, error);
+        }
+        if (!stats.isFile()) {
+            continue;
+        }
+        if (maxFileSizeBytes && typeof stats.size === 'number' && stats.size > maxFileSizeBytes) {
+            const relative = path.relative(cwd, filePath) || filePath;
+            oversized.push(`${relative} (${formatBytes(stats.size)})`);
+            continue;
+        }
+        accepted.push(filePath);
+    }
+    if (oversized.length > 0) {
+        throw new FileValidationError(`The following files exceed the 1 MB limit:\n- ${oversized.join('\n- ')}`, {
+            files: oversized,
+            limitBytes: maxFileSizeBytes,
+        });
+    }
+    const files = [];
+    for (const filePath of accepted) {
+        const content = await fsModule.readFile(filePath, 'utf8');
+        files.push({ path: filePath, content });
+    }
+    return files;
+}
+async function partitionFileInputs(rawPaths, cwd, fsModule) {
+    const result = {
+        globPatterns: [],
+        excludePatterns: [],
+        literalFiles: [],
+        literalDirectories: [],
+    };
+    for (const entry of rawPaths) {
+        const raw = entry?.trim();
+        if (!raw) {
+            continue;
+        }
+        if (raw.startsWith('!')) {
+            const normalized = normalizeGlob(raw.slice(1), cwd);
+            if (normalized) {
+                result.excludePatterns.push(normalized);
+            }
+            continue;
+        }
+        if (fg.isDynamicPattern(raw)) {
+            result.globPatterns.push(normalizeGlob(raw, cwd));
+            continue;
+        }
+        const absolutePath = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+        let stats;
+        try {
+            stats = await fsModule.stat(absolutePath);
+        }
+        catch (error) {
+            throw new FileValidationError(`Missing file or directory: ${raw}`, { path: absolutePath }, error);
+        }
+        if (stats.isDirectory()) {
+            result.literalDirectories.push(absolutePath);
+        }
+        else if (stats.isFile()) {
+            result.literalFiles.push(absolutePath);
+        }
+        else {
+            throw new FileValidationError(`Not a file or directory: ${raw}`, { path: absolutePath });
+        }
+    }
+    return result;
+}
+async function expandWithNativeGlob(partitioned, cwd) {
+    const patterns = [
+        ...partitioned.globPatterns,
+        ...partitioned.literalFiles.map((absPath) => toPosixRelativeOrBasename(absPath, cwd)),
+        ...partitioned.literalDirectories.map((absDir) => makeDirectoryPattern(toPosixRelative(absDir, cwd))),
+    ].filter(Boolean);
+    if (patterns.length === 0) {
+        return [];
+    }
+    const matches = await fg(patterns, {
+        cwd,
+        absolute: true,
+        dot: true,
+        ignore: partitioned.excludePatterns,
+        onlyFiles: true,
+        followSymbolicLinks: false,
+    });
+    return Array.from(new Set(matches.map((match) => path.resolve(match))));
+}
+async function expandWithCustomFs(partitioned, fsModule) {
+    const paths = new Set();
+    partitioned.literalFiles.forEach((file) => {
+        paths.add(file);
+    });
+    for (const directory of partitioned.literalDirectories) {
+        const nested = await expandDirectoryRecursive(directory, fsModule);
+        nested.forEach((entry) => {
+            paths.add(entry);
+        });
+    }
+    return Array.from(paths);
+}
+async function expandDirectoryRecursive(directory, fsModule) {
+    const entries = await fsModule.readdir(directory);
+    const results = [];
+    for (const entry of entries) {
+        const childPath = path.join(directory, entry);
+        const stats = await fsModule.stat(childPath);
+        if (stats.isDirectory()) {
+            results.push(...(await expandDirectoryRecursive(childPath, fsModule)));
+        }
+        else if (stats.isFile()) {
+            results.push(childPath);
+        }
+    }
+    return results;
+}
+function makeDirectoryPattern(relative) {
+    if (relative === '.' || relative === '') {
+        return '**/*';
+    }
+    return `${stripTrailingSlashes(relative)}/**/*`;
+}
+function normalizeGlob(pattern, cwd) {
+    if (!pattern) {
+        return '';
+    }
+    let normalized = pattern;
+    if (path.isAbsolute(normalized)) {
+        normalized = path.relative(cwd, normalized);
+    }
+    normalized = toPosix(normalized);
+    if (normalized.startsWith('./')) {
+        normalized = normalized.slice(2);
+    }
+    return normalized;
+}
+function toPosix(value) {
+    return value.replace(/\\/g, '/');
+}
+function toPosixRelative(absPath, cwd) {
+    const relative = path.relative(cwd, absPath);
+    if (!relative) {
+        return '.';
+    }
+    return toPosix(relative);
+}
+function toPosixRelativeOrBasename(absPath, cwd) {
+    const relative = path.relative(cwd, absPath);
+    return toPosix(relative || path.basename(absPath));
+}
+function stripTrailingSlashes(value) {
+    const normalized = toPosix(value);
+    return normalized.replace(/\/+$/g, '');
+}
+function formatBytes(size) {
+    if (size >= 1024 * 1024) {
+        return `${(size / (1024 * 1024)).toFixed(1)} MB`;
+    }
+    if (size >= 1024) {
+        return `${(size / 1024).toFixed(1)} KB`;
+    }
+    return `${size} B`;
+}
+function relativePath(targetPath, cwd) {
+    const relative = path.relative(cwd, targetPath);
+    return relative || targetPath;
+}
+export function createFileSections(files, cwd = process.cwd()) {
+    return files.map((file, index) => {
+        const relative = path.relative(cwd, file.path) || file.path;
+        const sectionText = [
+            `### File ${index + 1}: ${relative}`,
+            '```',
+            file.content.trimEnd(),
+            '```',
+        ].join('\n');
+        return {
+            index: index + 1,
+            absolutePath: file.path,
+            displayPath: relative,
+            sectionText,
+            content: file.content,
+        };
+    });
+}

package/dist/oracle/src/oracle/format.js

@@ -0,0 +1,33 @@
+export function formatUSD(value) {
+    if (!Number.isFinite(value)) {
+        return 'n/a';
+    }
+    if (value >= 0.1) {
+        return `$${value.toFixed(2)}`;
+    }
+    if (value >= 0.01) {
+        return `$${value.toFixed(3)}`;
+    }
+    return `$${value.toFixed(6)}`;
+}
+export function formatNumber(value, { estimated = false } = {}) {
+    if (value == null) {
+        return 'n/a';
+    }
+    const suffix = estimated ? ' (est.)' : '';
+    return `${value.toLocaleString()}${suffix}`;
+}
+export function formatElapsed(ms) {
+    const totalSeconds = ms / 1000;
+    if (totalSeconds < 60) {
+        return `${totalSeconds.toFixed(2)}s`;
+    }
+    const minutes = Math.floor(totalSeconds / 60);
+    let seconds = Math.round(totalSeconds - minutes * 60);
+    let adjustedMinutes = minutes;
+    if (seconds === 60) {
+        adjustedMinutes += 1;
+        seconds = 0;
+    }
+    return `${adjustedMinutes}m ${seconds}s`;
+}

package/dist/oracle/src/oracle/fsAdapter.js

@@ -0,0 +1,7 @@
+export function createFsAdapter(fsModule) {
+    return {
+        stat: (targetPath) => fsModule.stat(targetPath),
+        readdir: (targetPath) => fsModule.readdir(targetPath),
+        readFile: (targetPath, encoding) => fsModule.readFile(targetPath, encoding),
+    };
+}

package/dist/oracle/src/oracle/oscProgress.js

@@ -0,0 +1,60 @@
+import process from 'node:process';
+const OSC = '\u001b]9;4;';
+const ST = '\u001b\\';
+function sanitizeLabel(label) {
+    const withoutEscape = label.split('\u001b').join('');
+    const withoutBellAndSt = withoutEscape.replaceAll('\u0007', '').replaceAll('\u009c', '');
+    return withoutBellAndSt.replaceAll(']', '').trim();
+}
+export function supportsOscProgress(env = process.env, isTty = process.stdout.isTTY) {
+    if (!isTty) {
+        return false;
+    }
+    if (env.ORACLE_NO_OSC_PROGRESS === '1') {
+        return false;
+    }
+    if (env.ORACLE_FORCE_OSC_PROGRESS === '1') {
+        return true;
+    }
+    const termProgram = (env.TERM_PROGRAM ?? '').toLowerCase();
+    if (termProgram.includes('ghostty')) {
+        return true;
+    }
+    if (termProgram.includes('wezterm')) {
+        return true;
+    }
+    if (env.WT_SESSION) {
+        return true; // Windows Terminal exposes this
+    }
+    return false;
+}
+export function startOscProgress(options = {}) {
+    const { label = 'Waiting for OpenAI', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text) } = options;
+    if (!supportsOscProgress(options.env, options.isTty)) {
+        return () => { };
+    }
+    const cleanLabel = sanitizeLabel(label);
+    const target = Math.max(targetMs, 1_000);
+    const send = (state, percent) => {
+        const clamped = Math.max(0, Math.min(100, Math.round(percent)));
+        write(`${OSC}${state};${clamped};${cleanLabel}${ST}`);
+    };
+    const startedAt = Date.now();
+    send(1, 0); // activate progress bar
+    const timer = setInterval(() => {
+        const elapsed = Date.now() - startedAt;
+        const percent = Math.min(99, (elapsed / target) * 100);
+        send(1, percent);
+    }, 900);
+    timer.unref?.();
+    let stopped = false;
+    return () => {
+        // biome-ignore lint/nursery/noUnnecessaryConditions: multiple callers may try to stop
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        clearInterval(timer);
+        send(0, 0); // clear the progress bar
+    };
+}

package/dist/oracle/src/oracle/request.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs/promises';
+import { DEFAULT_SYSTEM_PROMPT } from './config.js';
+import { createFileSections, readFiles } from './files.js';
+import { createFsAdapter } from './fsAdapter.js';
+export function buildPrompt(basePrompt, files, cwd = process.cwd()) {
+    if (!files.length) {
+        return basePrompt;
+    }
+    const sections = createFileSections(files, cwd);
+    const sectionText = sections.map((section) => section.sectionText).join('\n\n');
+    return `${basePrompt.trim()}\n\n${sectionText}`;
+}
+export function buildRequestBody({ modelConfig, systemPrompt, userPrompt, searchEnabled, maxOutputTokens, background, storeResponse, }) {
+    return {
+        model: modelConfig.model,
+        instructions: systemPrompt,
+        input: [
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'input_text',
+                        text: userPrompt,
+                    },
+                ],
+            },
+        ],
+        tools: searchEnabled ? [{ type: 'web_search_preview' }] : undefined,
+        reasoning: modelConfig.reasoning || undefined,
+        max_output_tokens: maxOutputTokens,
+        background: background ? true : undefined,
+        store: storeResponse ? true : undefined,
+    };
+}
+export async function renderPromptMarkdown(options, deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const fsModule = deps.fs ?? createFsAdapter(fs);
+    const files = await readFiles(options.file ?? [], { cwd, fsModule });
+    const sections = createFileSections(files, cwd);
+    const systemPrompt = options.system?.trim() || DEFAULT_SYSTEM_PROMPT;
+    const userPrompt = (options.prompt ?? '').trim();
+    const lines = ['[SYSTEM]', systemPrompt, ''];
+    lines.push('[USER]', userPrompt, '');
+    sections.forEach((section) => {
+        lines.push(`[FILE: ${section.displayPath}]`, section.content.trimEnd(), '');
+    });
+    return lines.join('\n');
+}