vgxness 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { dispatchCliAsync } from './dispatcher.js';
+import { resolveMcpStartDatabasePath } from './mcp-start-path.js';
+import { startVgxMcpStdioServer } from '../mcp/stdio-server.js';
+void main();
+async function main() {
+    const argv = process.argv.slice(2);
+    if (isMcpStartCommand(argv)) {
+        const databasePath = resolveMcpStartDatabasePath(argv, process.cwd(), process.env, process.platform);
+        if (!databasePath.ok) {
+            process.stderr.write(`${databasePath.error.message}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        await startVgxMcpStdioServer({ databasePath: databasePath.value });
+        return;
+    }
+    const result = await dispatchCliAsync(argv, { cwd: process.cwd(), env: process.env, stdin: process.stdin, stdout: process.stdout });
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (result.stderr)
+        process.stderr.write(result.stderr);
+    process.exitCode = result.exitCode;
+}
+function isMcpStartCommand(argv) {
+    return argv[0] === 'mcp' && argv[1] === 'start';
+}

package/dist/cli/interactive-dashboard.js

@@ -0,0 +1,29 @@
+import { renderDashboardFrame } from './dashboard-screen-renderers.js';
+import { createDashboardState as createState, dashboardKeyFromInput, reduceDashboardKey, refreshDashboardState } from './dashboard-tui-state.js';
+import { sanitizeDashboardError } from './dashboard-tui-read-model.js';
+export function createDashboardState(input) {
+    return createState(input);
+}
+export async function loadInitialDashboardState(project, loader) {
+    const loaded = await loader();
+    if (!loaded.ok)
+        return createDashboardState({ ...(project === undefined ? {} : { project }), runs: [], activeScreen: project === undefined ? 'setup' : 'runs', error: sanitizeDashboardError(loaded.error.message) });
+    return createDashboardState({ ...(project === undefined ? {} : { project }), ...loaded.value });
+}
+export { dashboardKeyFromInput, reduceDashboardKey };
+export async function refreshDashboard(state, loader) {
+    const loaded = await loader();
+    if (!loaded.ok)
+        return { ...state, error: sanitizeDashboardError(loaded.error.message) };
+    return refreshDashboardState(state, loaded.value);
+}
+export function renderDashboard(state, options = {}) {
+    return renderDashboardFrame(state, options);
+}
+export function resolveDashboardRenderStyle(input) {
+    if (input.isTTY !== true)
+        return 'plain';
+    if (input.env?.NO_COLOR !== undefined || input.env?.CI !== undefined)
+        return 'plain';
+    return 'ansi';
+}

package/dist/cli/mcp-start-path.js

@@ -0,0 +1,21 @@
+import { resolveMemoryDatabasePath } from '../memory/storage-paths.js';
+export function resolveMcpStartDatabasePath(argv, cwd, env, platform = process.platform) {
+    const explicit = readFlagValue(argv, 'db');
+    const resolved = resolveMemoryDatabasePath({ cwd, env, explicitPath: explicit, platform });
+    return resolved.ok ? { ok: true, value: resolved.value.path } : resolved;
+}
+function readFlagValue(argv, name) {
+    const prefix = `--${name}=`;
+    for (let index = 0; index < argv.length; index += 1) {
+        const current = argv[index];
+        if (current === undefined)
+            continue;
+        if (current.startsWith(prefix))
+            return current.slice(prefix.length);
+        if (current === `--${name}`) {
+            const next = argv[index + 1];
+            return next !== undefined && !next.startsWith('--') ? next : undefined;
+        }
+    }
+    return undefined;
+}

package/dist/cli/setup-status-renderer.js

@@ -0,0 +1,29 @@
+export function renderSetupStatus(status) {
+    return [
+        'Setup Status',
+        `- Environment: ${status.environment.status} — ${status.environment.summary}`,
+        `- Project: ${status.projectState.status} — ${status.projectState.summary}`,
+        `- Store: ${status.store.status}${status.store.path === '' ? '' : ` — ${status.store.path}`}${status.store.blocker === undefined ? '' : ` (${status.store.blocker})`}`,
+        `- Providers: ${status.providers.map(renderProvider).join('; ')}`,
+        `- Agents: ${status.agents.deferred ? 'deferred' : status.agents.status} — ${renderDefaults(status)}`,
+        `- Verification: ${status.verification.status} — ${status.verification.summary}`,
+        `- Next setup action: ${status.nextAction.command} — ${status.nextAction.reason}`,
+        `- Provider writes: ${status.safety.writesProviderConfig} · provider execution: ${status.safety.executesProvider}`,
+    ].join('\n');
+}
+export function setupNeedsAction(status) {
+    return status.store.status !== 'ready' || status.verification.status !== 'ready' || status.defaults.status === 'blocked';
+}
+function renderDefaults(status) {
+    if (status.agents.deferred)
+        return 'Project-scoped default manager/profile checks are deferred until a project is selected.';
+    if (status.defaults.status !== 'ready')
+        return status.defaults.blocker ?? 'default context unavailable';
+    return `${status.defaults.agentName} via ${status.defaults.providerAdapter ?? 'unknown provider'} (${status.defaults.model ?? 'unknown model'})`;
+}
+function renderProvider(provider) {
+    const safety = provider.actions.some((action) => action.safety.writesProviderConfig)
+        ? 'external write action flagged'
+        : 'no provider writes';
+    return `${provider.displayName} ${provider.status}/${provider.supportLevel} (${safety})`;
+}

package/dist/cli/setup-wizard-read-model.js

@@ -0,0 +1,56 @@
+export function buildSetupWizardReadModel(status) {
+    const noProject = status.projectState.mode === 'none';
+    const modelStatus = noProject ? 'ready-without-project' : status.verification.status === 'ready' ? 'ready' : 'blocked';
+    return {
+        status: modelStatus,
+        projectMode: noProject ? 'none' : 'selected',
+        ...(status.project === undefined ? {} : { project: status.project }),
+        summary: noProject
+            ? 'Environment and provider setup can continue; project-scoped checks are deferred, not failed.'
+            : status.verification.summary,
+        steps: [
+            { id: 'environment', label: 'Environment', status: readinessToSection(status.environment.status), summary: status.environment.summary },
+            { id: 'project', label: 'Project', status: status.projectState.status === 'deferred' ? 'deferred' : readinessToSection(status.projectState.status), summary: status.projectState.summary },
+            { id: 'providers', label: 'Providers', status: 'ready', summary: `${status.providers.length} provider targets: ${status.providers.map((provider) => provider.displayName).join(', ')}.` },
+            { id: 'agents', label: 'Agents', status: status.agents.deferred ? 'deferred' : readinessToSection(status.agents.status), summary: status.agents.deferred ? 'Project-scoped manager/profile checks are deferred until a project is selected.' : status.agents.blocker ?? 'Default manager/profile context is available.' },
+            { id: 'verification', label: 'Verification', status: readinessToSection(status.verification.status), summary: status.verification.summary },
+        ],
+        providerCards: status.providers.map((provider) => ({
+            id: provider.providerId,
+            label: provider.displayName,
+            supportLevel: provider.supportLevel,
+            status: provider.status,
+            summary: provider.summary,
+            capabilities: provider.capabilities,
+            targets: provider.targets,
+            guidance: provider.guidance,
+            evidence: provider.evidence,
+            actions: provider.actions.map((action) => ({ ...action, safetyLabels: safetyLabels(action) })),
+        })),
+        safetySummary: [
+            'Read model is status/preview data only; renderers can consume it without side effects.',
+            'External or mutating provider actions are data-only and must be copied/run outside the TUI.',
+        ],
+    };
+}
+function readinessToSection(status) {
+    if (status === 'ready')
+        return 'ready';
+    if (status === 'blocked')
+        return 'blocked';
+    return 'empty';
+}
+function safetyLabels(action) {
+    const labels = [];
+    if (action.safety.externalOnly)
+        labels.push('External');
+    if (action.safety.mutating)
+        labels.push('Mutating');
+    if (action.safety.writesProviderConfig)
+        labels.push('Writes provider config');
+    if (action.safety.requiresExplicitConfirmation)
+        labels.push('Requires explicit confirmation');
+    if (!action.safety.writesProviderConfig && !action.safety.mutating)
+        labels.push('No provider writes');
+    return labels;
+}

package/dist/cli/setup-wizard-renderer.js

@@ -0,0 +1,148 @@
+import { badge, joinSections, renderActionLine, renderPanel } from './tui-render-helpers.js';
+export function renderSetupWizard(readModel, state, options = {}) {
+    if (readModel === undefined) {
+        return joinSections([
+            renderPanel('Setup · Loading', [
+                `${badge('loading')} Setup status is not loaded yet.`,
+                'Provider details will appear after setup status is loaded. Press r to refresh.',
+            ], { ...options, status: 'loading' }),
+            renderFallbackProgress(state, options),
+        ]);
+    }
+    return joinSections([
+        renderSetupSummary(readModel, state, options),
+        renderProgress(readModel.steps, state, options),
+        renderProviderCards(readModel.providerCards, state, options),
+        renderExternalActionsPanel(readModel.providerCards, state, options),
+        renderPanel('Setup safety', [shortSafetySummary(readModel.safetySummary)], options),
+    ]);
+}
+function renderSetupSummary(readModel, state, options) {
+    const activeIndex = Math.max(0, readModel.steps.findIndex((step) => step.id === state.activeStep));
+    const activeStep = readModel.steps[activeIndex] ?? readModel.steps[0];
+    const title = `Setup · Step ${activeIndex + 1}/5 · ${activeStep?.label ?? 'Unknown'}`;
+    return renderPanel(title, [
+        `Status: ${badge(readModel.status)}`,
+        `Summary: ${readModel.summary}`,
+        `Project mode: ${readModel.projectMode}${readModel.project === undefined ? '' : ` (${readModel.project})`}`,
+        'Next safe action: review setup status here, then run any provider commands outside the TUI after review.',
+    ], { ...options, status: readModel.status });
+}
+function renderProgress(steps, state, options) {
+    return renderPanel('Setup steps', steps.map((step, index) => {
+        const current = step.id === state.activeStep ? '› [current]' : '  ';
+        const ordinal = `${index + 1}/5`;
+        return `${current} ${ordinal} ${step.label} ${badge(step.status)} — ${step.summary}`;
+    }), options);
+}
+function renderFallbackProgress(state, options) {
+    const labels = ['Environment', 'Project', 'Providers', 'Agents', 'Verification'];
+    const ids = ['environment', 'project', 'providers', 'agents', 'verification'];
+    return renderPanel('Setup steps', labels.map((label, index) => {
+        const current = ids[index] === state.activeStep ? '› [current]' : '  ';
+        return `${current} ${index + 1}/5 ${label} ${badge('loading')}`;
+    }), options);
+}
+function renderProviderCards(cards, state, options) {
+    if (cards.length === 0)
+        return renderPanel('Providers', ['Providers: none available yet.'], { ...options, status: 'empty' });
+    return renderPanel('Provider cards', [
+        ...cards.map((card) => renderProviderRow(card, state)),
+        ...renderFocusedProviderDetails(cards, state),
+    ], options);
+}
+function renderProviderRow(card, state) {
+    const focused = state.focusedProviderId === card.id ? '› [focused]' : '  ';
+    const selected = state.selectedProviderIds.includes(card.id) ? '[x]' : '[ ]';
+    const support = supportLabel(card.supportLevel);
+    const safetyLabels = setupSafetyLabels(card);
+    return `${focused} ${selected} ${card.label} ${badge(card.status)} — ${support} ${safetyLabels.map(displaySafetyBadge).join(' ')} — ${card.summary}`;
+}
+function renderFocusedProviderDetails(cards, state) {
+    const focusedCard = cards.find((card) => card.id === state.focusedProviderId) ?? cards[state.focusedIndex] ?? cards[0];
+    if (focusedCard === undefined)
+        return [];
+    const targets = focusedCard.targets.length === 0
+        ? 'Targets: none'
+        : `Targets: ${focusedCard.targets.map((target) => `${target.label} (${target.kind}${target.path === undefined ? '' : `: ${target.path}`}; dashboard-write: no; no-TUI-write)`).join('; ')}`;
+    const safetyLabels = setupSafetyLabels(focusedCard);
+    return [
+        '',
+        'Focused provider details:',
+        `  ${focusedCard.label}: ${focusedCard.summary}`,
+        `  Safety: ${safetyLabels.map(displaySafetyBadge).join(' ')}`,
+        `  ${targets}`,
+        `  Capabilities: ${focusedCard.capabilities.length === 0 ? 'none' : focusedCard.capabilities.join(', ')}`,
+        ...(focusedCard.guidance.length === 0 ? [] : [`  Guidance: ${focusedCard.guidance.join(' ')}`]),
+        ...(state.expandedProviderId === focusedCard.id && focusedCard.evidence.length > 0 ? [
+            '  Evidence (presentational only):',
+            ...focusedCard.evidence.map((item) => `  - ${item}`),
+        ] : []),
+    ];
+}
+function renderExternalActionsPanel(cards, state, options) {
+    const focusedCard = cards.find((card) => card.id === state.focusedProviderId) ?? cards[state.focusedIndex] ?? cards[0];
+    const focusedAction = focusedCard?.actions[0];
+    const actionLines = cards.flatMap((card) => card.actions.flatMap((action) => renderActionLine(`${card.label}: ${action.label}`, {
+        ...options,
+        labels: action.safetyLabels.map(normalizeSafetyLabel),
+        description: compactActionDescription(action.kind),
+    })));
+    return renderPanel('External actions', [
+        'Compact external-only guidance: [external] [no TUI writes]; provider config writes require confirmation outside the TUI.',
+        ...(actionLines.length === 0 ? ['- No external actions available.'] : actionLines),
+        ...(focusedCard === undefined || focusedAction === undefined ? [] : renderFocusedActionDetails(focusedCard, focusedAction)),
+    ], options);
+}
+function renderFocusedActionDetails(card, action) {
+    return [
+        '',
+        `Focused action details: ${card.label}: ${action.label} ${action.safetyLabels.map(displaySafetyBadge).join(' ')}`,
+        `  Details: ${action.description.length === 0 ? `${action.kind}; run outside the TUI after review.` : action.description}`,
+        ...(action.command === undefined || action.command.length === 0 ? [] : [`  Command: ${action.command.join(' ')}`]),
+    ];
+}
+function compactActionDescription(kind) {
+    return `${kind}; external guidance only; no TUI writes.`;
+}
+function shortSafetySummary(items) {
+    if (items.length === 0)
+        return 'Read-only setup preview: [no TUI writes]; external actions are [external] and require review.';
+    return 'Read-only setup preview: [no TUI writes]; external actions are [external] and require review outside the TUI.';
+}
+function supportLabel(level) {
+    if (level === 'supported-primary')
+        return 'Supported primary';
+    if (level === 'preview-only')
+        return 'Preview-only';
+    if (level === 'placeholder')
+        return 'Placeholder';
+    if (level === 'extension-point')
+        return 'Extension point';
+    return 'Unsupported';
+}
+function setupSafetyLabels(card) {
+    return unique(['No TUI writes', ...card.actions.flatMap((action) => action.safetyLabels)].map(normalizeSafetyLabel));
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function displaySafetyBadge(value) {
+    return badge(normalizeSafetyLabel(value));
+}
+function normalizeSafetyLabel(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'external')
+        return 'external';
+    if (normalized === 'mutating')
+        return 'mutating';
+    if (normalized === 'writes provider config')
+        return 'writes provider config';
+    if (normalized === 'no tui writes')
+        return 'no TUI writes';
+    if (normalized === 'requires explicit confirmation')
+        return 'requires confirmation';
+    if (normalized === 'no provider writes')
+        return 'no TUI writes';
+    return value;
+}

package/dist/cli/setup-wizard-state.js

@@ -0,0 +1,82 @@
+export const setupWizardSteps = ['environment', 'project', 'providers', 'agents', 'verification'];
+export const defaultSetupProviderIds = ['opencode', 'claude', 'antigravity', 'custom'];
+export function createSetupWizardState(input = {}) {
+    const selectedProviderIds = [...(input.selectedProviderIds ?? ['opencode'])];
+    const focusedProviderId = input.focusedProviderId ?? defaultSetupProviderIds[0];
+    return {
+        activeStep: input.activeStep ?? 'environment',
+        focusedIndex: clampFocus(input.focusedIndex ?? 0),
+        projectMode: input.projectMode ?? 'none',
+        selectedProviderIds,
+        ...(input.selectedProject === undefined ? {} : { selectedProject: input.selectedProject }),
+        ...(focusedProviderId === undefined ? {} : { focusedProviderId }),
+        ...(input.expandedProviderId === undefined ? {} : { expandedProviderId: input.expandedProviderId }),
+    };
+}
+export function setupWizardKeyFromInput(input) {
+    if (input === 'n')
+        return 'next';
+    if (input === 'b')
+        return 'back';
+    if (input === ' ')
+        return 'toggle';
+    if (input === '\r' || input === '\n')
+        return 'details';
+    if (input === '\u001B')
+        return 'escape';
+    if (input === 'k' || input === '\u001B[A')
+        return 'up';
+    if (input === 'j' || input === '\u001B[B')
+        return 'down';
+    return undefined;
+}
+export function reduceSetupWizardKey(state, key) {
+    if (key === 'next')
+        return moveStep(state, 1);
+    if (key === 'back')
+        return moveStep(state, -1);
+    if (key === 'up')
+        return moveFocus(state, -1);
+    if (key === 'down')
+        return moveFocus(state, 1);
+    if (key === 'toggle')
+        return state.activeStep === 'providers' ? toggleFocusedProvider(state) : state;
+    if (key === 'details')
+        return state.activeStep === 'providers' ? toggleExpandedProvider(state) : state;
+    if (key === 'escape')
+        return state.expandedProviderId === undefined ? moveStep(state, -1) : withoutExpandedProvider(state);
+    return state;
+}
+function moveStep(state, delta) {
+    const index = setupWizardSteps.indexOf(state.activeStep);
+    const nextIndex = Math.max(0, Math.min(index + delta, setupWizardSteps.length - 1));
+    const activeStep = setupWizardSteps[nextIndex] ?? state.activeStep;
+    return activeStep === state.activeStep ? state : { ...state, activeStep };
+}
+function moveFocus(state, delta) {
+    const focusedIndex = clampFocus(state.focusedIndex + delta);
+    if (state.activeStep !== 'providers')
+        return focusedIndex === state.focusedIndex ? state : { ...state, focusedIndex };
+    const focusedProviderId = defaultSetupProviderIds[focusedIndex] ?? state.focusedProviderId;
+    return { ...state, focusedIndex, ...(focusedProviderId === undefined ? {} : { focusedProviderId }) };
+}
+function toggleFocusedProvider(state) {
+    const providerId = state.focusedProviderId ?? defaultSetupProviderIds[state.focusedIndex];
+    if (providerId === undefined)
+        return state;
+    const selected = state.selectedProviderIds.includes(providerId);
+    return { ...state, selectedProviderIds: selected ? state.selectedProviderIds.filter((id) => id !== providerId) : [...state.selectedProviderIds, providerId] };
+}
+function toggleExpandedProvider(state) {
+    const providerId = state.focusedProviderId ?? defaultSetupProviderIds[state.focusedIndex];
+    if (providerId === undefined)
+        return state;
+    return state.expandedProviderId === providerId ? withoutExpandedProvider(state) : { ...state, expandedProviderId: providerId };
+}
+function withoutExpandedProvider(state) {
+    const { expandedProviderId: _expandedProviderId, ...rest } = state;
+    return rest;
+}
+function clampFocus(index) {
+    return Math.max(0, Math.min(index, defaultSetupProviderIds.length - 1));
+}

package/dist/cli/tui-render-helpers.js

@@ -0,0 +1,192 @@
+export const DEFAULT_TUI_WIDTH = 100;
+export const MIN_TUI_WIDTH = 40;
+const knownBadges = new Set([
+    'ready',
+    'deferred',
+    'blocked',
+    'loading',
+    'error',
+    'empty',
+    'external',
+    'mutating',
+    'no tui writes',
+    'no provider writes',
+    'writes provider config',
+    'requires confirmation',
+    'available',
+    'preview-only',
+    'manual',
+    'coming-soon',
+    'unsupported',
+    'ready-without-project',
+    'project-required',
+]);
+export function normalizeRenderWidth(width) {
+    if (width === undefined || !Number.isFinite(width))
+        return DEFAULT_TUI_WIDTH;
+    return Math.max(MIN_TUI_WIDTH, Math.floor(width));
+}
+export function stripAnsi(value) {
+    return value.replace(/\u001B\[[0-?]*[ -/]*[@-~]/g, '');
+}
+export function visibleLength(value) {
+    return stripAnsi(value).length;
+}
+export function badge(value, options = {}) {
+    const normalized = value.trim().replace(/[_\s]+/g, ' ').toLowerCase();
+    if (normalized.length === 0)
+        return styleBadge('[unknown]', 'unknown', options);
+    if (knownBadges.has(normalized)) {
+        const label = normalized === 'no tui writes' ? 'no TUI writes' : normalized;
+        return styleBadge(`[${label}]`, normalized, options);
+    }
+    return styleBadge(`[unknown: ${normalized}]`, 'unknown', options);
+}
+export function wrapText(text, options = {}) {
+    const width = normalizeRenderWidth(options.width);
+    const indent = options.indent ?? '';
+    const hangingIndent = options.hangingIndent ?? indent;
+    const firstAvailable = Math.max(1, width - visibleLength(indent));
+    const hangingAvailable = Math.max(1, width - visibleLength(hangingIndent));
+    const words = text.trim().length === 0 ? [''] : text.trim().split(/\s+/);
+    const lines = [];
+    let currentIndent = indent;
+    let available = firstAvailable;
+    let current = '';
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+            continue;
+        }
+        if (visibleLength(`${current} ${word}`) <= available) {
+            current = `${current} ${word}`;
+            continue;
+        }
+        lines.push(`${currentIndent}${current}`);
+        currentIndent = hangingIndent;
+        available = hangingAvailable;
+        current = word;
+    }
+    lines.push(`${currentIndent}${current}`);
+    return lines;
+}
+export function renderPanel(title, bodyLines, options = {}) {
+    const width = normalizeRenderWidth(options.width);
+    const contentWidth = Math.max(1, width - 4);
+    const status = options.status === undefined ? '' : ` ${badge(options.status, options)}`;
+    const titleText = ansi(options, 'title', `${title}${status}`);
+    const top = borderedTop(titleText, width, options);
+    const body = bodyLines.flatMap((line) => line.split('\n')).flatMap((line) => wrapPanelLine(styleKnownBadges(line, options), contentWidth, options));
+    const footer = (options.footerLines ?? []).flatMap((line) => wrapPanelLine(styleKnownBadges(line, options), contentWidth, options));
+    return [top, ...[...body, ...footer].map((line) => borderedBody(line, width, options)), borderedBottom(width, options)];
+}
+export function styleFocusedRow(value, options = {}) {
+    return ansi(options, 'highlight', value);
+}
+export function renderTabRow(items, options = {}) {
+    const width = normalizeRenderWidth(options.width);
+    const tokens = items.map((item) => renderTabToken(item, options));
+    return wrapTokens('Tabs:', tokens, width);
+}
+function renderTabToken(item, options) {
+    if (item.selected && item.focused === true)
+        return ansi(options, 'highlight', `› [${item.key}] ${item.label} [selected] [focused]`);
+    if (item.selected)
+        return ansi(options, 'highlight', `› [${item.key}] ${item.label} [selected]`);
+    if (item.focused === true)
+        return ansi(options, 'focus', `» [${item.key}] ${item.label} [focused]`);
+    return ansi(options, 'dim', `[${item.key}] ${item.label}`);
+}
+export function renderFooterGroups(groups, options = {}) {
+    const width = normalizeRenderWidth(options.width);
+    const lines = [];
+    for (const group of groups) {
+        lines.push(...wrapTokens(`${group.label}:`, group.items, width));
+    }
+    return lines;
+}
+export function renderActionLine(label, options = {}) {
+    const labels = (options.labels ?? []).map((value) => badge(value)).join(' ');
+    const primary = `- ${label}${labels.length === 0 ? '' : ` ${labels}`}`;
+    return [
+        ...wrapText(primary, options),
+        ...(options.description === undefined ? [] : wrapText(options.description, { ...options, indent: '  ', hangingIndent: '  ' })),
+        ...(options.command === undefined || options.command.length === 0 ? [] : wrapText(`Command: ${options.command.join(' ')}`, { ...options, indent: '  ', hangingIndent: '  ' })),
+    ];
+}
+export function joinSections(sections) {
+    return sections
+        .map((section) => typeof section === 'string' || section === undefined ? section?.trim() : section.join('\n').trim())
+        .filter((section) => section !== undefined && section.length > 0)
+        .join('\n\n');
+}
+function wrapTokens(prefix, tokens, width) {
+    const lines = [];
+    let current = prefix;
+    for (const token of tokens) {
+        const separator = current === prefix ? ' ' : ' · ';
+        const candidate = `${current}${separator}${token}`;
+        if (visibleLength(candidate) <= width || current === prefix) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current);
+        current = `${' '.repeat(prefix.length)} ${token}`;
+    }
+    lines.push(current);
+    return lines;
+}
+function wrapPanelLine(line, contentWidth, options) {
+    if (visibleLength(line) <= contentWidth)
+        return [line];
+    return wrapText(line, { ...options, width: contentWidth });
+}
+function borderedTop(title, width, options) {
+    const prefix = `┌─ ${title} `;
+    return `${ansi(options, 'border', prefix)}${ansi(options, 'border', '─'.repeat(Math.max(0, width - visibleLength(prefix) - 1)))}${ansi(options, 'border', '┐')}`;
+}
+function borderedBody(line, width, options) {
+    const padded = `${line}${' '.repeat(Math.max(0, width - visibleLength(line) - 4))}`;
+    return `${ansi(options, 'border', '│')} ${padded} ${ansi(options, 'border', '│')}`;
+}
+function borderedBottom(width, options) {
+    return ansi(options, 'border', `└${'─'.repeat(Math.max(0, width - 2))}┘`);
+}
+function styleKnownBadges(line, options) {
+    if (options.style !== 'ansi')
+        return line;
+    return line.replace(/\[([^\]]+)\]/g, (match, raw) => {
+        const normalized = raw.trim().replace(/[_\s]+/g, ' ').toLowerCase();
+        return knownBadges.has(normalized) ? styleBadge(match, normalized, options) : match;
+    });
+}
+function styleBadge(value, status, options) {
+    if (options.style !== 'ansi')
+        return value;
+    if (['ready', 'available', 'ready-without-project'].includes(status))
+        return ansi(options, 'green', value);
+    if (['blocked', 'error', 'mutating', 'writes provider config'].includes(status))
+        return ansi(options, 'red', value);
+    if (['deferred', 'loading', 'manual', 'requires confirmation', 'preview-only', 'coming-soon', 'project-required'].includes(status))
+        return ansi(options, 'yellow', value);
+    if (['external', 'no tui writes', 'no provider writes'].includes(status))
+        return ansi(options, 'cyan', value);
+    return ansi(options, 'dim', value);
+}
+function ansi(options, role, value) {
+    if (options.style !== 'ansi')
+        return value;
+    const codes = {
+        bold: '1',
+        title: '1;96',
+        dim: '2',
+        highlight: '1;7;36',
+        focus: '1;36',
+        border: '36',
+        green: '32',
+        red: '31',
+        yellow: '33',
+        cyan: '36',
+    };
+    return `\u001B[${codes[role]}m${value}\u001B[0m`;
+}

package/dist/export/redaction.js

@@ -0,0 +1,71 @@
+export const redactedPlaceholder = '[REDACTED]';
+const sensitiveKeyParts = [
+    'token',
+    'apikey',
+    'secret',
+    'password',
+    'authorization',
+    'credential',
+    'privatekey',
+    'session',
+    'cookie',
+];
+const sensitiveStringPatterns = [
+    /\b(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]+\b/i,
+    /\bsk-[A-Za-z0-9_-]{8,}\b/i,
+    /\b[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/,
+    /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/,
+];
+export function redactJsonValue(value) {
+    if (Array.isArray(value))
+        return value.map((item) => redactJsonValue(item));
+    if (isJsonObject(value))
+        return redactJsonObject(value);
+    if (typeof value === 'string')
+        return redactString(value);
+    return value;
+}
+function redactJsonObject(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+        key,
+        isSensitiveKey(key) ? redactedPlaceholder : redactJsonValue(child),
+    ]));
+}
+function redactString(value) {
+    const parsed = parseJsonString(value);
+    if (parsed !== undefined)
+        return JSON.stringify(redactJsonValue(parsed));
+    if (sensitiveStringPatterns.some((pattern) => pattern.test(value)))
+        return redactedPlaceholder;
+    return value;
+}
+function parseJsonString(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('['))
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        return isJsonValue(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSensitiveKey(key) {
+    const normalized = key.toLowerCase().replaceAll(/[^a-z0-9]/g, '');
+    return sensitiveKeyParts.some((part) => normalized.includes(part));
+}
+function isJsonObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isJsonValue(value) {
+    if (value === null)
+        return true;
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return true;
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value === 'object')
+        return Object.values(value).every(isJsonValue);
+    return false;
+}