@indykish/oracle 0.9.0

package/dist/src/cli/options.js

@@ -0,0 +1,281 @@
+import { InvalidArgumentError } from 'commander';
+import { parseDuration } from '../browserMode.js';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { DEFAULT_MODEL, MODEL_CONFIGS } from '../oracle.js';
+export function collectPaths(value, previous = []) {
+    if (!value) {
+        return previous;
+    }
+    const nextValues = Array.isArray(value) ? value : [value];
+    return previous.concat(nextValues.flatMap((entry) => entry.split(',')).map((entry) => entry.trim()).filter(Boolean));
+}
+/**
+ * Merge all path-like CLI inputs (file/include aliases) into a single list, preserving order.
+ */
+export function mergePathLikeOptions(file, include, filesAlias, pathAlias, pathsAlias) {
+    const withFile = collectPaths(file, []);
+    const withInclude = collectPaths(include, withFile);
+    const withFilesAlias = collectPaths(filesAlias, withInclude);
+    const withPathAlias = collectPaths(pathAlias, withFilesAlias);
+    return collectPaths(pathsAlias, withPathAlias);
+}
+export function dedupePathInputs(inputs, { cwd = process.cwd() } = {}) {
+    const deduped = [];
+    const duplicates = [];
+    const seen = new Set();
+    for (const entry of inputs ?? []) {
+        const raw = entry?.trim();
+        if (!raw)
+            continue;
+        let key = raw;
+        if (!raw.startsWith('!') && !fg.isDynamicPattern(raw)) {
+            const absolute = path.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+            key = `path:${path.normalize(absolute)}`;
+        }
+        else {
+            key = `pattern:${raw}`;
+        }
+        if (seen.has(key)) {
+            duplicates.push(raw);
+            continue;
+        }
+        seen.add(key);
+        deduped.push(raw);
+    }
+    return { deduped, duplicates };
+}
+export function collectModelList(value, previous = []) {
+    if (!value) {
+        return previous;
+    }
+    const entries = value
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return previous.concat(entries);
+}
+export function parseFloatOption(value) {
+    const parsed = Number.parseFloat(value);
+    if (Number.isNaN(parsed)) {
+        throw new InvalidArgumentError('Value must be a number.');
+    }
+    return parsed;
+}
+export function parseIntOption(value) {
+    if (value == null) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new InvalidArgumentError('Value must be an integer.');
+    }
+    return parsed;
+}
+export function parseHeartbeatOption(value) {
+    if (value == null) {
+        return 30;
+    }
+    if (typeof value === 'number') {
+        if (Number.isNaN(value) || value < 0) {
+            throw new InvalidArgumentError('Heartbeat interval must be zero or a positive number.');
+        }
+        return value;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return 30;
+    }
+    if (normalized === 'false' || normalized === 'off') {
+        return 0;
+    }
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed < 0) {
+        throw new InvalidArgumentError('Heartbeat interval must be zero or a positive number.');
+    }
+    return parsed;
+}
+export function usesDefaultStatusFilters(cmd) {
+    const hoursSource = cmd.getOptionValueSource?.('hours') ?? 'default';
+    const limitSource = cmd.getOptionValueSource?.('limit') ?? 'default';
+    const allSource = cmd.getOptionValueSource?.('all') ?? 'default';
+    return hoursSource === 'default' && limitSource === 'default' && allSource === 'default';
+}
+export function resolvePreviewMode(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (value === true) {
+        return 'summary';
+    }
+    return undefined;
+}
+export function parseSearchOption(value) {
+    const normalized = value.trim().toLowerCase();
+    if (['on', 'true', '1', 'yes'].includes(normalized)) {
+        return true;
+    }
+    if (['off', 'false', '0', 'no'].includes(normalized)) {
+        return false;
+    }
+    throw new InvalidArgumentError('Search mode must be "on" or "off".');
+}
+export function normalizeModelOption(value) {
+    return (value ?? '').trim();
+}
+export function normalizeBaseUrl(value) {
+    const trimmed = value?.trim();
+    return trimmed?.length ? trimmed : undefined;
+}
+export function parseTimeoutOption(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'auto')
+        return 'auto';
+    const parsed = Number.parseFloat(normalized);
+    if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError('Timeout must be a positive number of seconds or "auto".');
+    }
+    return parsed;
+}
+export function parseDurationOption(value, label) {
+    if (value == null)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new InvalidArgumentError(`${label} must be a duration like 30m, 10s, 500ms, or 2h.`);
+    }
+    const parsed = parseDuration(trimmed, Number.NaN);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new InvalidArgumentError(`${label} must be a positive duration like 30m, 10s, 500ms, or 2h.`);
+    }
+    return parsed;
+}
+export function resolveApiModel(modelValue) {
+    const normalized = normalizeModelOption(modelValue).toLowerCase();
+    if (normalized in MODEL_CONFIGS) {
+        return normalized;
+    }
+    if (normalized.includes('grok')) {
+        return normalized.includes('4.2') || normalized.includes('4-2') ? 'grok-4.2' : 'grok-4.1';
+    }
+    if (normalized.includes('claude') && normalized.includes('sonnet')) {
+        if (normalized.includes('4.6') || normalized.includes('4-6')) {
+            return 'claude-4.6-sonnet';
+        }
+        return 'claude-4.5-sonnet';
+    }
+    if (normalized.includes('claude') && normalized.includes('opus')) {
+        if (normalized.includes('4.6') || normalized.includes('4-6')) {
+            return 'claude-4.6-opus';
+        }
+        return 'claude-4.1-opus';
+    }
+    if (normalized === 'claude' || normalized === 'sonnet' || /(^|\b)sonnet(\b|$)/.test(normalized)) {
+        return 'claude-4.6-sonnet';
+    }
+    if (normalized === 'opus' || normalized === 'claude-4.1') {
+        return 'claude-4.1-opus';
+    }
+    if (normalized.includes('gemini')) {
+        return normalized.includes('3.5') || normalized.includes('3-5') ? 'gemini-3.5-pro' : 'gemini-3-pro';
+    }
+    if (normalized.includes('5.0') || normalized === 'gpt-5-pro' || normalized === 'gpt-5') {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('5.3') && normalized.includes('pro')) {
+        return 'gpt-5.3-pro';
+    }
+    if (normalized.includes('5.3')) {
+        return 'gpt-5.3';
+    }
+    if (normalized.includes('5-pro') && !normalized.includes('5.1')) {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('5.2') && normalized.includes('pro')) {
+        return 'gpt-5.2-pro';
+    }
+    if (normalized.includes('5.1') && normalized.includes('pro')) {
+        return 'gpt-5.1-pro';
+    }
+    if (normalized.includes('codex')) {
+        if (normalized.includes('max')) {
+            throw new InvalidArgumentError('gpt-5.1-codex-max is not available yet. OpenAI has not released the API.');
+        }
+        return 'gpt-5.1-codex';
+    }
+    if (normalized.includes('pro')) {
+        return 'gpt-5.3-pro';
+    }
+    // Passthrough for custom/OpenRouter model IDs.
+    return normalized;
+}
+export function inferModelFromLabel(modelValue) {
+    const normalized = normalizeModelOption(modelValue).toLowerCase();
+    if (!normalized) {
+        return DEFAULT_MODEL;
+    }
+    if (normalized in MODEL_CONFIGS) {
+        return normalized;
+    }
+    if (normalized.includes('grok')) {
+        return normalized.includes('4.2') || normalized.includes('4-2') ? 'grok-4.2' : 'grok-4.1';
+    }
+    if (normalized.includes('claude') && normalized.includes('sonnet')) {
+        return normalized.includes('4.6') || normalized.includes('4-6') ? 'claude-4.6-sonnet' : 'claude-4.5-sonnet';
+    }
+    if (normalized.includes('claude') && normalized.includes('opus')) {
+        return normalized.includes('4.6') || normalized.includes('4-6') ? 'claude-4.6-opus' : 'claude-4.1-opus';
+    }
+    if (normalized.includes('codex')) {
+        return 'gpt-5.1-codex';
+    }
+    if (normalized.includes('gemini')) {
+        return normalized.includes('3.5') || normalized.includes('3-5') ? 'gemini-3.5-pro' : 'gemini-3-pro';
+    }
+    if (normalized.includes('classic')) {
+        return 'gpt-5-pro';
+    }
+    if ((normalized.includes('5.3') || normalized.includes('5_3')) && normalized.includes('pro')) {
+        return 'gpt-5.3-pro';
+    }
+    if (normalized.includes('5.3') || normalized.includes('5_3')) {
+        return 'gpt-5.3';
+    }
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('pro')) {
+        return 'gpt-5.2-pro';
+    }
+    // Browser-only: pass through 5.2 thinking/instant variants for browser label mapping
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if ((normalized.includes('5.2') || normalized.includes('5_2')) && normalized.includes('instant')) {
+        return 'gpt-5.2-instant';
+    }
+    if (normalized.includes('5.0') || normalized.includes('5-pro')) {
+        return 'gpt-5-pro';
+    }
+    if (normalized.includes('gpt-5') &&
+        normalized.includes('pro') &&
+        !normalized.includes('5.1') &&
+        !normalized.includes('5.2')) {
+        return 'gpt-5-pro';
+    }
+    if ((normalized.includes('5.1') || normalized.includes('5_1')) && normalized.includes('pro')) {
+        return 'gpt-5.1-pro';
+    }
+    if (normalized.includes('pro')) {
+        return 'gpt-5.3-pro';
+    }
+    if (normalized.includes('5.1') || normalized.includes('5_1')) {
+        return 'gpt-5.1';
+    }
+    if (normalized.includes('thinking')) {
+        return 'gpt-5.2-thinking';
+    }
+    if (normalized.includes('instant') || normalized.includes('fast')) {
+        return 'gpt-5.2-instant';
+    }
+    return 'gpt-5.3';
+}

package/dist/src/cli/oscUtils.js

@@ -0,0 +1,2 @@
+// Utilities for handling OSC progress codes embedded in stored logs.
+export { sanitizeOscProgress } from 'osc-progress';

package/dist/src/cli/promptRequirement.js

@@ -0,0 +1,17 @@
+/**
+ * Determine whether the CLI should enforce a prompt requirement based on raw args and options.
+ */
+export function shouldRequirePrompt(rawArgs, options) {
+    if (rawArgs.length === 0) {
+        return !options.prompt;
+    }
+    const firstArg = rawArgs[0];
+    const bypassPrompt = Boolean(options.session ||
+        options.execSession ||
+        options.status ||
+        options.debugHelp ||
+        firstArg === 'status' ||
+        firstArg === 'session');
+    const requiresPrompt = options.renderMarkdown || Boolean(options.preview) || Boolean(options.dryRun) || !bypassPrompt;
+    return requiresPrompt && !options.prompt;
+}

package/dist/src/cli/renderFlags.js

@@ -0,0 +1,9 @@
+export function resolveRenderFlag(render, renderMarkdown) {
+    return Boolean(renderMarkdown || render);
+}
+export function resolveRenderPlain(renderPlain, render, renderMarkdown) {
+    // Explicit plain render wins when any render flag is set; otherwise false.
+    if (!renderPlain)
+        return false;
+    return Boolean(renderMarkdown || render || renderPlain);
+}

package/dist/src/cli/renderOutput.js

@@ -0,0 +1,26 @@
+import { ensureShikiReady, renderMarkdownAnsi } from './markdownRenderer.js';
+export function shouldRenderRich(options = {}) {
+    return options.richTty ?? Boolean(process.stdout.isTTY);
+}
+/**
+ * Format markdown for CLI output. Uses our ANSI renderer + syntax highlighting
+ * when running in a rich TTY; otherwise returns the raw markdown to avoid
+ * escape codes in redirected output.
+ */
+export async function formatRenderedMarkdown(markdown, options = {}) {
+    const richTty = shouldRenderRich(options);
+    if (!richTty)
+        return markdown;
+    try {
+        await ensureShikiReady();
+    }
+    catch {
+        // If Shiki fails to init (missing terminals/themes), fall back to plain output gracefully.
+    }
+    try {
+        return renderMarkdownAnsi(markdown);
+    }
+    catch {
+        return markdown;
+    }
+}

package/dist/src/cli/rootAlias.js

@@ -0,0 +1,30 @@
+import { attachSession, showStatus } from './sessionDisplay.js';
+const defaultDeps = {
+    attachSession,
+    showStatus,
+};
+export async function handleStatusFlag(options, deps = defaultDeps) {
+    if (!options.status) {
+        return false;
+    }
+    if (options.session) {
+        await deps.attachSession(options.session);
+        return true;
+    }
+    await deps.showStatus({ hours: 24, includeAll: false, limit: 100, showExamples: true });
+    return true;
+}
+const defaultSessionDeps = {
+    attachSession,
+};
+/**
+ * Hidden root-level alias to attach to a stored session (`--session <id>`).
+ * Returns true when the alias was handled so callers can short-circuit.
+ */
+export async function handleSessionAlias(options, deps = defaultSessionDeps) {
+    if (!options.session) {
+        return false;
+    }
+    await deps.attachSession(options.session);
+    return true;
+}

package/dist/src/cli/runOptions.js

@@ -0,0 +1,78 @@
+import { DEFAULT_MODEL, MODEL_CONFIGS } from '../oracle.js';
+import { resolveEngine } from './engine.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel, normalizeBaseUrl } from './options.js';
+import { resolveGeminiModelId } from '../oracle/gemini.js';
+import { PromptValidationError } from '../oracle/errors.js';
+import { normalizeChatGptModelForBrowser } from './browserConfig.js';
+export function resolveRunOptionsFromConfig({ prompt, files = [], model, models, engine, userConfig, env = process.env, }) {
+    const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const browserRequested = engine === 'browser';
+    const browserConfigured = userConfig?.engine === 'browser';
+    const requestedModelList = Array.isArray(models) ? models : [];
+    const normalizedRequestedModels = requestedModelList.map((entry) => normalizeModelOption(entry)).filter(Boolean);
+    const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || DEFAULT_MODEL;
+    const inferredModel = resolvedEngine === 'browser' && normalizedRequestedModels.length === 0
+        ? inferModelFromLabel(cliModelArg)
+        : resolveApiModel(cliModelArg);
+    // Browser engine maps Pro/legacy aliases to the latest ChatGPT picker targets (GPT-5.2 / GPT-5.2 Pro).
+    const resolvedModel = resolvedEngine === 'browser' ? normalizeChatGptModelForBrowser(inferredModel) : inferredModel;
+    const isCodex = resolvedModel.startsWith('gpt-5.1-codex');
+    const isClaude = resolvedModel.startsWith('claude');
+    const isGrok = resolvedModel.startsWith('grok');
+    const engineWasBrowser = resolvedEngine === 'browser';
+    const allModels = normalizedRequestedModels.length > 0
+        ? Array.from(new Set(normalizedRequestedModels.map((entry) => resolveApiModel(entry))))
+        : [resolvedModel];
+    const isBrowserCompatible = (m) => m.startsWith('gpt-') || m.startsWith('gemini');
+    const hasNonBrowserCompatibleTarget = (browserRequested || browserConfigured) && allModels.some((m) => !isBrowserCompatible(m));
+    if (hasNonBrowserCompatibleTarget) {
+        throw new PromptValidationError('Browser engine only supports GPT and Gemini models. Re-run with --engine api for Grok, Claude, or other models.', { engine: 'browser', models: allModels });
+    }
+    const engineCoercedToApi = engineWasBrowser && (isCodex || isClaude || isGrok);
+    const fixedEngine = isCodex || isClaude || isGrok || normalizedRequestedModels.length > 0 ? 'api' : resolvedEngine;
+    const promptWithSuffix = userConfig?.promptSuffix && userConfig.promptSuffix.trim().length > 0
+        ? `${prompt.trim()}\n${userConfig.promptSuffix}`
+        : prompt;
+    const search = userConfig?.search !== 'off';
+    const heartbeatIntervalMs = userConfig?.heartbeatSeconds !== undefined ? userConfig.heartbeatSeconds * 1000 : 30_000;
+    const baseUrl = normalizeBaseUrl(userConfig?.apiBaseUrl ??
+        (isClaude ? env.ANTHROPIC_BASE_URL : isGrok ? env.XAI_BASE_URL : env.OPENAI_BASE_URL));
+    const uniqueMultiModels = normalizedRequestedModels.length > 0 ? allModels : [];
+    const includesCodexMultiModel = uniqueMultiModels.some((entry) => entry.startsWith('gpt-5.1-codex'));
+    if (includesCodexMultiModel && browserRequested) {
+        // Silent coerce; multi-model still forces API.
+    }
+    const chosenModel = uniqueMultiModels[0] ?? resolvedModel;
+    const effectiveModelId = resolveEffectiveModelId(chosenModel);
+    const runOptions = {
+        prompt: promptWithSuffix,
+        model: chosenModel,
+        models: uniqueMultiModels.length > 0 ? uniqueMultiModels : undefined,
+        file: files ?? [],
+        search,
+        heartbeatIntervalMs,
+        filesReport: userConfig?.filesReport,
+        background: userConfig?.background,
+        baseUrl,
+        effectiveModelId,
+    };
+    return { runOptions, resolvedEngine: fixedEngine, engineCoercedToApi };
+}
+function resolveEngineWithConfig({ engine, configEngine, env, }) {
+    if (engine)
+        return engine;
+    const envOverride = (env.ORACLE_ENGINE ?? '').trim().toLowerCase();
+    if (envOverride === 'api' || envOverride === 'browser') {
+        return envOverride;
+    }
+    if (configEngine)
+        return configEngine;
+    return resolveEngine({ engine: undefined, env });
+}
+function resolveEffectiveModelId(model) {
+    if (typeof model === 'string' && model.startsWith('gemini')) {
+        return resolveGeminiModelId(model);
+    }
+    const config = MODEL_CONFIGS[model];
+    return config?.apiModel ?? model;
+}

package/dist/src/cli/sessionCommand.js

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import { usesDefaultStatusFilters } from './options.js';
+import { attachSession, showStatus } from './sessionDisplay.js';
+import { sessionStore } from '../sessionStore.js';
+const defaultDependencies = {
+    showStatus,
+    attachSession,
+    usesDefaultStatusFilters,
+    deleteSessionsOlderThan: (options) => sessionStore.deleteOlderThan(options),
+    getSessionPaths: (sessionId) => sessionStore.getPaths(sessionId),
+};
+const SESSION_OPTION_KEYS = new Set(['hours', 'limit', 'all', 'clear', 'clean', 'render', 'renderMarkdown', 'path', 'model']);
+export async function handleSessionCommand(sessionId, command, deps = defaultDependencies) {
+    const sessionOptions = command.opts();
+    if (sessionOptions.verboseRender) {
+        process.env.ORACLE_VERBOSE_RENDER = '1';
+    }
+    const renderSource = command.getOptionValueSource?.('render');
+    const renderMarkdownSource = command.getOptionValueSource?.('renderMarkdown');
+    const renderExplicit = renderSource === 'cli' || renderMarkdownSource === 'cli';
+    const autoRender = !renderExplicit && process.stdout.isTTY;
+    const pathRequested = Boolean(sessionOptions.path);
+    const clearRequested = Boolean(sessionOptions.clear || sessionOptions.clean);
+    if (clearRequested) {
+        if (sessionId) {
+            console.error('Cannot combine a session ID with --clear. Remove the ID to delete cached sessions.');
+            process.exitCode = 1;
+            return;
+        }
+        const hours = sessionOptions.hours;
+        const includeAll = sessionOptions.all;
+        const result = await deps.deleteSessionsOlderThan({ hours, includeAll });
+        const scope = includeAll ? 'all stored sessions' : `sessions older than ${hours}h`;
+        console.log(formatSessionCleanupMessage(result, scope));
+        return;
+    }
+    if (sessionId === 'clear' || sessionId === 'clean') {
+        console.error('Session cleanup now uses --clear. Run "oracle session --clear --hours <n>" instead.');
+        process.exitCode = 1;
+        return;
+    }
+    if (pathRequested) {
+        if (!sessionId) {
+            console.error('The --path flag requires a session ID.');
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const paths = await deps.getSessionPaths(sessionId);
+            const richTty = Boolean(process.stdout.isTTY && chalk.level > 0);
+            const label = (text) => (richTty ? chalk.cyan(text) : text);
+            const value = (text) => (richTty ? chalk.dim(text) : text);
+            console.log(`${label('Session dir:')} ${value(paths.dir)}`);
+            console.log(`${label('Metadata:')} ${value(paths.metadata)}`);
+            console.log(`${label('Request:')} ${value(paths.request)}`);
+            console.log(`${label('Log:')} ${value(paths.log)}`);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (!sessionId) {
+        const showExamples = deps.usesDefaultStatusFilters(command);
+        await deps.showStatus({
+            hours: sessionOptions.all ? Infinity : sessionOptions.hours,
+            includeAll: sessionOptions.all,
+            limit: sessionOptions.limit,
+            showExamples,
+            modelFilter: sessionOptions.model,
+        });
+        return;
+    }
+    // Surface any root-level flags that were provided but are ignored when attaching to a session.
+    const ignoredFlags = listIgnoredFlags(command);
+    if (ignoredFlags.length > 0) {
+        console.log(`Ignoring flags on session attach: ${ignoredFlags.join(', ')}`);
+    }
+    const renderMarkdown = Boolean(sessionOptions.render || sessionOptions.renderMarkdown || autoRender);
+    await deps.attachSession(sessionId, {
+        renderMarkdown,
+        renderPrompt: !sessionOptions.hidePrompt,
+        model: sessionOptions.model,
+    });
+}
+export function formatSessionCleanupMessage(result, scope) {
+    const deletedLabel = `${result.deleted} ${result.deleted === 1 ? 'session' : 'sessions'}`;
+    const remainingLabel = `${result.remaining} ${result.remaining === 1 ? 'session' : 'sessions'} remain`;
+    const hint = 'Run "oracle session --clear --all" to delete everything.';
+    return `Deleted ${deletedLabel} (${scope}). ${remainingLabel}.\n${hint}`;
+}
+function listIgnoredFlags(command) {
+    const opts = command.optsWithGlobals();
+    const ignored = [];
+    for (const key of Object.keys(opts)) {
+        if (SESSION_OPTION_KEYS.has(key)) {
+            continue;
+        }
+        const source = command.getOptionValueSource?.(key);
+        if (source !== 'cli' && source !== 'env') {
+            continue;
+        }
+        const value = opts[key];
+        if (value === undefined || value === false || value === null) {
+            continue;
+        }
+        ignored.push(key);
+    }
+    return ignored;
+}