@aaronsb/kg-cli 0.6.1

package/dist/cli/jobs.js

@@ -0,0 +1,663 @@
+"use strict";
+/**
+ * Job management commands
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jobsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const client_1 = require("../api/client");
+const colors = __importStar(require("./colors"));
+const table_1 = require("../lib/table");
+const help_formatter_1 = require("./help-formatter");
+exports.jobsCommand = (0, help_formatter_1.setCommandHelp)(new commander_1.Command('job'), 'Manage and monitor ingestion jobs', 'Manage and monitor ingestion jobs through their lifecycle (pending → approval → processing → completed/failed)')
+    .alias('jobs') // Plural alias for backwards compatibility
+    .showHelpAfterError('(add --help for additional information)')
+    .showSuggestionAfterError();
+// Get job status
+exports.jobsCommand
+    .command('status <job-id>')
+    .description('Get detailed status information for a job (progress, costs, errors) - use --watch to poll until completion')
+    .showHelpAfterError()
+    .option('-w, --watch', 'Watch job until completion (polls every few seconds)', false)
+    .action(async (jobId, options) => {
+    try {
+        const client = (0, client_1.createClientFromEnv)();
+        if (options.watch) {
+            // Poll until completion
+            console.log(chalk_1.default.blue(`Watching job ${jobId}...`));
+            console.log(chalk_1.default.gray('Press Ctrl+C to stop\n'));
+            const finalJob = await client.pollJob(jobId, (job) => {
+                // Clear line and rewrite
+                process.stdout.write('\r\x1b[K'); // Clear line
+                if (job.status === 'queued') {
+                    process.stdout.write(chalk_1.default.yellow(`Status: ${job.status}`));
+                }
+                else if (job.status === 'processing' && job.progress) {
+                    const p = job.progress;
+                    if (p.percent !== undefined) {
+                        const conceptsTotal = (p.concepts_created || 0) + (p.concepts_linked || 0);
+                        const hitRate = conceptsTotal > 0 ? Math.round((p.concepts_linked || 0) / conceptsTotal * 100) : 0;
+                        process.stdout.write(chalk_1.default.blue(`Processing: ${p.percent}% `) +
+                            chalk_1.default.gray(`(${p.chunks_processed}/${p.chunks_total} chunks) `) +
+                            chalk_1.default.gray(`| Concepts: ${conceptsTotal} (${hitRate}% reused) `) +
+                            chalk_1.default.gray(`| Rels: ${p.relationships_created || 0}`));
+                    }
+                    else {
+                        process.stdout.write(chalk_1.default.blue(`Processing: ${p.stage}`));
+                    }
+                }
+            });
+            console.log(); // New line after polling
+            printJobStatus(finalJob);
+        }
+        else {
+            // Single fetch
+            const job = await client.getJob(jobId);
+            printJobStatus(job);
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('\n✗ Failed to get job status'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// Helper function to display jobs list using Table utility
+async function displayJobsList(status, clientId, limit = 20, fullId = false, offset = 0) {
+    const client = (0, client_1.createClientFromEnv)();
+    const jobs = await client.listJobs(status, clientId, limit, offset);
+    if (jobs.length === 0) {
+        console.log(colors.status.dim('\nNo jobs found\n'));
+        return;
+    }
+    // Create table with dynamic configuration
+    const table = new table_1.Table({
+        columns: [
+            {
+                header: 'Job ID',
+                field: 'job_id',
+                type: 'job_id',
+                width: fullId ? 38 : 16, // Fixed width - job IDs are consistent length
+                truncate: false
+            },
+            {
+                header: 'Source',
+                field: (job) => job.source_path || job.filename || '-',
+                type: 'text',
+                width: 'flex',
+                priority: 10, // Highest priority - gets most space
+                customFormat: (source, job) => {
+                    if (!source || source === '-')
+                        return colors.status.dim('-');
+                    return source;
+                },
+                truncate: true
+            },
+            {
+                header: 'User',
+                field: 'username',
+                type: 'user',
+                width: 'auto', // Fit to content
+                maxWidth: 12,
+                customFormat: (username) => username || 'unknown',
+                truncate: true
+            },
+            {
+                header: 'Status',
+                field: 'status',
+                type: 'text', // Use custom formatting instead of status type
+                width: 8, // Fixed width for compact status
+                customFormat: (status) => {
+                    // Compact status - just icons for terminal states
+                    switch (status) {
+                        case 'completed': return colors.status.success('✓ done');
+                        case 'failed': return colors.status.error('✗ fail');
+                        case 'running': return colors.status.info('⚙ run');
+                        case 'processing': return colors.status.info('⚙ run');
+                        case 'approved': return colors.status.success('✓ ok');
+                        case 'awaiting_approval': return colors.status.warning('⏸ wait');
+                        case 'pending': return colors.status.dim('○ pend');
+                        case 'queued': return colors.status.info('⋯ queue');
+                        case 'cancelled': return colors.status.dim('⊗ stop');
+                        default: return colors.status.dim(status);
+                    }
+                },
+                truncate: false
+            },
+            {
+                header: 'Ontology',
+                field: 'ontology',
+                type: 'heading',
+                width: 'flex',
+                priority: 3, // Lower priority than Source
+                customFormat: (name) => name || '-',
+                truncate: true
+            },
+            {
+                header: 'Created',
+                field: 'created_at',
+                type: 'timestamp',
+                width: 16 // Timestamp is consistent width
+            },
+            {
+                header: '', // No header for progress icon
+                field: (job) => job.progress?.percent,
+                type: 'progress',
+                width: 1, // Just the icon
+                customFormat: (percent, job) => {
+                    // Just icons, no text
+                    if (job.status === 'completed')
+                        return '✓';
+                    if (job.status === 'failed')
+                        return '✗';
+                    if (job.status === 'cancelled')
+                        return '⊗';
+                    return percent !== undefined && percent < 100 ? '⋯' : ' ';
+                },
+                truncate: false
+            }
+        ],
+        spacing: 1, // Tighter spacing between columns
+        showHeader: true,
+        showSeparator: true
+    });
+    // Render table
+    table.print(jobs);
+    // Helpful tip
+    if (!fullId && jobs.length > 0) {
+        console.log(colors.status.dim('Tip: Use --full-id to show complete job IDs\n'));
+    }
+}
+// List command with subcommands
+const listCommand = new commander_1.Command('list')
+    .description('List recent jobs with optional filtering by status or user - includes subcommands for common filters')
+    .option('-s, --status <status>', 'Filter by status (pending|awaiting_approval|approved|queued|processing|completed|failed|cancelled)')
+    .option('-c, --client <user-id>', 'Filter by user ID (view specific user\'s jobs)')
+    .option('-l, --limit <n>', 'Maximum jobs to return (max: 500, default: 100)', '100')
+    .option('-o, --offset <n>', 'Number of jobs to skip for pagination (default: 0)', '0')
+    .option('--full-id', 'Show full job IDs without truncation', false)
+    .showHelpAfterError()
+    .action(async (options) => {
+    try {
+        const limit = parseInt(options.limit);
+        const offset = parseInt(options.offset);
+        await displayJobsList(options.status, options.client, limit, options.fullId, offset);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// List subcommands for common filters
+listCommand
+    .command('pending')
+    .description('List jobs awaiting approval')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to return', '20')
+    .option('--full-id', 'Show full job IDs (no truncation)', false)
+    .action(async (options) => {
+    try {
+        console.log(chalk_1.default.blue('Jobs awaiting approval:\n'));
+        await displayJobsList('awaiting_approval', options.client, parseInt(options.limit), options.fullId);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+listCommand
+    .command('approved')
+    .description('List approved jobs (queued or processing)')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to return', '20')
+    .option('--full-id', 'Show full job IDs (no truncation)', false)
+    .action(async (options) => {
+    try {
+        console.log(chalk_1.default.blue('Approved jobs:\n'));
+        await displayJobsList('approved', options.client, parseInt(options.limit), options.fullId);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+listCommand
+    .command('done')
+    .description('List completed jobs')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to return', '20')
+    .option('--full-id', 'Show full job IDs (no truncation)', false)
+    .action(async (options) => {
+    try {
+        console.log(chalk_1.default.green('Completed jobs:\n'));
+        await displayJobsList('completed', options.client, parseInt(options.limit), options.fullId);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+listCommand
+    .command('failed')
+    .description('List failed jobs')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to return', '20')
+    .option('--full-id', 'Show full job IDs (no truncation)', false)
+    .action(async (options) => {
+    try {
+        console.log(chalk_1.default.red('Failed jobs:\n'));
+        await displayJobsList('failed', options.client, parseInt(options.limit), options.fullId);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+listCommand
+    .command('cancelled')
+    .description('List cancelled jobs')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to return', '20')
+    .option('--full-id', 'Show full job IDs (no truncation)', false)
+    .action(async (options) => {
+    try {
+        console.log(chalk_1.default.yellow('Cancelled jobs:\n'));
+        await displayJobsList('cancelled', options.client, parseInt(options.limit), options.fullId);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to list jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// Add list command to jobs
+exports.jobsCommand.addCommand(listCommand);
+// Approve job(s) (ADR-014)
+const approveCommand = new commander_1.Command('approve')
+    .description('Approve jobs for processing (ADR-014 approval workflow) - single job, batch pending, or filter by status')
+    .showHelpAfterError();
+// Approve single job
+approveCommand
+    .command('job <job-id>')
+    .description('Approve a specific job by ID after reviewing cost estimates')
+    .action(async (jobId) => {
+    try {
+        const client = (0, client_1.createClientFromEnv)();
+        console.log(chalk_1.default.blue(`Approving job ${jobId}...`));
+        const result = await client.approveJob(jobId);
+        console.log(chalk_1.default.green('✓ Job approved'));
+        console.log(chalk_1.default.gray(`  Status: ${result.status}`));
+        console.log(chalk_1.default.gray(`\nMonitor: ${chalk_1.default.cyan(`kg jobs status ${jobId} --watch`)}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to approve job'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// Approve all pending jobs
+approveCommand
+    .command('pending')
+    .description('Approve all jobs awaiting approval (batch operation with confirmation)')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .option('-l, --limit <n>', 'Maximum jobs to approve (default: 100)', '100')
+    .action(async (options) => {
+    try {
+        const client = (0, client_1.createClientFromEnv)();
+        console.log(chalk_1.default.blue('Finding jobs awaiting approval...\n'));
+        const jobs = await client.listJobs('awaiting_approval', options.client, parseInt(options.limit));
+        if (jobs.length === 0) {
+            console.log(chalk_1.default.gray('No pending jobs found'));
+            return;
+        }
+        console.log(chalk_1.default.blue(`Found ${jobs.length} pending job(s):\n`));
+        let approved = 0;
+        let failed = 0;
+        for (const job of jobs) {
+            try {
+                await client.approveJob(job.job_id);
+                console.log(chalk_1.default.green(`✓ Approved: ${job.job_id.substring(0, 12)}... (${job.ontology || 'unknown'})`));
+                approved++;
+            }
+            catch (error) {
+                console.log(chalk_1.default.red(`✗ Failed: ${job.job_id.substring(0, 12)}... - ${error.message}`));
+                failed++;
+            }
+        }
+        console.log(chalk_1.default.blue(`\nSummary: ${approved} approved, ${failed} failed`));
+        console.log(chalk_1.default.gray(`\nMonitor jobs: ${chalk_1.default.cyan('kg jobs list')}`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to approve pending jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// Legacy: approve with ID or filter
+approveCommand
+    .command('filter <status>')
+    .description('Approve all jobs matching status filter')
+    .option('-c, --client <user-id>', 'Filter by user ID')
+    .action(async (statusFilter, options) => {
+    try {
+        const client = (0, client_1.createClientFromEnv)();
+        const statusMap = {
+            'pending': 'awaiting_approval',
+            'awaiting': 'awaiting_approval',
+        };
+        const status = statusMap[statusFilter] || statusFilter;
+        console.log(chalk_1.default.blue(`Finding jobs with status: ${status}...\n`));
+        const jobs = await client.listJobs(status, options.client, 100);
+        if (jobs.length === 0) {
+            console.log(chalk_1.default.gray('No jobs found matching filter'));
+            return;
+        }
+        console.log(chalk_1.default.blue(`Found ${jobs.length} job(s). Approving...\n`));
+        let approved = 0;
+        let failed = 0;
+        for (const job of jobs) {
+            try {
+                await client.approveJob(job.job_id);
+                console.log(chalk_1.default.green(`✓ Approved: ${job.job_id.substring(0, 12)}... (${job.ontology || 'unknown'})`));
+                approved++;
+            }
+            catch (error) {
+                console.log(chalk_1.default.red(`✗ Failed: ${job.job_id.substring(0, 12)}... - ${error.message}`));
+                failed++;
+            }
+        }
+        console.log(chalk_1.default.blue(`\nSummary: ${approved} approved, ${failed} failed`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to approve jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+exports.jobsCommand.addCommand(approveCommand);
+// Cancel job(s)
+exports.jobsCommand
+    .command('cancel <job-id-or-filter>')
+    .description('Cancel a specific job by ID or batch cancel using filters (all, pending, running, queued, approved)')
+    .showHelpAfterError()
+    .option('-c, --client <user-id>', 'Filter by user ID for batch operations')
+    .option('-l, --limit <n>', 'Maximum jobs to cancel for safety (default: 100)', '100')
+    .action(async (jobIdOrFilter, options) => {
+    try {
+        const client = (0, client_1.createClientFromEnv)();
+        const limit = parseInt(options.limit);
+        // Check if it's a job ID or a status filter
+        if (jobIdOrFilter.startsWith('job_')) {
+            // Single job cancellation
+            console.log(chalk_1.default.blue(`Cancelling job ${jobIdOrFilter}...`));
+            const result = await client.cancelJob(jobIdOrFilter);
+            if (result.cancelled) {
+                console.log(chalk_1.default.green('✓ Job cancelled'));
+            }
+            else {
+                console.log(chalk_1.default.yellow('⚠ Job could not be cancelled'));
+            }
+        }
+        else {
+            // Batch cancellation by status filter
+            const statusMap = {
+                'all': undefined, // No filter = all jobs
+                'pending': 'awaiting_approval',
+                'awaiting': 'awaiting_approval',
+                'approved': 'approved',
+                'queued': 'queued',
+                'running': 'processing',
+                'processing': 'processing',
+            };
+            const filter = jobIdOrFilter.toLowerCase();
+            // Check if it's a known filter
+            if (!(filter in statusMap)) {
+                console.error(chalk_1.default.red(`✗ Unknown filter: "${jobIdOrFilter}"`));
+                console.error(chalk_1.default.gray('\nSupported filters:'));
+                console.error(chalk_1.default.gray('  all        - All cancellable jobs'));
+                console.error(chalk_1.default.gray('  pending    - Jobs awaiting approval'));
+                console.error(chalk_1.default.gray('  approved   - Approved jobs (not yet started)'));
+                console.error(chalk_1.default.gray('  queued     - Queued jobs'));
+                console.error(chalk_1.default.gray('  running    - Currently processing jobs'));
+                process.exit(1);
+            }
+            const status = statusMap[filter];
+            const filterDisplay = status || 'all cancellable jobs';
+            console.log(chalk_1.default.blue(`Finding ${filterDisplay}...`));
+            const jobs = await client.listJobs(status, options.client, limit);
+            if (jobs.length === 0) {
+                console.log(chalk_1.default.gray(`No jobs found matching filter: ${jobIdOrFilter}`));
+                return;
+            }
+            // Filter to only cancellable statuses (not completed, failed, or already cancelled)
+            const cancellableStatuses = ['awaiting_approval', 'approved', 'queued', 'processing'];
+            const cancellableJobs = jobs.filter(j => cancellableStatuses.includes(j.status));
+            if (cancellableJobs.length === 0) {
+                console.log(chalk_1.default.yellow(`Found ${jobs.length} job(s), but none are cancellable`));
+                console.log(chalk_1.default.gray('Only jobs in these states can be cancelled: awaiting_approval, approved, queued, processing'));
+                return;
+            }
+            if (cancellableJobs.length < jobs.length) {
+                console.log(chalk_1.default.yellow(`Found ${jobs.length} job(s), ${cancellableJobs.length} are cancellable\n`));
+            }
+            else {
+                console.log(chalk_1.default.blue(`Found ${cancellableJobs.length} job(s). Cancelling...\n`));
+            }
+            let cancelled = 0;
+            let failed = 0;
+            for (const job of cancellableJobs) {
+                try {
+                    await client.cancelJob(job.job_id);
+                    console.log(chalk_1.default.yellow(`✓ Cancelled: ${job.job_id.substring(0, 12)}... (${job.status}) - ${job.ontology || 'N/A'}`));
+                    cancelled++;
+                }
+                catch (error) {
+                    const errorMsg = error.response?.data?.detail || error.message || 'Unknown error';
+                    console.log(chalk_1.default.red(`✗ Failed: ${job.job_id.substring(0, 12)}... - ${errorMsg}`));
+                    failed++;
+                }
+            }
+            console.log(chalk_1.default.blue(`\nSummary: ${cancelled} cancelled, ${failed} failed`));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to cancel job(s)'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+// Clear all jobs
+exports.jobsCommand
+    .command('clear')
+    .description('Clear ALL jobs from database - DESTRUCTIVE operation requiring --confirm flag (use for dev/testing cleanup)')
+    .option('--confirm', 'Confirm deletion (REQUIRED for safety)', false)
+    .showHelpAfterError()
+    .action(async (options) => {
+    try {
+        if (!options.confirm) {
+            console.error(chalk_1.default.red('✗ Confirmation required'));
+            console.error(chalk_1.default.yellow('\n⚠️  This will DELETE ALL jobs from the database!'));
+            console.error(chalk_1.default.gray('\nTo confirm, run: ') + chalk_1.default.cyan('kg jobs clear --confirm'));
+            process.exit(1);
+        }
+        const client = (0, client_1.createClientFromEnv)();
+        console.log(chalk_1.default.yellow('\n⚠️  Clearing ALL jobs from database...'));
+        const result = await client.clearAllJobs(true);
+        console.log(chalk_1.default.green(`\n✓ ${result.message}`));
+        console.log(chalk_1.default.gray(`  Jobs deleted: ${result.jobs_deleted}\n`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red('✗ Failed to clear jobs'));
+        console.error(chalk_1.default.red(error.response?.data?.detail || error.message));
+        process.exit(1);
+    }
+});
+/**
+ * Print detailed job status
+ */
+function printJobStatus(job) {
+    console.log(chalk_1.default.blue('\nJob Status:'));
+    console.log(chalk_1.default.gray(`  ID: ${job.job_id}`));
+    console.log(chalk_1.default.gray(`  Type: ${job.job_type}`));
+    // Format job status with icons
+    let statusDisplay = job.status;
+    switch (job.status) {
+        case 'completed':
+            statusDisplay = colors.status.success('✓ completed');
+            break;
+        case 'failed':
+            statusDisplay = colors.status.error('✗ failed');
+            break;
+        case 'processing':
+            statusDisplay = colors.status.info('⚙ processing');
+            break;
+        case 'approved':
+            statusDisplay = colors.status.success('✓ approved');
+            break;
+        case 'awaiting_approval':
+            statusDisplay = colors.status.warning('⏸ awaiting approval');
+            break;
+        case 'pending':
+            statusDisplay = colors.status.dim('○ pending');
+            break;
+        case 'queued':
+            statusDisplay = colors.status.info('⋯ queued');
+            break;
+        case 'cancelled':
+            statusDisplay = colors.status.dim('⊗ cancelled');
+            break;
+        default:
+            statusDisplay = colors.status.dim(job.status);
+    }
+    console.log(`  Status: ${statusDisplay}`);
+    if (job.ontology) {
+        console.log(chalk_1.default.gray(`  Ontology: ${job.ontology}`));
+    }
+    console.log(chalk_1.default.gray(`  Created: ${new Date(job.created_at).toLocaleString()}`));
+    if (job.started_at) {
+        console.log(chalk_1.default.gray(`  Started: ${new Date(job.started_at).toLocaleString()}`));
+    }
+    if (job.completed_at) {
+        console.log(chalk_1.default.gray(`  Completed: ${new Date(job.completed_at).toLocaleString()}`));
+        const duration = (new Date(job.completed_at).getTime() - new Date(job.created_at).getTime()) / 1000;
+        console.log(chalk_1.default.gray(`  Duration: ${duration.toFixed(1)}s`));
+    }
+    // ADR-014: Show analysis when available
+    if (job.analysis) {
+        console.log(chalk_1.default.blue('\nPre-Ingestion Analysis:'));
+        const a = job.analysis;
+        if (a.file_stats) {
+            console.log(chalk_1.default.gray(`  File: ${a.file_stats.filename} (${a.file_stats.size_human})`));
+            console.log(chalk_1.default.gray(`  Words: ${a.file_stats.word_count.toLocaleString()}`));
+            console.log(chalk_1.default.gray(`  Estimated chunks: ~${a.file_stats.estimated_chunks}`));
+        }
+        if (a.cost_estimate) {
+            console.log(chalk_1.default.blue('\n💰 Cost Estimate:'));
+            const ce = a.cost_estimate;
+            console.log(chalk_1.default.gray(`  Extraction (${ce.extraction.model}):`));
+            console.log(chalk_1.default.gray(`    Tokens: ${ce.extraction.tokens_low.toLocaleString()}-${ce.extraction.tokens_high.toLocaleString()}`));
+            console.log(chalk_1.default.gray(`    Cost: $${ce.extraction.cost_low.toFixed(2)}-$${ce.extraction.cost_high.toFixed(2)}`));
+            console.log(chalk_1.default.gray(`  Embeddings (${ce.embeddings.model}):`));
+            console.log(chalk_1.default.gray(`    Concepts: ${ce.embeddings.concepts_low}-${ce.embeddings.concepts_high}`));
+            console.log(chalk_1.default.gray(`    Cost: $${ce.embeddings.cost_low.toFixed(2)}-$${ce.embeddings.cost_high.toFixed(2)}`));
+            console.log(chalk_1.default.bold(`  Total: $${ce.total.cost_low.toFixed(2)}-$${ce.total.cost_high.toFixed(2)}`));
+        }
+        if (a.warnings && a.warnings.length > 0) {
+            console.log(chalk_1.default.yellow('\n⚠️  Warnings:'));
+            a.warnings.forEach((w) => console.log(chalk_1.default.yellow(`  • ${w}`)));
+        }
+        if (job.status === 'awaiting_approval') {
+            console.log(chalk_1.default.blue('\n📌 Next Steps:'));
+            console.log(chalk_1.default.gray(`  Approve: kg jobs approve ${job.job_id}`));
+            console.log(chalk_1.default.gray(`  Cancel:  kg jobs cancel ${job.job_id}`));
+        }
+    }
+    if (job.progress) {
+        console.log(chalk_1.default.blue('\nProgress:'));
+        const p = job.progress;
+        if (p.percent !== undefined) {
+            console.log(chalk_1.default.gray(`  ${p.percent}% complete`));
+        }
+        if (p.chunks_total) {
+            console.log(chalk_1.default.gray(`  Chunks: ${p.chunks_processed}/${p.chunks_total}`));
+        }
+        // Concept statistics
+        const conceptsNew = p.concepts_created || 0;
+        const conceptsLinked = p.concepts_linked || 0;
+        const conceptsTotal = conceptsNew + conceptsLinked;
+        if (conceptsTotal > 0) {
+            const hitRate = Math.round((conceptsLinked / conceptsTotal) * 100);
+            console.log(chalk_1.default.gray(`  Concepts: ${conceptsTotal} total (${conceptsNew} new, ${conceptsLinked} reused)`));
+            console.log(chalk_1.default.gray(`  Hit rate: ${hitRate}% (existing concepts reused)`));
+        }
+        if (p.instances_created) {
+            console.log(chalk_1.default.gray(`  Instances: ${p.instances_created}`));
+        }
+        if (p.relationships_created) {
+            console.log(chalk_1.default.gray(`  Relationships: ${p.relationships_created}`));
+        }
+    }
+    if (job.result) {
+        console.log(chalk_1.default.blue('\nResults:'));
+        const r = job.result;
+        if (r.stats) {
+            console.log(chalk_1.default.gray(`  Chunks processed: ${r.stats.chunks_processed}`));
+            console.log(chalk_1.default.gray(`  Concepts created: ${r.stats.concepts_created}`));
+            console.log(chalk_1.default.gray(`  Sources created: ${r.stats.sources_created}`));
+            console.log(chalk_1.default.gray(`  Relationships: ${r.stats.relationships_created}`));
+        }
+        if (r.cost) {
+            console.log(chalk_1.default.blue('\nCost:'));
+            console.log(chalk_1.default.gray(`  Extraction: ${r.cost.extraction}`));
+            console.log(chalk_1.default.gray(`  Embeddings: ${r.cost.embeddings}`));
+            console.log(chalk_1.default.gray(`  Total: ${r.cost.total}`));
+        }
+    }
+    if (job.error) {
+        console.log(chalk_1.default.red('\nError:'));
+        console.log(chalk_1.default.red(`  ${job.error}`));
+    }
+}
+//# sourceMappingURL=jobs.js.map