@steipete/oracle 1.0.8 → 1.2.0

package/dist/src/cli/sessionDisplay.js

@@ -1,8 +1,12 @@
 import chalk from 'chalk';
 import kleur from 'kleur';
-import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, SESSIONS_DIR, wait, } from '../sessionManager.js';
-const isTty = process.stdout.isTTY;
-const dim = (text) => (isTty ? kleur.dim(text) : text);
+import { filterSessionsByRange, listSessionsMetadata, readSessionLog, readSessionMetadata, readSessionRequest, SESSIONS_DIR, wait, } from '../sessionManager.js';
+import { renderMarkdownAnsi } from './markdownRenderer.js';
+import { formatElapsed, formatUSD } from '../oracle/format.js';
+import { MODEL_CONFIGS } from '../oracle.js';
+const isTty = () => Boolean(process.stdout.isTTY);
+const dim = (text) => (isTty() ? kleur.dim(text) : text);
+export const MAX_RENDER_BYTES = 200_000;
 const CLEANUP_TIP = 'Tip: Run "oracle session --clear --hours 24" to prune cached runs (add --all to wipe everything).';
 export async function showStatus({ hours, includeAll, limit, showExamples = false }) {
     const metas = await listSessionsMetadata();
@@ -16,12 +20,17 @@ export async function showStatus({ hours, includeAll, limit, showExamples = fals
         return;
     }
     console.log(chalk.bold('Recent Sessions'));
+    console.log(chalk.dim('Timestamp             Chars  Cost  Status     Model      ID'));
     for (const entry of entries) {
         const statusRaw = (entry.status || 'unknown').padEnd(9);
         const status = richTty ? colorStatus(entry.status ?? 'unknown', statusRaw) : statusRaw;
         const model = (entry.model || 'n/a').padEnd(9);
-        const created = entry.createdAt.replace('T', ' ').replace('Z', '');
-        console.log(`${created} | ${status} | ${model} | ${entry.id}`);
+        const created = formatTimestamp(entry.createdAt);
+        const chars = entry.options?.prompt?.length ?? entry.promptPreview?.length ?? 0;
+        const charLabel = chars > 0 ? String(chars).padStart(5) : '    -';
+        const costValue = resolveCost(entry);
+        const costLabel = costValue != null ? formatCostTable(costValue) : '     -';
+        console.log(`${created} | ${charLabel} | ${costLabel} | ${status} | ${model} | ${entry.id}`);
     }
     if (truncated) {
         console.log(chalk.yellow(`Showing ${entries.length} of ${total} sessions from the requested range. Run "oracle session --clear" or delete entries in ${SESSIONS_DIR} to free space, or rerun with --status-limit/--status-all.`));
@@ -50,6 +59,8 @@ export async function attachSession(sessionId, options) {
         return;
     }
     const initialStatus = metadata.status;
+    const wantsRender = Boolean(options?.renderMarkdown);
+    const isVerbose = Boolean(process.env.ORACLE_VERBOSE_RENDER);
     if (!options?.suppressMetadata) {
         const reattachLine = buildReattachLine(metadata);
         if (reattachLine) {
@@ -72,18 +83,111 @@ export async function attachSession(sessionId, options) {
         }
     }
     const shouldTrimIntro = initialStatus === 'completed' || initialStatus === 'error';
+    if (options?.renderPrompt !== false) {
+        const prompt = await readStoredPrompt(sessionId);
+        if (prompt) {
+            console.log(chalk.bold('Prompt:'));
+            console.log(renderMarkdownAnsi(prompt));
+            console.log(dim('---'));
+        }
+    }
     if (shouldTrimIntro) {
         const fullLog = await readSessionLog(sessionId);
         const trimmed = trimBeforeFirstAnswer(fullLog);
-        process.stdout.write(trimmed);
+        const size = Buffer.byteLength(trimmed, 'utf8');
+        const canRender = wantsRender && isTty() && size <= MAX_RENDER_BYTES;
+        if (wantsRender && size > MAX_RENDER_BYTES) {
+            const msg = `Render skipped (log too large: ${size} bytes > ${MAX_RENDER_BYTES}). Showing raw text.`;
+            console.log(dim(msg));
+            if (isVerbose) {
+                console.log(dim(`Verbose: renderMarkdown=true tty=${isTty()} size=${size}`));
+            }
+        }
+        else if (wantsRender && !isTty()) {
+            const msg = 'Render requested but stdout is not a TTY; showing raw text.';
+            console.log(dim(msg));
+            if (isVerbose) {
+                console.log(dim(`Verbose: renderMarkdown=true tty=${isTty()} size=${size}`));
+            }
+        }
+        if (canRender) {
+            if (isVerbose) {
+                console.log(dim(`Verbose: rendering markdown (size=${size}, tty=${isTty()})`));
+            }
+            process.stdout.write(renderMarkdownAnsi(trimmed));
+        }
+        else {
+            process.stdout.write(trimmed);
+        }
+        const summary = formatCompletionSummary(metadata, { includeSlug: true });
+        if (summary) {
+            console.log(`\n${chalk.green.bold(summary)}`);
+        }
         return;
     }
+    if (wantsRender) {
+        console.log(dim('Render will apply after completion; streaming raw text meanwhile...'));
+        if (isVerbose) {
+            console.log(dim(`Verbose: streaming phase renderMarkdown=true tty=${isTty()}`));
+        }
+    }
+    const liveRenderState = wantsRender && isTty()
+        ? { pending: '', inFence: false, inTable: false, renderedBytes: 0, fallback: false, noticedFallback: false }
+        : null;
     let lastLength = 0;
+    const renderLiveChunk = (chunk) => {
+        if (!liveRenderState || chunk.length === 0) {
+            process.stdout.write(chunk);
+            return;
+        }
+        if (liveRenderState.fallback) {
+            process.stdout.write(chunk);
+            return;
+        }
+        liveRenderState.pending += chunk;
+        const { chunks, remainder } = extractRenderableChunks(liveRenderState.pending, liveRenderState);
+        liveRenderState.pending = remainder;
+        for (const candidate of chunks) {
+            const projected = liveRenderState.renderedBytes + Buffer.byteLength(candidate, 'utf8');
+            if (projected > MAX_RENDER_BYTES) {
+                if (!liveRenderState.noticedFallback) {
+                    console.log(dim(`Render skipped (log too large: > ${MAX_RENDER_BYTES} bytes). Showing raw text.`));
+                    liveRenderState.noticedFallback = true;
+                }
+                liveRenderState.fallback = true;
+                process.stdout.write(candidate + liveRenderState.pending);
+                liveRenderState.pending = '';
+                return;
+            }
+            process.stdout.write(renderMarkdownAnsi(candidate));
+            liveRenderState.renderedBytes += Buffer.byteLength(candidate, 'utf8');
+        }
+    };
+    const flushRemainder = () => {
+        if (!liveRenderState || liveRenderState.fallback) {
+            return;
+        }
+        if (liveRenderState.pending.length === 0) {
+            return;
+        }
+        const text = liveRenderState.pending;
+        liveRenderState.pending = '';
+        const projected = liveRenderState.renderedBytes + Buffer.byteLength(text, 'utf8');
+        if (projected > MAX_RENDER_BYTES) {
+            if (!liveRenderState.noticedFallback) {
+                console.log(dim(`Render skipped (log too large: > ${MAX_RENDER_BYTES} bytes). Showing raw text.`));
+            }
+            process.stdout.write(text);
+            liveRenderState.fallback = true;
+            return;
+        }
+        process.stdout.write(renderMarkdownAnsi(text));
+    };
     const printNew = async () => {
         const text = await readSessionLog(sessionId);
         const nextChunk = text.slice(lastLength);
         if (nextChunk.length > 0) {
-            process.stdout.write(nextChunk);
+            renderLiveChunk(nextChunk);
             lastLength = text.length;
         }
     };
@@ -96,14 +200,21 @@ export async function attachSession(sessionId, options) {
         }
         if (latest.status === 'completed' || latest.status === 'error') {
             await printNew();
+            flushRemainder();
             if (!options?.suppressMetadata) {
                 if (latest.status === 'error' && latest.errorMessage) {
                     console.log('\nResult:');
                     console.log(`Session failed: ${latest.errorMessage}`);
                 }
-                if (latest.usage && initialStatus === 'running') {
-                    const usage = latest.usage;
-                    console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                if (latest.status === 'completed' && latest.usage) {
+                    const summary = formatCompletionSummary(latest, { includeSlug: true });
+                    if (summary) {
+                        console.log(`\n${chalk.green.bold(summary)}`);
+                    }
+                    else {
+                        const usage = latest.usage;
+                        console.log(`\nFinished (tok i/o/r/t: ${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens})`);
+                    }
                 }
             }
             break;
@@ -234,3 +345,104 @@ function printStatusExamples() {
     console.log(dim('    Attach to a specific running/completed session to stream its output.'));
     console.log(dim(CLEANUP_TIP));
 }
+function extractRenderableChunks(text, state) {
+    const chunks = [];
+    let buffer = '';
+    const lines = text.split(/(\n)/);
+    for (let i = 0; i < lines.length; i += 1) {
+        const segment = lines[i];
+        if (segment === '\n') {
+            buffer += segment;
+            // Detect code fences
+            const prev = lines[i - 1] ?? '';
+            const fenceMatch = prev.match(/^(\s*)(`{3,}|~{3,})(.*)$/);
+            if (!state.inFence && fenceMatch) {
+                state.inFence = true;
+                state.fenceDelimiter = fenceMatch[2];
+            }
+            else if (state.inFence && state.fenceDelimiter && prev.startsWith(state.fenceDelimiter)) {
+                state.inFence = false;
+                state.fenceDelimiter = undefined;
+            }
+            const trimmed = prev.trim();
+            if (!state.inFence) {
+                if (!state.inTable && trimmed.startsWith('|') && trimmed.includes('|')) {
+                    state.inTable = true;
+                }
+                if (state.inTable && trimmed === '') {
+                    state.inTable = false;
+                }
+            }
+            const safeBreak = !state.inFence && !state.inTable && trimmed === '';
+            if (safeBreak) {
+                chunks.push(buffer);
+                buffer = '';
+            }
+            continue;
+        }
+        buffer += segment;
+    }
+    return { chunks, remainder: buffer };
+}
+function formatTimestamp(iso) {
+    const date = new Date(iso);
+    const locale = 'en-US';
+    const opts = {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: 'numeric',
+        minute: '2-digit',
+        second: undefined,
+        hour12: true,
+    };
+    const formatted = date.toLocaleString(locale, opts);
+    return formatted.replace(/(, )(\d:)/, '$1 $2');
+}
+export function formatCompletionSummary(metadata, options = {}) {
+    if (!metadata.usage || metadata.elapsedMs == null) {
+        return null;
+    }
+    const modeLabel = metadata.mode === 'browser' ? `${metadata.model ?? 'n/a'}[browser]` : metadata.model ?? 'n/a';
+    const usage = metadata.usage;
+    const cost = metadata.mode === 'browser' ? null : resolveCost(metadata);
+    const costPart = cost != null ? ` | ${formatUSD(cost)}` : '';
+    const tokensDisplay = `${usage.inputTokens}/${usage.outputTokens}/${usage.reasoningTokens}/${usage.totalTokens}`;
+    const filesCount = metadata.options?.file?.length ?? 0;
+    const filesPart = filesCount > 0 ? ` | files=${filesCount}` : '';
+    const slugPart = options.includeSlug ? ` | slug=${metadata.id}` : '';
+    return `Finished in ${formatElapsed(metadata.elapsedMs)} (${modeLabel}${costPart} | tok(i/o/r/t)=${tokensDisplay}${filesPart}${slugPart})`;
+}
+function resolveCost(metadata) {
+    if (metadata.mode === 'browser') {
+        return null;
+    }
+    if (metadata.usage?.cost != null) {
+        return metadata.usage.cost;
+    }
+    if (!metadata.model || !metadata.usage) {
+        return null;
+    }
+    const pricing = MODEL_CONFIGS[metadata.model]?.pricing;
+    if (!pricing) {
+        return null;
+    }
+    const input = metadata.usage.inputTokens ?? 0;
+    const output = metadata.usage.outputTokens ?? 0;
+    const cost = input * pricing.inputPerToken + output * pricing.outputPerToken;
+    return cost > 0 ? cost : null;
+}
+function formatCostTable(cost) {
+    return `$${cost.toFixed(3)}`.padStart(7);
+}
+async function readStoredPrompt(sessionId) {
+    const request = await readSessionRequest(sessionId);
+    if (request?.prompt && request.prompt.trim().length > 0) {
+        return request.prompt;
+    }
+    const meta = await readSessionMetadata(sessionId);
+    if (meta?.options?.prompt && meta.options.prompt.trim().length > 0) {
+        return meta.options.prompt;
+    }
+    return null;
+}

package/dist/src/cli/sessionRunner.js

@@ -1,18 +1,20 @@
 import kleur from 'kleur';
 import { updateSessionMetadata } from '../sessionManager.js';
-import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, } from '../oracle.js';
+import { runOracle, OracleResponseError, OracleTransportError, extractResponseMetadata, asOracleUserError, extractTextOutput, } from '../oracle.js';
 import { runBrowserSessionExecution } from '../browser/sessionRunner.js';
 import { formatResponseMetadata, formatTransportMetadata } from './sessionDisplay.js';
 import { markErrorLogged } from './errorUtils.js';
+import { sendSessionNotification, deriveNotificationSettingsFromMetadata, } from './notifier.js';
 const isTty = process.stdout.isTTY;
 const dim = (text) => (isTty ? kleur.dim(text) : text);
-export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, }) {
+export async function performSessionRun({ sessionMeta, runOptions, mode, browserConfig, cwd, log, write, version, notifications, }) {
     await updateSessionMetadata(sessionMeta.id, {
         status: 'running',
         startedAt: new Date().toISOString(),
         mode,
         ...(browserConfig ? { browser: { config: browserConfig } } : {}),
     });
+    const notificationSettings = notifications ?? deriveNotificationSettingsFromMetadata(sessionMeta, process.env);
     try {
         if (mode === 'browser') {
             if (!browserConfig) {
@@ -32,6 +34,14 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
                 transport: undefined,
                 error: undefined,
             });
+            await sendSessionNotification({
+                sessionId: sessionMeta.id,
+                sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+                mode,
+                model: sessionMeta.model,
+                usage: result.usage,
+                characters: result.answerText?.length,
+            }, notificationSettings, log, result.answerText?.slice(0, 140));
             return;
         }
         const result = await runOracle(runOptions, {
@@ -51,6 +61,15 @@ export async function performSessionRun({ sessionMeta, runOptions, mode, browser
             transport: undefined,
             error: undefined,
         });
+        const answerText = extractTextOutput(result.response);
+        await sendSessionNotification({
+            sessionId: sessionMeta.id,
+            sessionName: sessionMeta.options?.slug ?? sessionMeta.id,
+            mode,
+            model: sessionMeta.model ?? runOptions.model,
+            usage: result.usage,
+            characters: answerText.length,
+        }, notificationSettings, log, answerText.slice(0, 140));
     }
     catch (error) {
         const message = formatError(error);