@steipete/oracle 1.1.0 → 1.3.0

package/dist/src/oracle/files.js

@@ -4,12 +4,13 @@ import fg from 'fast-glob';
 import { FileValidationError } from './errors.js';
 const MAX_FILE_SIZE_BYTES = 1 * 1024 * 1024; // 1 MB
 const DEFAULT_FS = fs;
+const DEFAULT_IGNORED_DIRS = ['node_modules', 'dist', 'coverage', '.git', '.turbo', '.next', 'build', 'tmp'];
 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;
+    const useNativeFilesystem = fsModule === DEFAULT_FS || isNativeFsModule(fsModule);
     let candidatePaths = [];
     if (useNativeFilesystem) {
         candidatePaths = await expandWithNativeGlob(partitioned, cwd);
@@ -20,7 +21,28 @@ export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEF
         }
         candidatePaths = await expandWithCustomFs(partitioned, fsModule);
     }
-    if (candidatePaths.length === 0) {
+    const allowedLiteralDirs = partitioned.literalDirectories
+        .map((dir) => path.resolve(dir))
+        .filter((dir) => DEFAULT_IGNORED_DIRS.includes(path.basename(dir)));
+    const allowedLiteralFiles = partitioned.literalFiles.map((file) => path.resolve(file));
+    const resolvedLiteralDirs = new Set(allowedLiteralDirs);
+    const allowedPaths = new Set([...allowedLiteralDirs, ...allowedLiteralFiles]);
+    const ignoredWhitelist = await buildIgnoredWhitelist(candidatePaths, cwd, fsModule);
+    const ignoredLog = new Set();
+    const filteredCandidates = candidatePaths.filter((filePath) => {
+        const ignoredDir = findIgnoredAncestor(filePath, cwd, resolvedLiteralDirs, allowedPaths, ignoredWhitelist);
+        if (!ignoredDir) {
+            return true;
+        }
+        const displayFile = relativePath(filePath, cwd);
+        const key = `${ignoredDir}|${displayFile}`;
+        if (!ignoredLog.has(key)) {
+            console.log(`Skipping default-ignored path: ${displayFile} (matches ${ignoredDir})`);
+            ignoredLog.add(key);
+        }
+        return false;
+    });
+    if (filteredCandidates.length === 0) {
         throw new FileValidationError('No files matched the provided --file patterns.', {
             patterns: partitioned.globPatterns,
             excludes: partitioned.excludePatterns,
@@ -28,7 +50,7 @@ export async function readFiles(filePaths, { cwd = process.cwd(), fsModule = DEF
     }
     const oversized = [];
     const accepted = [];
-    for (const filePath of candidatePaths) {
+    for (const filePath of filteredCandidates) {
         let stats;
         try {
             stats = await fsModule.stat(filePath);
@@ -111,15 +133,130 @@ async function expandWithNativeGlob(partitioned, cwd) {
     if (patterns.length === 0) {
         return [];
     }
-    const matches = await fg(patterns, {
+    const dotfileOptIn = patterns.some((pattern) => includesDotfileSegment(pattern));
+    const gitignoreSets = await loadGitignoreSets(cwd);
+    const matches = (await fg(patterns, {
         cwd,
-        absolute: true,
+        absolute: false,
         dot: true,
         ignore: partitioned.excludePatterns,
         onlyFiles: true,
         followSymbolicLinks: false,
-    });
-    return Array.from(new Set(matches.map((match) => path.resolve(match))));
+    }));
+    const resolved = matches.map((match) => path.resolve(cwd, match));
+    const filtered = resolved.filter((filePath) => !isGitignored(filePath, gitignoreSets));
+    const finalFiles = dotfileOptIn ? filtered : filtered.filter((filePath) => !path.basename(filePath).startsWith('.'));
+    return Array.from(new Set(finalFiles));
+}
+async function loadGitignoreSets(cwd) {
+    const gitignorePaths = await fg('**/.gitignore', { cwd, dot: true, absolute: true, onlyFiles: true, followSymbolicLinks: false });
+    const sets = [];
+    for (const filePath of gitignorePaths) {
+        try {
+            const raw = await fs.readFile(filePath, 'utf8');
+            const patterns = raw
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith('#'));
+            if (patterns.length > 0) {
+                sets.push({ dir: path.dirname(filePath), patterns });
+            }
+        }
+        catch {
+            // Ignore unreadable .gitignore files
+        }
+    }
+    // Ensure deterministic parent-before-child ordering
+    return sets.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+function isGitignored(filePath, sets) {
+    for (const { dir, patterns } of sets) {
+        if (!filePath.startsWith(dir)) {
+            continue;
+        }
+        const relative = path.relative(dir, filePath) || path.basename(filePath);
+        if (matchesAny(relative, patterns)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function buildIgnoredWhitelist(filePaths, cwd, fsModule) {
+    const whitelist = new Set();
+    for (const filePath of filePaths) {
+        const absolute = path.resolve(filePath);
+        const rel = path.relative(cwd, absolute);
+        const parts = rel.split(path.sep).filter(Boolean);
+        for (let i = 0; i < parts.length - 1; i += 1) {
+            const part = parts[i];
+            if (!DEFAULT_IGNORED_DIRS.includes(part)) {
+                continue;
+            }
+            const dirPath = path.resolve(cwd, ...parts.slice(0, i + 1));
+            if (whitelist.has(dirPath)) {
+                continue;
+            }
+            try {
+                const stats = await fsModule.stat(path.join(dirPath, '.gitignore'));
+                if (stats.isFile()) {
+                    whitelist.add(dirPath);
+                }
+            }
+            catch {
+                // no .gitignore at this level; keep ignored
+            }
+        }
+    }
+    return whitelist;
+}
+function findIgnoredAncestor(filePath, cwd, _literalDirs, allowedPaths, ignoredWhitelist) {
+    const absolute = path.resolve(filePath);
+    if (Array.from(allowedPaths).some((allowed) => absolute === allowed || absolute.startsWith(`${allowed}${path.sep}`))) {
+        return null; // explicitly requested path overrides default ignore when the ignored dir itself was passed
+    }
+    const rel = path.relative(cwd, absolute);
+    const parts = rel.split(path.sep);
+    for (let idx = 0; idx < parts.length; idx += 1) {
+        const part = parts[idx];
+        if (!DEFAULT_IGNORED_DIRS.includes(part)) {
+            continue;
+        }
+        const ignoredDir = path.resolve(cwd, parts.slice(0, idx + 1).join(path.sep));
+        if (ignoredWhitelist.has(ignoredDir)) {
+            continue;
+        }
+        return part;
+    }
+    return null;
+}
+function matchesAny(relativePath, patterns) {
+    return patterns.some((pattern) => matchesPattern(relativePath, pattern));
+}
+function matchesPattern(relativePath, pattern) {
+    if (!pattern) {
+        return false;
+    }
+    const normalized = pattern.replace(/\\+/g, '/');
+    // Directory rule
+    if (normalized.endsWith('/')) {
+        const dir = normalized.slice(0, -1);
+        return relativePath === dir || relativePath.startsWith(`${dir}/`);
+    }
+    // Simple glob support (* and **)
+    const regex = globToRegex(normalized);
+    return regex.test(relativePath);
+}
+function globToRegex(pattern) {
+    const withMarkers = pattern.replace(/\*\*/g, '§§DOUBLESTAR§§').replace(/\*/g, '§§SINGLESTAR§§');
+    const escaped = withMarkers.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    const restored = escaped
+        .replace(/§§DOUBLESTAR§§/g, '.*')
+        .replace(/§§SINGLESTAR§§/g, '[^/]*');
+    return new RegExp(`^${restored}$`);
+}
+function includesDotfileSegment(pattern) {
+    const segments = pattern.split('/');
+    return segments.some((segment) => segment.startsWith('.') && segment.length > 1);
 }
 async function expandWithCustomFs(partitioned, fsModule) {
     const paths = new Set();
@@ -155,6 +292,12 @@ function makeDirectoryPattern(relative) {
     }
     return `${stripTrailingSlashes(relative)}/**/*`;
 }
+function isNativeFsModule(fsModule) {
+    return ((fsModule.__nativeFs === true ||
+        (fsModule.readFile === DEFAULT_FS.readFile &&
+            fsModule.stat === DEFAULT_FS.stat &&
+            fsModule.readdir === DEFAULT_FS.readdir)));
+}
 function normalizeGlob(pattern, cwd) {
     if (!pattern) {
         return '';
@@ -202,7 +345,7 @@ function relativePath(targetPath, cwd) {
 }
 export function createFileSections(files, cwd = process.cwd()) {
     return files.map((file, index) => {
-        const relative = path.relative(cwd, file.path) || file.path;
+        const relative = toPosix(path.relative(cwd, file.path) || file.path);
         const sectionText = [
             `### File ${index + 1}: ${relative}`,
             '```',

package/dist/src/oracle/format.js

@@ -2,13 +2,8 @@ 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)}`;
+    // Display with 4 decimal places, rounding to $0.0001 minimum granularity.
+    return `$${value.toFixed(4)}`;
 }
 export function formatNumber(value, { estimated = false } = {}) {
     if (value == null) {

package/dist/src/oracle/fsAdapter.js

@@ -1,7 +1,10 @@
 export function createFsAdapter(fsModule) {
-    return {
+    const adapter = {
         stat: (targetPath) => fsModule.stat(targetPath),
         readdir: (targetPath) => fsModule.readdir(targetPath),
         readFile: (targetPath, encoding) => fsModule.readFile(targetPath, encoding),
     };
+    // Mark adapters so downstream callers can treat them as native filesystem access.
+    adapter.__nativeFs = true;
+    return adapter;
 }

package/dist/src/oracle/gemini.js

@@ -0,0 +1,161 @@
+import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold, } from '@google/generative-ai';
+const MODEL_ID_MAP = {
+    'gemini-3-pro': 'gemini-3-pro-preview',
+    'gpt-5-pro': 'gpt-5-pro', // unused, normalize TS map
+    'gpt-5.1': 'gpt-5.1',
+};
+export function resolveGeminiModelId(modelName) {
+    // Map our logical Gemini names to the exact model ids expected by the SDK.
+    return MODEL_ID_MAP[modelName] ?? modelName;
+}
+export function createGeminiClient(apiKey, modelName = 'gemini-3-pro', resolvedModelId) {
+    const genAI = new GoogleGenerativeAI(apiKey);
+    const modelId = resolvedModelId ?? resolveGeminiModelId(modelName);
+    const model = genAI.getGenerativeModel({ model: modelId });
+    const adaptBodyToGemini = (body) => {
+        const contents = body.input.map((inputItem) => ({
+            role: inputItem.role === 'user' ? 'user' : 'model',
+            parts: inputItem.content
+                .map((contentPart) => {
+                if (contentPart.type === 'input_text') {
+                    return { text: contentPart.text };
+                }
+                return null;
+            })
+                .filter((part) => part !== null),
+        }));
+        const tools = body.tools
+            ?.map((tool) => {
+            if (tool.type === 'web_search_preview') {
+                return {
+                    googleSearch: {},
+                };
+            }
+            return {};
+        })
+            .filter((t) => Object.keys(t).length > 0);
+        const generationConfig = {
+            maxOutputTokens: body.max_output_tokens,
+        };
+        const safetySettings = [
+            {
+                category: HarmCategory.HARM_CATEGORY_HARASSMENT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+            {
+                category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+                threshold: HarmBlockThreshold.BLOCK_NONE,
+            },
+        ];
+        const systemInstruction = body.instructions || undefined;
+        return { systemInstruction, contents, tools, generationConfig, safetySettings };
+    };
+    const adaptGeminiResponseToOracle = (geminiResponse) => {
+        const outputText = [];
+        const output = [];
+        geminiResponse.candidates?.forEach((candidate) => {
+            candidate.content?.parts?.forEach((part) => {
+                if (part.text) {
+                    outputText.push(part.text);
+                    output.push({ type: 'text', text: part.text });
+                }
+            });
+        });
+        const usage = {
+            input_tokens: geminiResponse.usageMetadata?.promptTokenCount || 0,
+            output_tokens: geminiResponse.usageMetadata?.candidatesTokenCount || 0,
+            total_tokens: (geminiResponse.usageMetadata?.promptTokenCount || 0) + (geminiResponse.usageMetadata?.candidatesTokenCount || 0),
+        };
+        return {
+            id: `gemini-${Date.now()}`, // Gemini doesn't always provide a stable ID in the response object
+            status: 'completed',
+            output_text: outputText,
+            output,
+            usage,
+        };
+    };
+    const enrichGeminiError = (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('404')) {
+            return new Error(`Gemini model not available to this API key/region. Confirm preview access and model ID (${modelId}). Original: ${message}`);
+        }
+        return error instanceof Error ? error : new Error(message);
+    };
+    return {
+        responses: {
+            stream: (body) => {
+                const geminiBody = adaptBodyToGemini(body);
+                let finalResponsePromise = null;
+                const collectChunkText = (chunk) => {
+                    const parts = [];
+                    chunk.candidates?.forEach((candidate) => {
+                        candidate.content?.parts?.forEach((part) => {
+                            if (part.text) {
+                                parts.push(part.text);
+                            }
+                        });
+                    });
+                    return parts.join('');
+                };
+                async function* iterator() {
+                    let streamingResp;
+                    try {
+                        streamingResp = await model.generateContentStream(geminiBody);
+                    }
+                    catch (error) {
+                        throw enrichGeminiError(error);
+                    }
+                    for await (const chunk of streamingResp.stream) {
+                        const text = collectChunkText(chunk);
+                        if (text) {
+                            yield { type: 'chunk', delta: text };
+                        }
+                    }
+                    finalResponsePromise = streamingResp.response.then(adaptGeminiResponseToOracle);
+                }
+                const generator = iterator();
+                return {
+                    [Symbol.asyncIterator]: () => generator,
+                    finalResponse: async () => {
+                        // Ensure the stream has been consumed or at least started to get the promise
+                        if (!finalResponsePromise) {
+                            // In case the user calls finalResponse before iterating, we need to consume the stream
+                            // This is a bit edge-casey but safe.
+                            for await (const _ of generator) { }
+                        }
+                        if (!finalResponsePromise) {
+                            throw new Error('Response promise not initialized');
+                        }
+                        return finalResponsePromise;
+                    }
+                };
+            },
+            create: async (body) => {
+                const geminiBody = adaptBodyToGemini(body);
+                let result;
+                try {
+                    result = await model.generateContent(geminiBody);
+                }
+                catch (error) {
+                    throw enrichGeminiError(error);
+                }
+                return adaptGeminiResponseToOracle(result.response);
+            },
+            retrieve: async (id) => {
+                return {
+                    id,
+                    status: 'error',
+                    error: { message: 'Retrieve by ID not supported for Gemini API yet.' },
+                };
+            },
+        },
+    };
+}

package/dist/src/oracle/logging.js

@@ -0,0 +1,36 @@
+export function maskApiKey(key) {
+    if (!key)
+        return null;
+    if (key.length <= 8)
+        return `${key[0] ?? ''}***${key[key.length - 1] ?? ''}`;
+    const prefix = key.slice(0, 4);
+    const suffix = key.slice(-4);
+    return `${prefix}****${suffix}`;
+}
+export function formatBaseUrlForLog(raw) {
+    if (!raw)
+        return '';
+    try {
+        const parsed = new URL(raw);
+        const segments = parsed.pathname.split('/').filter(Boolean);
+        let path = '';
+        if (segments.length > 0) {
+            path = `/${segments[0]}`;
+            if (segments.length > 1) {
+                path += '/...';
+            }
+        }
+        const allowedQueryKeys = ['api-version'];
+        const maskedQuery = allowedQueryKeys
+            .filter((key) => parsed.searchParams.has(key))
+            .map((key) => `${key}=***`);
+        const query = maskedQuery.length > 0 ? `?${maskedQuery.join('&')}` : '';
+        return `${parsed.protocol}//${parsed.host}${path}${query}`;
+    }
+    catch {
+        const trimmed = raw.trim();
+        if (trimmed.length <= 64)
+            return trimmed;
+        return `${trimmed.slice(0, 32)}…${trimmed.slice(-8)}`;
+    }
+}

package/dist/src/oracle/oscProgress.js

@@ -29,11 +29,17 @@ export function supportsOscProgress(env = process.env, isTty = process.stdout.is
     return false;
 }
 export function startOscProgress(options = {}) {
-    const { label = 'Waiting for OpenAI', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text) } = options;
+    const { label = 'Waiting for API', targetMs = 10 * 60_000, write = (text) => process.stdout.write(text), indeterminate = false, } = options;
     if (!supportsOscProgress(options.env, options.isTty)) {
         return () => { };
     }
     const cleanLabel = sanitizeLabel(label);
+    if (indeterminate) {
+        write(`${OSC}3;;${cleanLabel}${ST}`);
+        return () => {
+            write(`${OSC}0;0;${cleanLabel}${ST}`);
+        };
+    }
     const target = Math.max(targetMs, 1_000);
     const send = (state, percent) => {
         const clamped = Math.max(0, Math.min(100, Math.round(percent)));