@kaelio/ktx 0.0.0 → 0.1.0-rc.1

package/dist/context-build-view.js

@@ -0,0 +1,868 @@
+import { publicDatabaseIngestMessage, publicQueryHistoryMessage } from './public-ingest-copy.js';
+import { buildPublicIngestPlan, executePublicIngestTarget } from './public-ingest.js';
+import { formatDuration } from './demo-metrics.js';
+import { profileMark } from './startup-profile.js';
+profileMark('module:context-build-view');
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const ESC = String.fromCharCode(0x1b);
+const PHASE_LABELS = {
+    'database-schema': 'Schema',
+    'query-history': 'Query history',
+    'source-ingest': 'Source ingest',
+};
+function makePhasesForTarget(target) {
+    const make = (key) => ({
+        key,
+        name: PHASE_LABELS[key],
+        status: 'queued',
+        percent: 0,
+        detail: null,
+        summary: null,
+        startedAt: null,
+        elapsedMs: 0,
+        progressUpdatedAtMs: null,
+    });
+    if (target.operation === 'database-ingest') {
+        const phases = [make('database-schema')];
+        if (target.queryHistory?.enabled === true) {
+            phases.push(make('query-history'));
+        }
+        return phases;
+    }
+    return [make('source-ingest')];
+}
+// --- Rendering ---
+function green(text) {
+    return `${ESC}[32m${text}${ESC}[39m`;
+}
+function red(text) {
+    return `${ESC}[31m${text}${ESC}[39m`;
+}
+function cyan(text) {
+    return `${ESC}[36m${text}${ESC}[39m`;
+}
+function dim(text) {
+    return `${ESC}[2m${text}${ESC}[22m`;
+}
+function statusIcon(status, frame, styled) {
+    if (!styled) {
+        switch (status) {
+            case 'done':
+                return '✓';
+            case 'failed':
+                return '✗';
+            case 'running':
+                return SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? '⠋';
+            default:
+                return '○';
+        }
+    }
+    switch (status) {
+        case 'done':
+            return green('✓');
+        case 'failed':
+            return red('✗');
+        case 'running':
+            return cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? '⠋');
+        default:
+            return dim('○');
+    }
+}
+function phaseStatusIcon(status, frame, styled) {
+    const raw = (() => {
+        switch (status) {
+            case 'done':
+                return '✓';
+            case 'failed':
+                return '✗';
+            case 'running':
+                return SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? '⠋';
+            case 'skipped':
+                return '·';
+            default:
+                return '○';
+        }
+    })();
+    if (!styled)
+        return raw;
+    switch (status) {
+        case 'done':
+            return green(raw);
+        case 'failed':
+            return red(raw);
+        case 'running':
+            return cyan(raw);
+        default:
+            return dim(raw);
+    }
+}
+function extractPercent(detailLine) {
+    if (!detailLine)
+        return null;
+    const match = detailLine.match(/^\[(\d+)%\]/);
+    return match ? Number(match[1]) : null;
+}
+const BAR_WIDTH = 12;
+const BAR_FILLED = '█';
+const BAR_EMPTY = '░';
+const STALE_PROGRESS_UPDATE_MS = 30_000;
+function renderProgressBar(percent, styled) {
+    const filled = Math.round((percent / 100) * BAR_WIDTH);
+    const empty = BAR_WIDTH - filled;
+    const bar = `${BAR_FILLED.repeat(filled)}${BAR_EMPTY.repeat(empty)}`;
+    return styled ? cyan(bar) : bar;
+}
+function staleProgressText(target, styled) {
+    if (target.startedAt === null || target.progressUpdatedAtMs === null || target.elapsedMs <= 0) {
+        return null;
+    }
+    const currentTimeMs = target.startedAt + target.elapsedMs;
+    const staleMs = currentTimeMs - target.progressUpdatedAtMs;
+    if (staleMs < STALE_PROGRESS_UPDATE_MS) {
+        return null;
+    }
+    const text = `last update ${formatDuration(staleMs)} ago`;
+    return styled ? dim(text) : text;
+}
+function targetDetail(target, styled, options) {
+    if (target.status === 'done') {
+        const parts = [];
+        if (target.summaryText)
+            parts.push(target.summaryText);
+        parts.push(formatDuration(target.elapsedMs));
+        return parts.join(' · ');
+    }
+    if (target.status === 'failed') {
+        const failureText = target.failureText ?? 'failed';
+        return styled ? red(failureText) : failureText;
+    }
+    if (target.status === 'running') {
+        const percent = extractPercent(target.detailLine);
+        const progressText = target.detailLine?.replace(/^\[\d+%\]\s*/, '') ??
+            (target.target.operation === 'database-ingest'
+                ? (options.scanRunningText ?? 'reading schema')
+                : (options.sourceIngestRunningText ?? 'ingesting...'));
+        const elapsed = target.elapsedMs > 0 ? `(${formatDuration(target.elapsedMs)})` : null;
+        const parts = [];
+        if (percent !== null) {
+            parts.push(`${renderProgressBar(percent, styled)} ${percent}%`);
+        }
+        parts.push(progressText);
+        const stale = staleProgressText(target, styled);
+        if (stale)
+            parts.push(stale);
+        if (elapsed)
+            parts.push(styled ? dim(elapsed) : elapsed);
+        return parts.join('  ');
+    }
+    return styled ? dim('queued') : 'queued';
+}
+const PHASE_NAME_WIDTH = 14;
+function renderRunningTargetHeaderDetail(target, styled) {
+    const elapsed = target.elapsedMs > 0 ? `(${formatDuration(target.elapsedMs)})` : '';
+    if (!elapsed)
+        return '';
+    return styled ? dim(elapsed) : elapsed;
+}
+function renderPhaseRow(phase, frame, styled) {
+    const icon = phaseStatusIcon(phase.status, frame, styled);
+    const name = phase.name.padEnd(PHASE_NAME_WIDTH);
+    const segments = [];
+    if (phase.status === 'queued' || phase.status === 'skipped') {
+        const emptyBar = BAR_EMPTY.repeat(BAR_WIDTH);
+        segments.push(styled ? dim(emptyBar) : emptyBar);
+        segments.push(styled ? dim('  —') : '  —');
+    }
+    else {
+        const pct = Math.max(0, Math.min(100, Math.round(phase.percent)));
+        segments.push(renderProgressBar(pct, styled));
+        segments.push(`${String(pct).padStart(3)}%`);
+    }
+    let trailing = '';
+    if (phase.status === 'done') {
+        const parts = [];
+        if (phase.summary)
+            parts.push(phase.summary);
+        if (phase.elapsedMs > 0) {
+            const elapsed = `(${formatDuration(phase.elapsedMs)})`;
+            parts.push(styled ? dim(elapsed) : elapsed);
+        }
+        trailing = parts.join('  ');
+    }
+    else if (phase.status === 'running') {
+        const parts = [];
+        if (phase.detail)
+            parts.push(phase.detail);
+        if (phase.elapsedMs > 0) {
+            const elapsed = `(${formatDuration(phase.elapsedMs)})`;
+            parts.push(styled ? dim(elapsed) : elapsed);
+        }
+        trailing = parts.join('  ');
+    }
+    else if (phase.status === 'queued') {
+        trailing = styled ? dim('queued') : 'queued';
+    }
+    else if (phase.status === 'skipped') {
+        trailing = styled ? dim('skipped') : 'skipped';
+    }
+    else if (phase.status === 'failed') {
+        trailing = styled ? red('failed') : 'failed';
+    }
+    const bar = `${segments.join(' ')}  ${trailing}`.trimEnd();
+    return `        ${icon} ${name} ${bar}`;
+}
+function columnWidth(state) {
+    const all = [...state.primarySources, ...state.contextSources];
+    return Math.max(12, ...all.map((t) => t.target.connectionId.length)) + 2;
+}
+function renderTargetRows(target, frame, styled, width, options) {
+    const icon = statusIcon(target.status, frame, styled);
+    const name = target.target.connectionId.padEnd(width);
+    const anyPhaseStarted = target.phases.some((p) => p.status !== 'queued');
+    if (target.status === 'running' && target.phases.length > 0 && anyPhaseStarted) {
+        const headerDetail = renderRunningTargetHeaderDetail(target, styled);
+        const headerLine = `    ${icon} ${name} ${headerDetail}`.trimEnd();
+        return [headerLine, ...target.phases.map((phase) => renderPhaseRow(phase, frame, styled))];
+    }
+    return [`    ${icon} ${name} ${targetDetail(target, styled, options)}`];
+}
+function renderTargetGroup(label, targets, frame, styled, width, options) {
+    if (targets.length === 0)
+        return [];
+    return ['', `  ${label}:`, ...targets.flatMap((t) => renderTargetRows(t, frame, styled, width, options))];
+}
+function renderMessageGroup(label, messages, styled) {
+    if (messages.length === 0)
+        return [];
+    const renderedMessages = messages.map((message) => `    - ${message}`);
+    return ['', `  ${label}:`, ...renderedMessages.map((line) => (styled ? dim(line) : line))];
+}
+function retryCommand(input) {
+    const projectPart = input.projectDir ? ` --project-dir ${input.projectDir}` : '';
+    if (input.entrypoint === 'ingest' && input.connectionId) {
+        const depthPart = input.depth ? ` --${input.depth}` : '';
+        const queryHistoryPart = input.queryHistory ? ' --query-history' : '';
+        const windowPart = input.queryHistory && input.queryHistoryWindowDays !== undefined
+            ? ` --query-history-window-days ${input.queryHistoryWindowDays}`
+            : '';
+        return `ktx ingest ${input.connectionId}${projectPart}${depthPart}${queryHistoryPart}${windowPart}`;
+    }
+    return input.projectDir ? `ktx setup --project-dir ${input.projectDir}` : 'ktx setup';
+}
+export function renderContextBuildView(state, options = {}) {
+    const styled = options.styled ?? true;
+    const width = columnWidth(state);
+    const allTargets = [...state.primarySources, ...state.contextSources];
+    const doneCount = allTargets.filter((t) => t.status === 'done' || t.status === 'failed').length;
+    const totalCount = allTargets.length;
+    const hasActive = allTargets.some((t) => t.status === 'running' || t.status === 'queued');
+    const allDone = totalCount > 0 && !hasActive;
+    const headerParts = [options.title ?? 'Building KTX context'];
+    if (totalCount > 0) {
+        const progressParts = [`${doneCount}/${totalCount}`];
+        if (state.totalElapsedMs > 0)
+            progressParts.push(formatDuration(state.totalElapsedMs));
+        const progress = `(${progressParts.join(' · ')})`;
+        headerParts.push(styled ? dim(progress) : progress);
+    }
+    const header = headerParts.join('  ');
+    const headerPlainLength = header.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const separator = '─'.repeat(Math.max(21, headerPlainLength));
+    const lines = [
+        '',
+        header,
+        separator,
+        ...(options.projectDir ? [`  Project: ${options.projectDir}`] : []),
+        ...renderTargetGroup(options.primaryGroupLabel ?? 'Databases', state.primarySources, state.frame, styled, width, options),
+        ...renderTargetGroup(options.contextGroupLabel ?? 'Context sources', state.contextSources, state.frame, styled, width, options),
+        ...renderMessageGroup('Notices', options.notices ?? [], styled),
+        ...renderMessageGroup('Warnings', options.warnings ?? [], styled),
+        '',
+    ];
+    if (allDone && state.totalElapsedMs > 0) {
+        const itemName = options.completedItemName ?? { singular: 'source', plural: 'sources' };
+        const sourcesLabel = totalCount === 1 ? `1 ${itemName.singular}` : `${totalCount} ${itemName.plural}`;
+        const summary = `  Done in ${formatDuration(state.totalElapsedMs)} · ${sourcesLabel} processed`;
+        lines.push(styled ? green(summary) : summary);
+        lines.push('');
+    }
+    if (options.showHint && hasActive) {
+        const hintContent = options.hintText ?? 'Ctrl+C to stop';
+        const hint = `  ${hintContent}`;
+        lines.push(styled ? dim(hint) : hint);
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+// --- IO Capture ---
+const ESC_K_RE = new RegExp(`${ESC.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\[K`, 'g');
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+export function extractProgressMessage(chunk) {
+    const cleaned = chunk.replace(/^\r/, '').replace(ESC_K_RE, '').replace(/\n$/, '').trim();
+    const match = cleaned.match(/^\[(\d+)%\]\s*(.+)$/);
+    return match ? `[${match[1]}%] ${match[2]}` : null;
+}
+export function parseScanSummary(output) {
+    const match = output.match(/(\d+) changes? across (\d+) tables?/);
+    return match ? `${match[2]} tables` : null;
+}
+export function parseIngestSummary(output) {
+    const savedMemory = output.match(/Saved memory: (.+)/);
+    if (savedMemory)
+        return savedMemory[1];
+    const tasks = output.match(/(?:Tasks|Work units): (\d+)/);
+    if (tasks)
+        return `${tasks[1]} tasks`;
+    return null;
+}
+function collectOutputMetadata(output, operation) {
+    const reportIds = new Set();
+    const artifactPaths = new Set();
+    for (const line of output.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        const reportLine = trimmed.match(/^Report:\s*(.+)$/);
+        if (reportLine) {
+            const value = reportLine[1].trim();
+            if (value && value !== 'none') {
+                if (operation === 'database-ingest')
+                    artifactPaths.add(value);
+                else
+                    reportIds.add(value);
+            }
+        }
+        const rawSourcesLine = trimmed.match(/^Raw sources:\s*(.+)$/);
+        if (rawSourcesLine) {
+            const value = rawSourcesLine[1].trim();
+            if (value && value !== 'none')
+                artifactPaths.add(value);
+        }
+        if (operation === 'source-ingest') {
+            for (const match of trimmed.matchAll(/\breport=([^\s]+)/g)) {
+                reportIds.add(match[1]);
+            }
+        }
+    }
+    return { reportIds: [...reportIds], artifactPaths: [...artifactPaths] };
+}
+function createCaptureIo(onProgress, isTTY) {
+    let buffer = '';
+    return {
+        io: {
+            stdout: {
+                isTTY,
+                write(chunk) {
+                    buffer += chunk;
+                    const progress = extractProgressMessage(chunk);
+                    if (progress)
+                        onProgress(progress);
+                },
+            },
+            stderr: {
+                write(chunk) {
+                    buffer += chunk;
+                },
+            },
+        },
+        captured: () => buffer,
+    };
+}
+// --- Source progress helpers ---
+function progressFieldsFromDetailLine(detailLine, updatedAtMs) {
+    if (!detailLine)
+        return {};
+    const percent = extractPercent(detailLine);
+    const message = detailLine.replace(/^\[\d+%\]\s*/, '');
+    return {
+        ...(percent !== null ? { percent } : {}),
+        ...(message ? { message } : {}),
+        ...(updatedAtMs !== null ? { updatedAtMs } : {}),
+    };
+}
+function detailLineFromProgressSource(source) {
+    if (!source.message)
+        return null;
+    if (typeof source.percent === 'number' && Number.isFinite(source.percent)) {
+        const percent = Math.max(0, Math.min(100, Math.round(source.percent)));
+        return `[${percent}%] ${source.message}`;
+    }
+    return source.message;
+}
+function collectSourceProgress(targets) {
+    return targets.map((t) => {
+        const progressFields = progressFieldsFromDetailLine(t.detailLine, t.progressUpdatedAtMs);
+        return {
+            connectionId: t.target.connectionId,
+            operation: t.target.operation,
+            status: t.status,
+            ...(t.startedAt !== null ? { startedAtMs: t.startedAt } : {}),
+            ...(t.elapsedMs > 0 ? { elapsedMs: t.elapsedMs } : {}),
+            ...progressFields,
+            ...(t.summaryText ? { summaryText: t.summaryText } : {}),
+        };
+    });
+}
+export function viewStateFromSourceProgress(sources, now, startedAtMs) {
+    const makeTarget = (s) => ({
+        target: { connectionId: s.connectionId, driver: '', operation: s.operation, debugCommand: '', steps: [] },
+        status: s.status,
+        detailLine: detailLineFromProgressSource(s),
+        summaryText: s.summaryText ?? null,
+        failureText: null,
+        startedAt: s.startedAtMs ?? null,
+        elapsedMs: s.status === 'running' && s.startedAtMs ? now - s.startedAtMs : (s.elapsedMs ?? 0),
+        progressUpdatedAtMs: s.updatedAtMs ?? null,
+        phases: [],
+    });
+    return {
+        primarySources: sources.filter((s) => s.operation === 'database-ingest').map(makeTarget),
+        contextSources: sources.filter((s) => s.operation === 'source-ingest').map(makeTarget),
+        frame: 0,
+        startedAt: startedAtMs ?? null,
+        totalElapsedMs: startedAtMs ? now - startedAtMs : 0,
+    };
+}
+// --- Repaint ---
+export function createRepainter(io) {
+    let hasPainted = false;
+    let lastCursorUpRows = 0;
+    const terminalColumns = () => {
+        for (const columns of [io.stdout.columns, process.stdout.columns]) {
+            if (typeof columns === 'number' && Number.isFinite(columns) && columns > 0)
+                return columns;
+        }
+        return 80;
+    };
+    const visualRows = (line, columns) => {
+        const plainLength = line.replace(ANSI_RE, '').length;
+        return Math.max(1, Math.ceil(plainLength / columns));
+    };
+    const cursorUpRowsAfterWrite = (content) => {
+        const columns = terminalColumns();
+        const endsWithNewline = content.endsWith('\n');
+        const lines = content.split('\n');
+        return lines.reduce((sum, line, index) => {
+            if (index === lines.length - 1) {
+                return endsWithNewline ? sum : sum + Math.max(0, visualRows(line, columns) - 1);
+            }
+            return sum + visualRows(line, columns);
+        }, 0);
+    };
+    return {
+        paint(content) {
+            if (hasPainted) {
+                if (lastCursorUpRows > 0) {
+                    io.stdout.write(`${ESC}[${lastCursorUpRows}A`);
+                }
+                io.stdout.write('\r');
+            }
+            io.stdout.write(`${ESC}[2K`);
+            io.stdout.write(content.replaceAll('\n', `\n${ESC}[2K`));
+            io.stdout.write(`${ESC}[J`);
+            hasPainted = true;
+            lastCursorUpRows = cursorUpRowsAfterWrite(content);
+        },
+    };
+}
+// --- Orchestration ---
+function makeTargetState(target) {
+    return {
+        target,
+        status: 'queued',
+        detailLine: null,
+        summaryText: null,
+        failureText: null,
+        startedAt: null,
+        elapsedMs: 0,
+        progressUpdatedAtMs: null,
+        phases: makePhasesForTarget(target),
+    };
+}
+const NETWORK_ERROR_REASONS = {
+    EADDRNOTAVAIL: 'network address unavailable',
+    ECONNRESET: 'connection reset',
+    ECONNREFUSED: 'connection refused',
+    ENETUNREACH: 'network unreachable',
+    ENOTFOUND: 'host not found',
+    ETIMEDOUT: 'connection timed out',
+    EHOSTUNREACH: 'host unreachable',
+};
+function unknownErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function networkErrorCodeFromText(text) {
+    for (const code of Object.keys(NETWORK_ERROR_REASONS)) {
+        if (new RegExp(`\\b${code}\\b`).test(text)) {
+            return code;
+        }
+    }
+    return null;
+}
+function networkErrorCode(error, capturedOutput = '') {
+    const directCode = typeof error?.code === 'string'
+        ? error.code
+        : null;
+    if (directCode && NETWORK_ERROR_REASONS[directCode]) {
+        return directCode;
+    }
+    return networkErrorCodeFromText(`${unknownErrorMessage(error)}\n${capturedOutput}`);
+}
+function isLocalSqlAnalysisConnectionRefused(input) {
+    const text = `${input.capturedOutput ?? ''}\n${input.fallback ?? ''}`;
+    return /\bECONNREFUSED\b/.test(text) && /\b(?:127\.0\.0\.1|localhost):8765\b/.test(text);
+}
+function friendlyDriverName(driver) {
+    const normalized = driver.toLowerCase();
+    if (normalized === 'postgres' || normalized === 'postgresql')
+        return 'PostgreSQL';
+    if (normalized === 'mysql')
+        return 'MySQL';
+    if (normalized === 'sqlserver')
+        return 'SQL Server';
+    if (normalized === 'bigquery')
+        return 'BigQuery';
+    if (normalized === 'snowflake')
+        return 'Snowflake';
+    if (normalized === 'clickhouse')
+        return 'ClickHouse';
+    if (normalized === 'sqlite')
+        return 'SQLite';
+    return driver || 'the source';
+}
+function failedStepDetail(result) {
+    return result.steps.find((step) => step.status === 'failed')?.detail ?? null;
+}
+const INTERNAL_FAILURE_LINE_RE = /^(Report|Run|Job|Status|Adapter|Connection|Sync|Mode|Dry run|Diff|Tasks|Work units|Failed tasks|Saved memory|Provenance rows):\s*/;
+const ACTIONABLE_FAILURE_LINE_RE = /^(Missing bundled Python runtime manifest|KTX Python runtime is required|KTX managed daemon|Error:|Failed\b|Could not\b|Cannot\b)/;
+function firstCapturedFailureLine(output) {
+    const lines = (output ?? '')
+        .split(/\r?\n/)
+        .map((candidate) => candidate.trim())
+        .filter((candidate) => candidate.length > 0)
+        .filter((candidate) => !candidate.startsWith('KTX scan completed'))
+        .filter((candidate) => !INTERNAL_FAILURE_LINE_RE.test(candidate));
+    return lines.find((candidate) => ACTIONABLE_FAILURE_LINE_RE.test(candidate)) ?? lines.at(-1) ?? null;
+}
+function isGenericFailedAtDetail(target, detail) {
+    return new RegExp(`^${target.connectionId} failed at [a-z-]+\\.?(?: Retry: .*)?$`).test(detail ?? '');
+}
+function appendRetryIfNeeded(input) {
+    const base = input.message.trim().replace(/\.+$/, '');
+    if (/\bRetry:\s/.test(base)) {
+        return base;
+    }
+    return `${base}. Retry: ${retryCommand({
+        projectDir: input.projectDir,
+        entrypoint: input.entrypoint,
+        connectionId: input.target.connectionId,
+        depth: input.target.databaseDepth,
+        queryHistory: input.target.queryHistory?.enabled === true,
+        queryHistoryWindowDays: input.target.queryHistory?.windowDays,
+    })}`;
+}
+function failureTextForTarget(input) {
+    const code = networkErrorCode(input.error, input.capturedOutput);
+    if (code && isLocalSqlAnalysisConnectionRefused({ capturedOutput: input.capturedOutput, fallback: input.fallback })) {
+        return [
+            `KTX could not reach the local SQL analysis runtime while processing query history for ${input.target.connectionId}.`,
+            `Reason: ${NETWORK_ERROR_REASONS[code]} (${code}).`,
+            `Retry: ${retryCommand({
+                projectDir: input.projectDir,
+                entrypoint: input.entrypoint,
+                connectionId: input.target.connectionId,
+                depth: input.target.databaseDepth,
+                queryHistory: input.target.queryHistory?.enabled === true,
+                queryHistoryWindowDays: input.target.queryHistory?.windowDays,
+            })}`,
+        ].join(' ');
+    }
+    if (code) {
+        const operation = input.target.operation === 'database-ingest' ? 'reading schema for' : 'ingesting';
+        return [
+            `KTX lost its connection to ${friendlyDriverName(input.target.driver)} while ${operation} ${input.target.connectionId}.`,
+            `Reason: ${NETWORK_ERROR_REASONS[code]} (${code}).`,
+            `Retry: ${retryCommand({
+                projectDir: input.projectDir,
+                entrypoint: input.entrypoint,
+                connectionId: input.target.connectionId,
+                depth: input.target.databaseDepth,
+                queryHistory: input.target.queryHistory?.enabled === true,
+                queryHistoryWindowDays: input.target.queryHistory?.windowDays,
+            })}`,
+        ].join(' ');
+    }
+    const capturedFailure = firstCapturedFailureLine(input.capturedOutput);
+    const fallback = capturedFailure && isGenericFailedAtDetail(input.target, input.fallback)
+        ? capturedFailure
+        : (input.fallback ?? capturedFailure ?? `${input.target.connectionId} failed.`);
+    if (input.entrypoint === 'ingest') {
+        return appendRetryIfNeeded({
+            message: fallback,
+            target: input.target,
+            projectDir: input.projectDir,
+            entrypoint: input.entrypoint,
+        });
+    }
+    return fallback;
+}
+export function initViewState(targets) {
+    return {
+        primarySources: targets.filter((t) => t.operation === 'database-ingest').map(makeTargetState),
+        contextSources: targets.filter((t) => t.operation === 'source-ingest').map(makeTargetState),
+        frame: 0,
+        startedAt: null,
+        totalElapsedMs: 0,
+    };
+}
+function publicProgressMessage(message, target) {
+    let current = message;
+    if (target.operation === 'database-ingest') {
+        current = publicDatabaseIngestMessage(current);
+    }
+    if (target.steps.includes('query-history')) {
+        current = publicQueryHistoryMessage(current, target.connectionId);
+    }
+    return current;
+}
+function formatProgressDetail(update, target) {
+    const percent = Math.max(0, Math.min(100, Math.round(update.percent)));
+    return `[${percent}%] ${publicProgressMessage(update.message, target)}`;
+}
+function createContextBuildProgressPort(onProgress, state = { progress: 0 }, start = 0, weight = 1) {
+    return {
+        async update(value, message, options) {
+            const absoluteValue = start + Math.max(0, Math.min(1, value)) * weight;
+            state.progress = Math.max(state.progress, Math.min(1, absoluteValue));
+            if (!message)
+                return;
+            onProgress({
+                percent: Math.max(0, Math.min(100, Math.round(state.progress * 100))),
+                message,
+                ...(options?.transient !== undefined ? { transient: options.transient } : {}),
+            });
+        },
+        startPhase(phaseWeight) {
+            return createContextBuildProgressPort(onProgress, state, state.progress, weight * phaseWeight);
+        },
+    };
+}
+export async function runContextBuild(project, args, io, deps = {}) {
+    const plan = buildPublicIngestPlan(project, {
+        projectDir: args.projectDir,
+        ...(args.targetConnectionId ? { targetConnectionId: args.targetConnectionId } : {}),
+        all: args.all ?? true,
+        ...(args.depth ? { depth: args.depth } : {}),
+        ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
+        ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
+        ...(args.scanMode ? { scanMode: args.scanMode } : {}),
+    });
+    const state = initViewState(plan.targets);
+    const isTTY = io.stdout.isTTY === true;
+    const nowFn = deps.now ?? (() => Date.now());
+    state.startedAt = nowFn();
+    const repainter = isTTY ? createRepainter(io) : null;
+    const viewOpts = {
+        styled: true,
+        projectDir: args.projectDir,
+        notices: plan.notices ?? [],
+        warnings: plan.warnings,
+    };
+    const paint = (hint) => repainter?.paint(renderContextBuildView(state, { ...viewOpts, showHint: hint }));
+    paint(true);
+    let spinnerInterval = null;
+    if (repainter) {
+        spinnerInterval = setInterval(() => {
+            state.frame++;
+            if (state.startedAt !== null) {
+                state.totalElapsedMs = nowFn() - state.startedAt;
+            }
+            for (const t of [...state.primarySources, ...state.contextSources]) {
+                if (t.status === 'running' && t.startedAt !== null) {
+                    t.elapsedMs = nowFn() - t.startedAt;
+                }
+                for (const phase of t.phases) {
+                    if (phase.status === 'running' && phase.startedAt !== null) {
+                        phase.elapsedMs = nowFn() - phase.startedAt;
+                    }
+                }
+            }
+            paint(true);
+        }, 140);
+    }
+    const orderedTargets = [...state.primarySources, ...state.contextSources];
+    const execTarget = deps.executeTarget ?? executePublicIngestTarget;
+    const reportIds = new Set();
+    const artifactPaths = new Set();
+    const sourceProgressThrottleMs = deps.sourceProgressThrottleMs ?? 750;
+    let lastSourceProgressPublishedAt = Number.NEGATIVE_INFINITY;
+    const publishSourceProgress = (force = false) => {
+        if (!deps.onSourceProgress)
+            return false;
+        const now = nowFn();
+        if (!force && now - lastSourceProgressPublishedAt < sourceProgressThrottleMs) {
+            return false;
+        }
+        lastSourceProgressPublishedAt = now;
+        deps.onSourceProgress(collectSourceProgress(orderedTargets));
+        return true;
+    };
+    const runArgs = {
+        command: 'run',
+        projectDir: args.projectDir,
+        ...(args.targetConnectionId ? { targetConnectionId: args.targetConnectionId } : {}),
+        all: args.all ?? true,
+        json: false,
+        inputMode: args.inputMode,
+        ...(args.depth ? { depth: args.depth } : {}),
+        ...(args.queryHistory ? { queryHistory: args.queryHistory } : {}),
+        ...(args.queryHistoryWindowDays !== undefined ? { queryHistoryWindowDays: args.queryHistoryWindowDays } : {}),
+        ...(args.scanMode ? { scanMode: args.scanMode } : {}),
+        ...(args.detectRelationships !== undefined ? { detectRelationships: args.detectRelationships } : {}),
+        ...(args.cliVersion ? { cliVersion: args.cliVersion } : {}),
+        ...(args.runtimeInstallPolicy ? { runtimeInstallPolicy: args.runtimeInstallPolicy } : {}),
+    };
+    let hasFailure = false;
+    try {
+        for (const targetState of orderedTargets) {
+            targetState.status = 'running';
+            targetState.startedAt = nowFn();
+            paint(true);
+            publishSourceProgress(true);
+            let hasPendingProgressPublish = false;
+            const ingestPhaseKeyForTarget = targetState.target.operation === 'database-ingest' ? 'query-history' : 'source-ingest';
+            const updateNamedPhase = (key, update) => {
+                const phase = targetState.phases.find((p) => p.key === key);
+                if (phase) {
+                    if (phase.status === 'queued') {
+                        phase.status = 'running';
+                        phase.startedAt = nowFn();
+                    }
+                    const sanitizedMessage = update.message.replace(/^\[\d+%\]\s*/, '');
+                    phase.detail = publicProgressMessage(sanitizedMessage, targetState.target);
+                    phase.percent = Math.max(phase.percent, Math.max(0, Math.min(100, Math.round(update.percent))));
+                    phase.progressUpdatedAtMs = nowFn();
+                }
+                targetState.detailLine = formatProgressDetail(update, targetState.target);
+                targetState.progressUpdatedAtMs = nowFn();
+                if (!repainter) {
+                    io.stdout.write(`${targetState.detailLine}\n`);
+                }
+                paint(true);
+                hasPendingProgressPublish = !publishSourceProgress(false);
+            };
+            const updateSchemaPhase = (update) => updateNamedPhase('database-schema', update);
+            const updateIngestPhase = (update) => updateNamedPhase(ingestPhaseKeyForTarget, update);
+            const capture = createCaptureIo((message) => {
+                targetState.detailLine = publicProgressMessage(message, targetState.target);
+                targetState.progressUpdatedAtMs = nowFn();
+                if (!repainter) {
+                    io.stdout.write(`${targetState.detailLine}\n`);
+                }
+                paint(true);
+                hasPendingProgressPublish = !publishSourceProgress(false);
+            }, false);
+            const onPhaseStart = (key) => {
+                const phase = targetState.phases.find((p) => p.key === key);
+                if (!phase)
+                    return;
+                phase.status = 'running';
+                if (phase.startedAt === null)
+                    phase.startedAt = nowFn();
+                phase.progressUpdatedAtMs = nowFn();
+                paint(true);
+                hasPendingProgressPublish = !publishSourceProgress(false);
+            };
+            const onPhaseEnd = (key, status, summary) => {
+                const phase = targetState.phases.find((p) => p.key === key);
+                if (!phase)
+                    return;
+                phase.status = status;
+                if (phase.startedAt !== null) {
+                    phase.elapsedMs = nowFn() - phase.startedAt;
+                }
+                if (status === 'done') {
+                    phase.percent = 100;
+                }
+                let resolvedSummary = summary;
+                if (status === 'done' && !resolvedSummary) {
+                    const captured = capture.captured();
+                    if (key === 'database-schema') {
+                        resolvedSummary = parseScanSummary(captured) ?? undefined;
+                    }
+                    else if (key === 'query-history' || key === 'source-ingest') {
+                        resolvedSummary = parseIngestSummary(captured) ?? undefined;
+                    }
+                }
+                if (resolvedSummary) {
+                    phase.summary = resolvedSummary;
+                }
+                paint(true);
+                hasPendingProgressPublish = !publishSourceProgress(false);
+            };
+            const progressDeps = {
+                scanProgress: createContextBuildProgressPort(updateSchemaPhase),
+                ingestProgress: updateIngestPhase,
+                onPhaseStart,
+                onPhaseEnd,
+            };
+            let result = null;
+            let thrownError = null;
+            try {
+                result = await execTarget(targetState.target, runArgs, capture.io, progressDeps);
+            }
+            catch (error) {
+                thrownError = error;
+            }
+            if (hasPendingProgressPublish) {
+                publishSourceProgress(true);
+            }
+            targetState.elapsedMs = nowFn() - (targetState.startedAt ?? nowFn());
+            const failed = thrownError !== null || result?.steps.some((s) => s.status === 'failed') === true;
+            targetState.status = failed ? 'failed' : 'done';
+            targetState.detailLine = null;
+            const capturedOutput = capture.captured();
+            const metadata = collectOutputMetadata(capturedOutput, targetState.target.operation);
+            for (const reportId of metadata.reportIds)
+                reportIds.add(reportId);
+            for (const artifactPath of metadata.artifactPaths)
+                artifactPaths.add(artifactPath);
+            if (!failed) {
+                targetState.summaryText =
+                    targetState.target.operation === 'database-ingest'
+                        ? parseScanSummary(capturedOutput)
+                        : parseIngestSummary(capturedOutput);
+            }
+            else {
+                targetState.failureText = failureTextForTarget({
+                    target: targetState.target,
+                    projectDir: args.projectDir,
+                    entrypoint: args.entrypoint,
+                    capturedOutput,
+                    error: thrownError,
+                    fallback: result ? failedStepDetail(result) : null,
+                });
+            }
+            if (failed)
+                hasFailure = true;
+            paint(true);
+            publishSourceProgress(true);
+        }
+    }
+    finally {
+        if (spinnerInterval)
+            clearInterval(spinnerInterval);
+    }
+    if (state.startedAt !== null) {
+        state.totalElapsedMs = nowFn() - state.startedAt;
+    }
+    if (!repainter) {
+        io.stdout.write(renderContextBuildView(state, { ...viewOpts, styled: false }));
+    }
+    else {
+        paint(false);
+    }
+    return {
+        exitCode: hasFailure ? 1 : 0,
+        ...(reportIds.size > 0 ? { reportIds: [...reportIds] } : {}),
+        ...(artifactPaths.size > 0 ? { artifactPaths: [...artifactPaths] } : {}),
+    };
+}