@steipete/oracle 1.0.8 → 1.2.0

package/dist/src/cli/help.js

@@ -47,7 +47,7 @@ function renderHelpFooter(program, colors) {
         `${colors.bullet('•')} Oracle starts empty—open with a short project briefing (stack, services, build steps), spell out the question and prior attempts, and why it matters; the more explanation and context you provide, the better the response will be.`,
         `${colors.bullet('•')} Oracle is one-shot: it does not remember prior runs, so start fresh each time with full context.`,
         `${colors.bullet('•')} Run ${colors.accent('--files-report')} to inspect token spend before hitting the API.`,
-        `${colors.bullet('•')} Non-preview runs spawn detached sessions so they keep streaming even if your terminal closes — reattach anytime via ${colors.accent('pnpm oracle session <slug>')}.`,
+        `${colors.bullet('•')} Non-preview runs spawn detached sessions (especially gpt-5-pro API). If the CLI times out, do not re-run — reattach with ${colors.accent('oracle session <slug>')} to resume/inspect the existing run.`,
         `${colors.bullet('•')} Set a memorable 3–5 word slug via ${colors.accent('--slug "<words>"')} to keep session IDs tidy.`,
         `${colors.bullet('•')} Finished sessions auto-hide preamble logs when reattached; raw timestamps remain in the saved log file.`,
         `${colors.bullet('•')} Need hidden flags? Run ${colors.accent(`${program.name()} --help --verbose`)} to list search/token/browser overrides.`,

package/dist/src/cli/hiddenAliases.js

@@ -0,0 +1,17 @@
+/**
+ * Normalize hidden alias flags so they behave like their primary counterparts.
+ *
+ * - `--message` maps to `--prompt` when no prompt is provided.
+ * - `--include` extends the `--file` list.
+ */
+export function applyHiddenAliases(options, setOptionValue) {
+    if (options.include && options.include.length > 0) {
+        const mergedFiles = [...(options.file ?? []), ...options.include];
+        options.file = mergedFiles;
+        setOptionValue?.('file', mergedFiles);
+    }
+    if (!options.prompt && options.message) {
+        options.prompt = options.message;
+        setOptionValue?.('prompt', options.message);
+    }
+}

package/dist/src/cli/markdownRenderer.js

@@ -0,0 +1,97 @@
+import chalk from 'chalk';
+import { render as renderMarkdown } from 'markdansi';
+import { bundledLanguages, bundledThemes, createHighlighter, } from 'shiki';
+const DEFAULT_THEME = 'github-dark';
+const HIGHLIGHT_LANGS = ['ts', 'tsx', 'js', 'jsx', 'json', 'swift'];
+const SUPPORTED_LANG_ALIASES = {
+    ts: 'ts',
+    typescript: 'ts',
+    tsx: 'tsx',
+    js: 'js',
+    javascript: 'js',
+    jsx: 'jsx',
+    json: 'json',
+    swift: 'swift',
+};
+const shikiPromise = createHighlighter({
+    themes: [bundledThemes[DEFAULT_THEME]],
+    langs: HIGHLIGHT_LANGS.map((lang) => bundledLanguages[lang]),
+});
+let shiki = null;
+void shikiPromise
+    .then((instance) => {
+    shiki = instance;
+})
+    .catch(() => {
+    shiki = null;
+});
+export async function ensureShikiReady() {
+    if (shiki)
+        return;
+    try {
+        shiki = await shikiPromise;
+    }
+    catch {
+        shiki = null;
+    }
+}
+function normalizeLanguage(lang) {
+    if (!lang)
+        return null;
+    const key = lang.toLowerCase();
+    return SUPPORTED_LANG_ALIASES[key] ?? null;
+}
+function styleToken(text, fontStyle = 0) {
+    let styled = text;
+    if (fontStyle & 1)
+        styled = chalk.italic(styled);
+    if (fontStyle & 2)
+        styled = chalk.bold(styled);
+    if (fontStyle & 4)
+        styled = chalk.underline(styled);
+    if (fontStyle & 8)
+        styled = chalk.strikethrough(styled);
+    return styled;
+}
+function shikiHighlighter(code, lang) {
+    if (!process.stdout.isTTY || !shiki)
+        return code;
+    const normalizedLang = normalizeLanguage(lang);
+    if (!normalizedLang)
+        return code;
+    try {
+        if (!shiki.getLoadedLanguages().includes(normalizedLang)) {
+            return code;
+        }
+        const { tokens } = shiki.codeToTokens(code, { lang: normalizedLang, theme: DEFAULT_THEME });
+        return tokens
+            .map((line) => line
+            .map((token) => {
+            const colored = token.color ? chalk.hex(token.color)(token.content) : token.content;
+            return styleToken(colored, token.fontStyle);
+        })
+            .join(''))
+            .join('\n');
+    }
+    catch {
+        return code;
+    }
+}
+export function renderMarkdownAnsi(markdown) {
+    try {
+        const color = Boolean(process.stdout.isTTY);
+        const width = process.stdout.columns;
+        const hyperlinks = color; // enable OSC 8 only when we have color/TTY
+        return renderMarkdown(markdown, {
+            color,
+            width,
+            wrap: true,
+            hyperlinks,
+            highlighter: color ? shikiHighlighter : undefined,
+        });
+    }
+    catch {
+        // Last-resort fallback: return the raw markdown so we never crash.
+        return markdown;
+    }
+}

package/dist/src/cli/notifier.js

@@ -0,0 +1,223 @@
+import notifier from 'toasted-notifier';
+import { spawn } from 'node:child_process';
+import { formatUSD, formatNumber } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle/config.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+const ORACLE_EMOJI = '🧿';
+export function resolveNotificationSettings({ cliNotify, cliNotifySound, env, config, }) {
+    const defaultEnabled = !(bool(env.CI) || bool(env.SSH_CONNECTION) || muteByConfig(env, config));
+    const envNotify = parseToggle(env.ORACLE_NOTIFY);
+    const envSound = parseToggle(env.ORACLE_NOTIFY_SOUND);
+    const enabled = cliNotify ?? envNotify ?? config?.enabled ?? defaultEnabled;
+    const sound = cliNotifySound ?? envSound ?? config?.sound ?? false;
+    return { enabled, sound };
+}
+export function deriveNotificationSettingsFromMetadata(metadata, env, config) {
+    if (metadata?.notifications) {
+        return metadata.notifications;
+    }
+    return resolveNotificationSettings({ cliNotify: undefined, cliNotifySound: undefined, env, config });
+}
+export async function sendSessionNotification(payload, settings, log, answerPreview) {
+    if (!settings.enabled || isTestEnv(process.env)) {
+        return;
+    }
+    const title = `Oracle${ORACLE_EMOJI} finished`;
+    const message = buildMessage(payload, sanitizePreview(answerPreview));
+    try {
+        if (await tryMacNativeNotifier(title, message, settings)) {
+            return;
+        }
+        // Fallback to toasted-notifier (cross-platform). macAppIconOption() is only honored on macOS.
+        await notifier.notify({
+            title,
+            message,
+            sound: settings.sound,
+        });
+    }
+    catch (error) {
+        if (isMacExecError(error)) {
+            const repaired = await repairMacNotifier(log);
+            if (repaired) {
+                try {
+                    await notifier.notify({ title, message, sound: settings.sound, ...(macAppIconOption()) });
+                    return;
+                }
+                catch (retryError) {
+                    const reason = retryError instanceof Error ? retryError.message : String(retryError);
+                    log(`(notify skipped after retry: ${reason})`);
+                    return;
+                }
+            }
+        }
+        const reason = error instanceof Error ? error.message : String(error);
+        log(`(notify skipped: ${reason})`);
+    }
+}
+function buildMessage(payload, answerPreview) {
+    const parts = [];
+    const sessionLabel = payload.sessionName || payload.sessionId;
+    parts.push(sessionLabel);
+    // Show cost only for API runs.
+    if (payload.mode === 'api') {
+        const cost = payload.costUsd ?? inferCost(payload);
+        if (cost !== undefined) {
+            // Round to $0.00 for a concise toast.
+            parts.push(formatUSD(Number(cost.toFixed(2))));
+        }
+    }
+    if (payload.characters != null) {
+        parts.push(`${formatNumber(payload.characters)} chars`);
+    }
+    if (answerPreview) {
+        parts.push(answerPreview);
+    }
+    return parts.join(' · ');
+}
+function sanitizePreview(preview) {
+    if (!preview)
+        return undefined;
+    let text = preview;
+    // Strip code fences and inline code markers.
+    text = text.replace(/```[\s\S]*?```/g, ' ');
+    text = text.replace(/`([^`]+)`/g, '$1');
+    // Convert markdown links and images to their visible text.
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+    // Drop bold/italic markers.
+    text = text.replace(/(\*\*|__|\*|_)/g, '');
+    // Remove headings / list markers / blockquotes.
+    text = text.replace(/^\s*#+\s*/gm, '');
+    text = text.replace(/^\s*[-*+]\s+/gm, '');
+    text = text.replace(/^\s*>\s+/gm, '');
+    // Collapse whitespace and trim.
+    text = text.replace(/\s+/g, ' ').trim();
+    // Limit length to keep notifications short.
+    const max = 200;
+    if (text.length > max) {
+        text = `${text.slice(0, max - 1)}…`;
+    }
+    return text;
+}
+// Exposed for unit tests only.
+export const testHelpers = { sanitizePreview };
+function inferCost(payload) {
+    const model = payload.model;
+    const usage = payload.usage;
+    if (!model || !usage)
+        return undefined;
+    const config = MODEL_CONFIGS[model];
+    if (!config)
+        return undefined;
+    return (usage.inputTokens * config.pricing.inputPerToken +
+        usage.outputTokens * config.pricing.outputPerToken);
+}
+function parseToggle(value) {
+    if (value == null)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return undefined;
+}
+function bool(value) {
+    return Boolean(value && String(value).length > 0);
+}
+function isMacExecError(error) {
+    return Boolean(process.platform === 'darwin' &&
+        error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        error.code === 'EACCES');
+}
+async function repairMacNotifier(log) {
+    const binPath = macNotifierPath();
+    if (!binPath)
+        return false;
+    try {
+        await fs.chmod(binPath, 0o755);
+        return true;
+    }
+    catch (chmodError) {
+        const reason = chmodError instanceof Error ? chmodError.message : String(chmodError);
+        log(`(notify repair failed: ${reason} — try: xattr -dr com.apple.quarantine "${path.dirname(binPath)}")`);
+        return false;
+    }
+}
+function macNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    try {
+        const req = createRequire(import.meta.url);
+        const modPath = req.resolve('toasted-notifier');
+        const base = path.dirname(modPath);
+        return path.join(base, 'vendor', 'mac.noindex', 'terminal-notifier.app', 'Contents', 'MacOS', 'terminal-notifier');
+    }
+    catch {
+        return null;
+    }
+}
+function macAppIconOption() {
+    if (process.platform !== 'darwin')
+        return {};
+    const iconPaths = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../assets-oracle-icon.png'),
+        path.resolve(process.cwd(), 'assets-oracle-icon.png'),
+    ];
+    for (const candidate of iconPaths) {
+        if (candidate && fsExistsSync(candidate)) {
+            return { appIcon: candidate };
+        }
+    }
+    return {};
+}
+function fsExistsSync(target) {
+    try {
+        return Boolean(require('node:fs').statSync(target));
+    }
+    catch {
+        return false;
+    }
+}
+async function tryMacNativeNotifier(title, message, settings) {
+    const binary = macNativeNotifierPath();
+    if (!binary)
+        return false;
+    return new Promise((resolve) => {
+        const child = spawn(binary, [title, message, settings.sound ? 'Glass' : ''], {
+            stdio: 'ignore',
+        });
+        child.on('error', () => resolve(false));
+        child.on('exit', (code) => resolve(code === 0));
+    });
+}
+function macNativeNotifierPath() {
+    if (process.platform !== 'darwin')
+        return null;
+    const candidates = [
+        path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+        path.resolve(process.cwd(), 'vendor/oracle-notifier/OracleNotifier.app/Contents/MacOS/OracleNotifier'),
+    ];
+    for (const candidate of candidates) {
+        if (fsExistsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function muteByConfig(env, config) {
+    if (!config?.muteIn)
+        return false;
+    return ((config.muteIn.includes('CI') && bool(env.CI)) ||
+        (config.muteIn.includes('SSH') && bool(env.SSH_CONNECTION)));
+}
+function isTestEnv(env) {
+    return (env.ORACLE_DISABLE_NOTIFICATIONS === '1' ||
+        env.NODE_ENV === 'test' ||
+        Boolean(env.VITEST || env.VITEST_WORKER_ID || env.JEST_WORKER_ID));
+}

package/dist/src/cli/promptRequirement.js

@@ -2,6 +2,9 @@
  * 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 ||

package/dist/src/cli/rootAlias.js

@@ -14,3 +14,17 @@ export async function handleStatusFlag(options, deps = defaultDeps) {
     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,29 @@
+import { resolveEngine } from './engine.js';
+import { normalizeModelOption, inferModelFromLabel, resolveApiModel } from './options.js';
+export function resolveRunOptionsFromConfig({ prompt, files = [], model, engine, userConfig, env = process.env, }) {
+    const resolvedEngine = resolveEngineWithConfig({ engine, configEngine: userConfig?.engine, env });
+    const cliModelArg = normalizeModelOption(model ?? userConfig?.model) || 'gpt-5-pro';
+    const resolvedModel = resolvedEngine === 'browser' ? inferModelFromLabel(cliModelArg) : resolveApiModel(cliModelArg);
+    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 runOptions = {
+        prompt: promptWithSuffix,
+        model: resolvedModel,
+        file: files ?? [],
+        search,
+        heartbeatIntervalMs,
+        filesReport: userConfig?.filesReport,
+        background: userConfig?.background,
+    };
+    return { runOptions, resolvedEngine };
+}
+function resolveEngineWithConfig({ engine, configEngine, env, }) {
+    if (engine)
+        return engine;
+    if (configEngine)
+        return configEngine;
+    return resolveEngine({ engine: undefined, env });
+}

package/dist/src/cli/sessionCommand.js

@@ -1,14 +1,25 @@
+import chalk from 'chalk';
 import { usesDefaultStatusFilters } from './options.js';
 import { attachSession, showStatus } from './sessionDisplay.js';
-import { deleteSessionsOlderThan } from '../sessionManager.js';
+import { deleteSessionsOlderThan, getSessionPaths } from '../sessionManager.js';
 const defaultDependencies = {
     showStatus,
     attachSession,
     usesDefaultStatusFilters,
     deleteSessionsOlderThan,
+    getSessionPaths,
 };
+const SESSION_OPTION_KEYS = new Set(['hours', 'limit', 'all', 'clear', 'clean', 'render', 'renderMarkdown', 'path']);
 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) {
@@ -28,6 +39,28 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
         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({
@@ -38,7 +71,13 @@ export async function handleSessionCommand(sessionId, command, deps = defaultDep
         });
         return;
     }
-    await deps.attachSession(sessionId);
+    // 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 });
 }
 export function formatSessionCleanupMessage(result, scope) {
     const deletedLabel = `${result.deleted} ${result.deleted === 1 ? 'session' : 'sessions'}`;
@@ -46,3 +85,22 @@ export function formatSessionCleanupMessage(result, scope) {
     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;
+}