@aitherium/shell-cli 1.1.0

package/dist/gargbot.js

@@ -0,0 +1,230 @@
+/**
+ * GargBot CLI commands — chat, ingest, search, status, and Obsidian sync.
+ *
+ * Usage:
+ *   aither gargbot chat "What projects did we do in Texas?"
+ *   aither gargbot ingest ./resumes/john_doe.pdf
+ *   aither gargbot search "bridge engineers with PE"
+ *   aither gargbot status
+ *   aither gargbot sync-obsidian /path/to/vault
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+function getGargbotUrl() {
+    // 1. Environment variable
+    if (process.env.GARGBOT_URL)
+        return process.env.GARGBOT_URL;
+    // 2. Config file ~/.aither/gargbot.json
+    const configPath = path.join(os.homedir(), '.aither', 'gargbot.json');
+    try {
+        if (fs.existsSync(configPath)) {
+            const cfg = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            if (cfg.url)
+                return cfg.url;
+        }
+    }
+    catch { /* fallthrough */ }
+    // 3. Default
+    return 'http://localhost:8900';
+}
+async function gargGet(endpoint) {
+    const url = `${getGargbotUrl()}${endpoint}`;
+    const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function gargPost(endpoint, body) {
+    const url = `${getGargbotUrl()}${endpoint}`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+async function gargUpload(endpoint, filePath, fields = {}) {
+    const url = `${getGargbotUrl()}${endpoint}`;
+    const fileBuffer = fs.readFileSync(filePath);
+    const fileName = path.basename(filePath);
+    // Build multipart form data manually for Node fetch
+    const boundary = '----AitherShellBoundary' + Date.now().toString(36);
+    let body = '';
+    for (const [key, val] of Object.entries(fields)) {
+        body += `--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${val}\r\n`;
+    }
+    body += `--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${fileName}"\r\nContent-Type: application/octet-stream\r\n\r\n`;
+    const ending = `\r\n--${boundary}--\r\n`;
+    const bodyBuffer = Buffer.concat([
+        Buffer.from(body, 'utf-8'),
+        fileBuffer,
+        Buffer.from(ending, 'utf-8'),
+    ]);
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': `multipart/form-data; boundary=${boundary}` },
+        body: bodyBuffer,
+    });
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText}`);
+    return res.json();
+}
+// ── Subcommand handlers ──────────────────────────────────────────────────
+async function handleChat(args) {
+    const message = args.join(' ');
+    if (!message) {
+        console.log('\x1b[33mUsage:\x1b[0m aither gargbot chat <message>');
+        return;
+    }
+    console.log('\x1b[2mThinking...\x1b[0m');
+    try {
+        const data = await gargPost('/api/chat', { message });
+        console.log(`\n\x1b[36mGargBot:\x1b[0m ${data.response}`);
+        if (data.sources?.length > 0) {
+            console.log(`\n\x1b[2mSources: ${data.sources.map((s) => s.filename).join(', ')}\x1b[0m`);
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function handleIngest(args) {
+    const target = args[0];
+    // If no args and stdin is piped, read from stdin
+    if (!target && !process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        }
+        const text = Buffer.concat(chunks).toString('utf-8').trim();
+        if (!text) {
+            console.error('\x1b[31mNo input received from stdin\x1b[0m');
+            return;
+        }
+        console.log('\x1b[2mIngesting from stdin...\x1b[0m');
+        try {
+            const data = await gargPost('/api/documents/ingest', {
+                text,
+                filename: `stdin-${Date.now()}`,
+                doc_type: 'other',
+            });
+            console.log(`\x1b[32m✓\x1b[0m Ingested stdin (${data.chunks_created || '?'} chunks)`);
+        }
+        catch (e) {
+            console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+        }
+        return;
+    }
+    if (!target) {
+        console.log('\x1b[33mUsage:\x1b[0m aither gargbot ingest <file-or-url>');
+        console.log('       echo "text" | aither gargbot ingest');
+        return;
+    }
+    // URL detection
+    if (target.startsWith('http://') || target.startsWith('https://')) {
+        console.log(`\x1b[2mIngesting URL: ${target}...\x1b[0m`);
+        try {
+            const data = await gargPost('/api/documents/ingest-url', { url: target, auto_extract: true });
+            console.log(`\x1b[32m✓\x1b[0m Ingested: ${data.title || target} (${data.chunk_count || '?'} chunks)`);
+        }
+        catch (e) {
+            console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+        }
+        return;
+    }
+    // File path
+    const resolved = path.resolve(target);
+    if (!fs.existsSync(resolved)) {
+        console.error(`\x1b[31mFile not found:\x1b[0m ${resolved}`);
+        return;
+    }
+    console.log(`\x1b[2mIngesting ${path.basename(resolved)}...\x1b[0m`);
+    try {
+        const data = await gargUpload('/api/documents/upload', resolved, { auto_extract: 'true' });
+        console.log(`\x1b[32m✓\x1b[0m Ingested: ${data.filename || path.basename(resolved)} (${data.chunk_count || data.chunks_created || '?'} chunks)`);
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function handleSearch(args) {
+    const query = args.join(' ');
+    if (!query) {
+        console.log('\x1b[33mUsage:\x1b[0m aither gargbot search <query>');
+        return;
+    }
+    try {
+        const data = await gargPost('/api/chat', { message: `Search: ${query}` });
+        console.log(`\n\x1b[36mResults:\x1b[0m ${data.response}`);
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+async function handleStatus(_args) {
+    try {
+        const health = await gargGet('/api/health');
+        const stats = await gargGet('/api/stats');
+        console.log(`\x1b[36mGargBot Status\x1b[0m`);
+        console.log(`  Service:    ${health.service}`);
+        console.log(`  Provider:   ${health.llm_provider}`);
+        console.log(`  Mode:       ${health.deployment_mode}`);
+        console.log(`  Documents:  ${stats.documents}`);
+        console.log(`  Staff:      ${stats.staff}`);
+        console.log(`  Projects:   ${stats.projects}`);
+        console.log(`  Feedback:   ${stats.feedback_entries}`);
+    }
+    catch (e) {
+        console.error(`\x1b[31mCannot reach GargBot:\x1b[0m ${e.message}`);
+        console.log(`  URL: ${getGargbotUrl()}`);
+    }
+}
+async function handleSyncObsidian(args) {
+    const vaultPath = args[0];
+    if (!vaultPath) {
+        console.log('\x1b[33mUsage:\x1b[0m aither gargbot sync-obsidian <vault-path>');
+        return;
+    }
+    console.log(`\x1b[2mSyncing vault: ${vaultPath}...\x1b[0m`);
+    try {
+        const data = await gargPost('/api/obsidian/sync', { vault_path: vaultPath });
+        console.log(`\x1b[32m✓\x1b[0m Synced: ${data.total_files} files (${data.ingested} new, ${data.skipped} unchanged)`);
+        if (data.error_count > 0) {
+            console.log(`\x1b[33m  ⚠ ${data.error_count} errors\x1b[0m`);
+        }
+    }
+    catch (e) {
+        console.error(`\x1b[31mError:\x1b[0m ${e.message}`);
+    }
+}
+// ── Main dispatcher ──────────────────────────────────────────────────────
+export async function handleGargbotCommand(args) {
+    const subcommand = args[0] || 'help';
+    const subArgs = args.slice(1);
+    switch (subcommand) {
+        case 'chat':
+            return handleChat(subArgs);
+        case 'ingest':
+            return handleIngest(subArgs);
+        case 'search':
+            return handleSearch(subArgs);
+        case 'status':
+            return handleStatus(subArgs);
+        case 'sync-obsidian':
+        case 'sync':
+            return handleSyncObsidian(subArgs);
+        case 'help':
+        default:
+            console.log(`\x1b[36mGargBot CLI\x1b[0m — Knowledge management commands\n`);
+            console.log('  aither gargbot chat <message>           Chat with GargBot');
+            console.log('  aither gargbot ingest <file-or-url>     Ingest a document or URL');
+            console.log('  echo "text" | aither gargbot ingest     Ingest from stdin');
+            console.log('  aither gargbot search <query>           Search knowledge base');
+            console.log('  aither gargbot status                   Show health & stats');
+            console.log('  aither gargbot sync-obsidian <path>     Sync Obsidian vault');
+            break;
+    }
+}

package/dist/jobs.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Background Job Manager for AitherShell.
+ *
+ * Allows long-running tasks (forge, swarm, chat with agents) to execute
+ * in the background while the REPL remains interactive. Jobs collect their
+ * output silently and notify the shell on completion.
+ *
+ * IMPORTANT: Background jobs NEVER write to stdout/stderr directly.
+ * All output is collected into job.output[] and read via /jobs <id>.
+ * This prevents background tasks from corrupting the interactive prompt.
+ */
+import type { GenesisClient, StreamChatOpts } from './client.js';
+export type JobStatus = 'running' | 'completed' | 'failed' | 'cancelled';
+export type JobKind = 'chat' | 'forge' | 'swarm' | 'command';
+export interface Job {
+    id: number;
+    kind: JobKind;
+    label: string;
+    status: JobStatus;
+    startedAt: Date;
+    finishedAt: Date | null;
+    output: string[];
+    error: string | null;
+    abortController: AbortController | null;
+}
+type NotifyFn = (job: Job) => void;
+/** Register a callback that fires when any background job completes. */
+export declare function setJobNotifier(fn: NotifyFn): void;
+/** Get all jobs (most recent first). */
+export declare function listJobs(): Job[];
+/** Get a single job by ID. */
+export declare function getJob(id: number): Job | undefined;
+/** Get count of currently running jobs. */
+export declare function runningCount(): number;
+/** Cancel a running job. */
+export declare function cancelJob(id: number): boolean;
+/** Prune completed/failed/cancelled jobs older than `maxAge` ms (default 30 min). */
+export declare function pruneJobs(maxAge?: number): number;
+/**
+ * Launch a streaming chat in the background.
+ * Returns the job immediately; the stream runs asynchronously.
+ *
+ * Consumes the SSE stream silently — no stdout writes, no spinners.
+ * Content and trace info are collected into job.output[].
+ */
+export declare function launchChatJob(client: GenesisClient, message: string, opts?: StreamChatOpts & {
+    label?: string;
+}): Job;
+export declare function launchForgeJob(client: GenesisClient, task: string, opts?: {
+    agent?: string;
+    effort?: number;
+}): Job;
+export declare function launchSwarmJob(client: GenesisClient, task: string, mode?: string): Job;
+/**
+ * Run an arbitrary async function as a background job.
+ * Replaces console.log within the function scope to capture output.
+ *
+ * WARNING: This uses global console.log replacement, so only ONE
+ * command job should run at a time. For concurrent background work,
+ * use the specific launchers (chat, forge, swarm) instead.
+ */
+export declare function launchCommandJob(label: string, fn: () => Promise<void>): Job;
+export declare function formatJobLine(job: Job): string;
+export declare function formatJobOutput(job: Job): string;
+export {};

package/dist/jobs.js

@@ -0,0 +1,386 @@
+/**
+ * Background Job Manager for AitherShell.
+ *
+ * Allows long-running tasks (forge, swarm, chat with agents) to execute
+ * in the background while the REPL remains interactive. Jobs collect their
+ * output silently and notify the shell on completion.
+ *
+ * IMPORTANT: Background jobs NEVER write to stdout/stderr directly.
+ * All output is collected into job.output[] and read via /jobs <id>.
+ * This prevents background tasks from corrupting the interactive prompt.
+ */
+import chalk from 'chalk';
+let nextJobId = 1;
+const jobs = new Map();
+let onJobDone = null;
+/** Register a callback that fires when any background job completes. */
+export function setJobNotifier(fn) {
+    onJobDone = fn;
+}
+/** Get all jobs (most recent first). */
+export function listJobs() {
+    return [...jobs.values()].reverse();
+}
+/** Get a single job by ID. */
+export function getJob(id) {
+    return jobs.get(id);
+}
+/** Get count of currently running jobs. */
+export function runningCount() {
+    let count = 0;
+    for (const j of jobs.values()) {
+        if (j.status === 'running')
+            count++;
+    }
+    return count;
+}
+/** Cancel a running job. */
+export function cancelJob(id) {
+    const job = jobs.get(id);
+    if (!job || job.status !== 'running')
+        return false;
+    if (job.abortController) {
+        job.abortController.abort();
+    }
+    job.status = 'cancelled';
+    job.finishedAt = new Date();
+    return true;
+}
+/** Prune completed/failed/cancelled jobs older than `maxAge` ms (default 30 min). */
+export function pruneJobs(maxAge = 30 * 60 * 1000) {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [id, job] of jobs) {
+        if (job.status !== 'running' && job.finishedAt && now - job.finishedAt.getTime() > maxAge) {
+            jobs.delete(id);
+            pruned++;
+        }
+    }
+    return pruned;
+}
+/* ── Job creation helpers ──────────────────────────────────── */
+function createJob(kind, label) {
+    const job = {
+        id: nextJobId++,
+        kind,
+        label,
+        status: 'running',
+        startedAt: new Date(),
+        finishedAt: null,
+        output: [],
+        error: null,
+        abortController: new AbortController(),
+    };
+    jobs.set(job.id, job);
+    return job;
+}
+function finishJob(job, status, error) {
+    job.status = status;
+    job.finishedAt = new Date();
+    job.error = error || null;
+    job.abortController = null;
+    onJobDone?.(job);
+}
+/* ── Silent SSE content extractor ─────────────────────────── */
+/**
+ * Extract the final text content from an SSE event stream without
+ * writing ANYTHING to stdout. No spinners, no progress — just data.
+ */
+function extractContentFromEvent(event) {
+    switch (event.type) {
+        case 'token':
+            return event.data.t || null;
+        case 'message':
+        case 'answer':
+        case 'final_answer':
+            return event.data.response || event.data.answer || event.data.content || null;
+        case 'partial':
+            return event.data.content || event.data.text || null;
+        case 'done':
+        case 'complete':
+            return event.data.content || null;
+        default:
+            return null;
+    }
+}
+/**
+ * Extract metadata/trace info from SSE events for the job log.
+ */
+function extractTraceFromEvent(event) {
+    switch (event.type) {
+        case 'thinking': {
+            const thought = event.data.thought || event.data.content || event.data.phase || '';
+            const clean = thought.replace(/<\/?think(?:ing)?>/g, '').trim();
+            if (clean.length > 10)
+                return `[think] ${clean.slice(0, 200)}`;
+            return null;
+        }
+        case 'tool_call': {
+            const tools = event.data.tools || event.data.tool_calls || [];
+            const names = tools.map((t) => t.name || t.function?.name || 'tool');
+            return names.length ? `[tools] ${names.join(', ')}` : null;
+        }
+        case 'tool_result': {
+            const results = event.data.results || [];
+            const summary = results.map((r) => {
+                const icon = r.success !== false ? '+' : 'x';
+                return `${icon}${r.tool || 'tool'}`;
+            });
+            return summary.length ? `[result] ${summary.join(', ')}` : null;
+        }
+        case 'plan_ready':
+            return event.data.summary ? `[plan] ${event.data.summary}` : null;
+        case 'error':
+            return `[error] ${event.data.error || 'unknown'}`;
+        case 'classify': {
+            const intent = event.data.intent?.type || '?';
+            const effort = event.data.effort?.level || '?';
+            return `[classify] intent=${intent} effort=${effort}`;
+        }
+        case 'classify_update': {
+            const uIntent = event.data.intent?.type || '?';
+            const uEffort = event.data.effort?.level || '?';
+            const uReason = event.data.reason || 'context';
+            return `[classify_update] intent=${uIntent} effort=${uEffort} reason=${uReason}`;
+        }
+        default:
+            return null;
+    }
+}
+/* ── Background chat ───────────────────────────────────────── */
+/**
+ * Launch a streaming chat in the background.
+ * Returns the job immediately; the stream runs asynchronously.
+ *
+ * Consumes the SSE stream silently — no stdout writes, no spinners.
+ * Content and trace info are collected into job.output[].
+ */
+export function launchChatJob(client, message, opts = {}) {
+    const label = opts.label || `Chat: ${message.slice(0, 50)}${message.length > 50 ? '...' : ''}`;
+    const job = createJob('chat', label);
+    const run = async () => {
+        const contentParts = [];
+        let fullAnswer = '';
+        // Each background chat gets its own session ID so concurrent jobs
+        // don't clobber each other's context on Genesis.
+        const bgSessionId = `${opts.sessionId || 'shell'}-bg-${job.id}-${Date.now().toString(36)}`;
+        try {
+            const stream = client.streamChat(message, {
+                ...opts,
+                sessionId: bgSessionId,
+                priority: 'background',
+                signal: job.abortController.signal,
+            });
+            for await (const event of stream) {
+                // Collect content tokens
+                const content = extractContentFromEvent(event);
+                if (content) {
+                    // Token events are incremental, answer/message events are full text
+                    if (event.type === 'token') {
+                        contentParts.push(content);
+                    }
+                    else {
+                        fullAnswer = content;
+                    }
+                }
+                // Collect trace info for the job log
+                const trace = extractTraceFromEvent(event);
+                if (trace) {
+                    job.output.push(trace);
+                }
+                // Extract metadata from done/complete
+                if (event.type === 'done' || event.type === 'complete') {
+                    const meta = [];
+                    if (event.data.model || event.data.model_used)
+                        meta.push(event.data.model || event.data.model_used);
+                    if (event.data.duration_ms || event.data.elapsed_ms) {
+                        meta.push(`${Math.round(event.data.duration_ms || event.data.elapsed_ms)}ms`);
+                    }
+                    if (event.data.turns_completed)
+                        meta.push(`${event.data.turns_completed} turns`);
+                    if (meta.length) {
+                        job.output.push(`[meta] ${meta.join(' | ')}`);
+                    }
+                }
+            }
+            // Use full answer if available, otherwise join tokens
+            const finalContent = fullAnswer || contentParts.join('');
+            if (finalContent) {
+                job.output.push('---'); // separator between trace and content
+                job.output.push(finalContent);
+            }
+            finishJob(job, 'completed');
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                const partial = fullAnswer || contentParts.join('');
+                if (partial) {
+                    job.output.push('---');
+                    job.output.push(partial);
+                    job.output.push('(cancelled — partial output above)');
+                }
+                finishJob(job, 'cancelled');
+            }
+            else {
+                finishJob(job, 'failed', err.message);
+            }
+        }
+    };
+    run().catch((err) => {
+        finishJob(job, 'failed', err.message);
+    });
+    return job;
+}
+/* ── Background forge ──────────────────────────────────────── */
+export function launchForgeJob(client, task, opts = {}) {
+    const label = opts.agent
+        ? `Forge @${opts.agent}: ${task.slice(0, 40)}...`
+        : `Forge: ${task.slice(0, 50)}...`;
+    const job = createJob('forge', label);
+    const run = async () => {
+        try {
+            const result = await client.forgeDispatch(task, opts);
+            if (result?.error) {
+                job.output.push(result.error);
+                finishJob(job, 'failed', result.error);
+            }
+            else {
+                const output = result?.response || result?.result || result?.output;
+                job.output.push(output || JSON.stringify(result, null, 2));
+                finishJob(job, 'completed');
+            }
+        }
+        catch (err) {
+            finishJob(job, 'failed', err.message);
+        }
+    };
+    run().catch((err) => finishJob(job, 'failed', err.message));
+    return job;
+}
+/* ── Background swarm ──────────────────────────────────────── */
+export function launchSwarmJob(client, task, mode = 'llm') {
+    const label = `Swarm (${mode}): ${task.slice(0, 40)}...`;
+    const job = createJob('swarm', label);
+    const run = async () => {
+        try {
+            const result = await client.post('/swarm/code/sync', { problem: task, mode });
+            if (result?.error) {
+                job.output.push(result.error);
+                finishJob(job, 'failed', result.error);
+            }
+            else {
+                const output = result?.result || result?.plan || result?.response;
+                job.output.push(typeof output === 'string' ? output : JSON.stringify(output, null, 2));
+                finishJob(job, 'completed');
+            }
+        }
+        catch (err) {
+            finishJob(job, 'failed', err.message);
+        }
+    };
+    run().catch((err) => finishJob(job, 'failed', err.message));
+    return job;
+}
+/* ── Background command ────────────────────────────────────── */
+/**
+ * Run an arbitrary async function as a background job.
+ * Replaces console.log within the function scope to capture output.
+ *
+ * WARNING: This uses global console.log replacement, so only ONE
+ * command job should run at a time. For concurrent background work,
+ * use the specific launchers (chat, forge, swarm) instead.
+ */
+export function launchCommandJob(label, fn) {
+    const job = createJob('command', label);
+    const run = async () => {
+        const origLog = console.log;
+        const origError = console.error;
+        const origWarn = console.warn;
+        const origWrite = process.stdout.write;
+        const capture = (...args) => {
+            const line = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+            job.output.push(line);
+        };
+        const captureWrite = (chunk) => {
+            const text = typeof chunk === 'string' ? chunk : chunk.toString();
+            if (text.trim())
+                job.output.push(text);
+            return true;
+        };
+        // Replace all output channels
+        console.log = capture;
+        console.error = capture;
+        console.warn = capture;
+        process.stdout.write = captureWrite;
+        try {
+            await fn();
+            finishJob(job, 'completed');
+        }
+        catch (err) {
+            finishJob(job, 'failed', err.message);
+        }
+        finally {
+            // Always restore — even if the fn throws
+            console.log = origLog;
+            console.error = origError;
+            console.warn = origWarn;
+            process.stdout.write = origWrite;
+        }
+    };
+    run().catch((err) => {
+        finishJob(job, 'failed', err.message);
+    });
+    return job;
+}
+/* ── Formatting helpers ────────────────────────────────────── */
+export function formatJobLine(job) {
+    const icons = {
+        running: chalk.blue('\u25B6'),
+        completed: chalk.green('\u2713'),
+        failed: chalk.red('\u2717'),
+        cancelled: chalk.yellow('\u2015'),
+    };
+    const icon = icons[job.status];
+    const id = chalk.bold(`#${job.id}`);
+    const elapsed = formatElapsed(job);
+    const status = job.status === 'running'
+        ? chalk.blue(job.status)
+        : job.status === 'completed'
+            ? chalk.green(job.status)
+            : job.status === 'failed'
+                ? chalk.red(job.status)
+                : chalk.yellow(job.status);
+    return `  ${icon} ${id} ${status} ${chalk.dim(elapsed)} ${job.label}`;
+}
+function formatElapsed(job) {
+    const end = job.finishedAt || new Date();
+    const ms = end.getTime() - job.startedAt.getTime();
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60_000)}m${Math.round((ms % 60_000) / 1000)}s`;
+}
+export function formatJobOutput(job) {
+    const lines = [];
+    lines.push(chalk.bold(`\n  Job #${job.id}: ${job.label}`));
+    lines.push(chalk.dim(`  Status: ${job.status} | Started: ${job.startedAt.toLocaleTimeString()}`));
+    if (job.finishedAt) {
+        lines.push(chalk.dim(`  Finished: ${job.finishedAt.toLocaleTimeString()} (${formatElapsed(job)})`));
+    }
+    if (job.error) {
+        lines.push(chalk.red(`  Error: ${job.error}`));
+    }
+    if (job.output.length > 0) {
+        lines.push('');
+        const outputLines = job.output.join('\n').split('\n');
+        for (const line of outputLines) {
+            lines.push(`  ${line}`);
+        }
+    }
+    else if (job.status === 'running') {
+        lines.push(chalk.dim('  (no output yet)'));
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};