@steipete/oracle 1.0.8 → 1.2.0

package/dist/src/mcp/tools/sessionResources.js

@@ -0,0 +1,64 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import fs from 'node:fs/promises';
+import { getSessionPaths, readSessionLog, readSessionMetadata } from '../../sessionManager.js';
+// URIs:
+// - oracle-session://<id>/metadata
+// - oracle-session://<id>/log
+// - oracle-session://<id>/request
+export function registerSessionResources(server) {
+    const template = new ResourceTemplate('oracle-session://{id}/{kind}', { list: undefined });
+    server.registerResource('oracle-session', template, {
+        title: 'oracle session resources',
+        description: 'Read stored session metadata, log, or request payload.',
+    }, async (uri, variables) => {
+        const idRaw = variables?.id;
+        const kindRaw = variables?.kind;
+        // uri-template variables arrive as string | string[]; collapse to first value.
+        const id = Array.isArray(idRaw) ? idRaw[0] : idRaw;
+        const kind = Array.isArray(kindRaw) ? kindRaw[0] : kindRaw;
+        if (!id || !kind) {
+            throw new Error('Missing id or kind');
+        }
+        const paths = await getSessionPaths(id);
+        switch (kind) {
+            case 'metadata': {
+                const metadata = await readSessionMetadata(id);
+                if (!metadata) {
+                    throw new Error(`Session "${id}" not found.`);
+                }
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: JSON.stringify(metadata, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'log': {
+                const log = await readSessionLog(id);
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: log,
+                        },
+                    ],
+                };
+            }
+            case 'request': {
+                const raw = await fs.readFile(paths.request, 'utf8');
+                return {
+                    contents: [
+                        {
+                            uri: uri.href,
+                            text: raw,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unsupported resource kind: ${kind}`);
+        }
+    });
+}

package/dist/src/mcp/tools/sessions.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs/promises';
+import { z } from 'zod';
+import { filterSessionsByRange, getSessionPaths, listSessionsMetadata, readSessionLog, readSessionMetadata, } from '../../sessionManager.js';
+import { sessionsInputSchema } from '../types.js';
+const sessionsInputShape = {
+    id: z.string().optional(),
+    hours: z.number().optional(),
+    limit: z.number().optional(),
+    includeAll: z.boolean().optional(),
+    detail: z.boolean().optional(),
+};
+const sessionsOutputShape = {
+    entries: z
+        .array(z.object({
+        id: z.string(),
+        createdAt: z.string(),
+        status: z.string(),
+        model: z.string().optional(),
+        mode: z.string().optional(),
+    }))
+        .optional(),
+    total: z.number().optional(),
+    truncated: z.boolean().optional(),
+    session: z
+        .object({
+        metadata: z.record(z.string(), z.any()),
+        log: z.string(),
+        request: z.record(z.string(), z.any()).optional(),
+    })
+        .optional(),
+};
+export function registerSessionsTool(server) {
+    server.registerTool('sessions', {
+        title: 'List or fetch oracle sessions',
+        description: 'List stored sessions (same defaults as `oracle status`) or, with id/slug, return a summary row. Pass detail:true to include metadata, log, and stored request for that session.',
+        inputSchema: sessionsInputShape,
+        outputSchema: sessionsOutputShape,
+    }, async (input) => {
+        const textContent = (text) => [{ type: 'text', text }];
+        const { id, hours = 24, limit = 100, includeAll = false, detail = false } = sessionsInputSchema.parse(input);
+        if (id) {
+            if (!detail) {
+                const metadata = await readSessionMetadata(id);
+                if (!metadata) {
+                    throw new Error(`Session "${id}" not found.`);
+                }
+                return {
+                    content: textContent(`${metadata.createdAt} | ${metadata.status} | ${metadata.model ?? 'n/a'} | ${metadata.id}`),
+                    structuredContent: {
+                        entries: [
+                            {
+                                id: metadata.id,
+                                createdAt: metadata.createdAt,
+                                status: metadata.status,
+                                model: metadata.model,
+                                mode: metadata.mode,
+                            },
+                        ],
+                        total: 1,
+                        truncated: false,
+                    },
+                };
+            }
+            const metadata = await readSessionMetadata(id);
+            if (!metadata) {
+                throw new Error(`Session "${id}" not found.`);
+            }
+            const log = await readSessionLog(id);
+            let request;
+            try {
+                const paths = await getSessionPaths(id);
+                const raw = await fs.readFile(paths.request, 'utf8');
+                // Old sessions may lack a request payload; treat it as best-effort metadata.
+                request = JSON.parse(raw);
+            }
+            catch {
+                request = undefined;
+            }
+            return {
+                content: textContent(log),
+                structuredContent: { session: { metadata, log, request } },
+            };
+        }
+        const metas = await listSessionsMetadata();
+        const { entries, truncated, total } = filterSessionsByRange(metas, { hours, includeAll, limit });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: entries.map((entry) => `${entry.createdAt} | ${entry.status} | ${entry.model ?? 'n/a'} | ${entry.id}`).join('\n'),
+                },
+            ],
+            structuredContent: {
+                entries: entries.map((entry) => ({
+                    id: entry.id,
+                    createdAt: entry.createdAt,
+                    status: entry.status,
+                    model: entry.model,
+                    mode: entry.mode,
+                })),
+                total,
+                truncated,
+            },
+        };
+    });
+}

package/dist/src/mcp/types.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export const consultInputSchema = z.object({
+    prompt: z.string().min(1, 'Prompt is required.'),
+    files: z.array(z.string()).default([]),
+    model: z.string().optional(),
+    engine: z.enum(['api', 'browser']).optional(),
+    browserModelLabel: z.string().optional(),
+    search: z.boolean().optional(),
+    slug: z.string().optional(),
+});
+export const sessionsInputSchema = z.object({
+    id: z.string().optional(),
+    hours: z.number().optional(),
+    limit: z.number().optional(),
+    includeAll: z.boolean().optional(),
+    detail: z.boolean().optional(),
+});

package/dist/src/mcp/utils.js

@@ -0,0 +1,24 @@
+import { resolveRunOptionsFromConfig } from '../cli/runOptions.js';
+import { Launcher } from 'chrome-launcher';
+export function mapConsultToRunOptions({ prompt, files, model, engine, search, userConfig, env = process.env, }) {
+    // Normalize CLI-style inputs through the shared resolver so config/env defaults apply,
+    // then overlay MCP-only overrides such as explicit search toggles.
+    const result = resolveRunOptionsFromConfig({ prompt, files, model, engine, userConfig, env });
+    if (typeof search === 'boolean') {
+        result.runOptions.search = search;
+    }
+    return result;
+}
+export function ensureBrowserAvailable(engine) {
+    if (engine !== 'browser') {
+        return null;
+    }
+    if (process.env.CHROME_PATH) {
+        return null;
+    }
+    const found = Launcher.getFirstInstallation();
+    if (!found) {
+        return 'Browser engine unavailable: no Chrome installation found and CHROME_PATH is unset.';
+    }
+    return null;
+}

package/dist/src/oracle/files.js

@@ -4,6 +4,7 @@ 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 [];
@@ -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();

package/dist/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
+    };
+}