vgxness 1.20.4 → 1.20.6

package/dist/cli/sdd-renderer.js

@@ -1,247 +1 @@
-import { normalizeSddArtifact, sddPhases, } from '../sdd/schema.js';
-export { sddContinuationPlanFrom } from '../sdd/sdd-continuation-plan.js';
-export function renderSddStatus(input) {
-    const missing = input.status.phases.filter((phase) => !phase.present).map((phase) => phase.topicKey);
-    const blockers = input.status.phases.filter((phase) => phase.present && phase.accepted !== true);
-    const complete = input.status.phases.length > 0 && input.status.phases.every((phase) => phase.present && phase.accepted === true);
-    const statusLabel = complete ? 'complete' : input.status.nextReadyPhase === undefined ? 'blocked' : 'ready';
-    const directPhaseCommand = input.status.nextReadyPhase === undefined ? undefined : `vgxness sdd continue --project ${input.project} --change ${input.status.change}`;
-    const recommendedAction = complete
-        ? 'No next SDD phase remains for this change.'
-        : input.status.nextReadyPhase === undefined
-            ? 'Review blockers or accept present draft artifacts before continuing.'
-            : `Continue the ${input.status.nextReadyPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`;
-    const commandLabel = directPhaseCommand === undefined ? 'Diagnostic command' : 'Continuation guidance command';
-    const lines = [
-        'SDD Status',
-        `Project: ${input.project}`,
-        `Change: ${input.status.change}`,
-        `Status: ${statusLabel}`,
-        `Next ready phase: ${input.status.nextReadyPhase ?? 'none'}`,
-        '',
-        'Phases:',
-        ...input.status.phases.map((phase) => `- ${phase.phase}: ${phase.present ? (phase.state ?? 'present') : 'missing'}; accepted=${phase.accepted === true ? 'yes' : 'no'}; topic=${phase.topicKey}`),
-        '',
-        'Blockers:',
-        ...(blockers.length === 0 ? ['- none'] : blockers.map((phase) => `- ${phase.phase}: ${phase.state ?? 'present'} at ${phase.topicKey}`)),
-        '',
-        'Missing topic keys:',
-        ...(missing.length === 0 ? ['- none'] : missing.map((topicKey) => `- ${topicKey}`)),
-        '',
-        `Recommended action: ${recommendedAction}`,
-        `${commandLabel}: ${directPhaseCommand ?? `vgxness sdd next --project ${input.project} --change ${input.status.change}`}`,
-        `JSON: vgxness sdd status --project ${input.project} --change ${input.status.change} --json`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddNext(input) {
-    const blockers = input.decision.blockedPrerequisites ?? [];
-    const guidance = input.decision.blockerGuidance ?? [];
-    const phase = input.decision.nextPhase ?? 'none';
-    const commandGuidance = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
-        ? `vgxness sdd continue --project ${input.project} --change ${input.decision.change}`
-        : `vgxness sdd status --project ${input.project} --change ${input.decision.change}`;
-    const commandLabel = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined ? 'Continuation guidance command' : 'Diagnostic command';
-    const primaryAction = input.decision.status === 'runnable' && input.decision.nextPhase !== undefined
-        ? `Continue the ${input.decision.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.`
-        : input.decision.recommendedAction;
-    const lines = [
-        'SDD Next',
-        `Project: ${input.project}`,
-        `Change: ${input.decision.change}`,
-        `Status: ${input.decision.status}`,
-        `Next phase: ${phase}`,
-        `Reason: ${input.decision.reason}`,
-        '',
-        'Blockers:',
-        ...(blockers.length === 0
-            ? ['- none']
-            : blockers.map((blocker) => `- ${blocker.phase}: ${blocker.reason} at ${blocker.topicKey}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
-        '',
-        'Missing topic keys:',
-        ...(input.decision.missingArtifactTopicKeys.length === 0 ? ['- none'] : input.decision.missingArtifactTopicKeys.map((topicKey) => `- ${topicKey}`)),
-        '',
-        'Missing prerequisite topic keys:',
-        ...((input.decision.missingPrerequisiteTopicKeys ?? []).length === 0
-            ? ['- none']
-            : (input.decision.missingPrerequisiteTopicKeys ?? []).map((topicKey) => `- ${topicKey}`)),
-        '',
-        'Next actions:',
-        ...(guidance.length === 0 ? ['- none'] : guidance.map((item) => `- ${item.phase}: ${item.action}`)),
-        '',
-        `Recommended action: ${primaryAction}`,
-        `${commandLabel}: ${commandGuidance}`,
-        `JSON: vgxness sdd next --project ${input.project} --change ${input.decision.change} --json`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddContinuationPlan(plan) {
-    const suggestedCommandLabel = plan.status === 'runnable' ? 'Continuation guidance command' : 'Diagnostic command';
-    const lines = [
-        'SDD Continue (read-only)',
-        `Project: ${plan.project}`,
-        `Change: ${plan.change}`,
-        `Status: ${plan.status}`,
-        `Next phase: ${plan.nextPhase ?? 'none'}`,
-        `Actionable phase: ${plan.actionablePhase ?? 'none'}`,
-        `Reason: ${plan.reason}`,
-        '',
-        'Recommended plan:',
-        `- ${plan.status === 'runnable' && plan.nextPhase !== undefined ? `Continue the ${plan.nextPhase} phase in OpenCode using VGXNESS MCP and hidden SDD subagents.` : plan.recommendedAction}`,
-        `- ${suggestedCommandLabel}: ${plan.suggestedCommand}`,
-        `- Diagnostic command: ${plan.inspectCommand}`,
-        '',
-        ...renderSddAdviceLines(plan.advice),
-        ...(plan.advice.length === 0 ? [] : ['']),
-        'Blocker-specific next actions:',
-        ...(plan.blockerActions.length === 0
-            ? ['- none']
-            : plan.blockerActions.map((item) => {
-                const draftRun = item.draftRunCommand === undefined ? '' : `; manualFallbackCommand=${item.draftRunCommand}`;
-                const warning = item.warning === undefined ? '' : `; warning=${item.warning}`;
-                return `- ${item.phase}: ${item.action}; recoveryCommand=${item.command}${draftRun}${warning}`;
-            })),
-        '',
-        ...(plan.relatedRunContext === undefined
-            ? []
-            : [
-                'Related interrupted run:',
-                `- Run ID: ${plan.relatedRunContext.runId}`,
-                `- Status: ${plan.relatedRunContext.status}`,
-                `- Workflow/phase: ${plan.relatedRunContext.workflow}/${plan.relatedRunContext.phase}`,
-                `- Latest checkpoint: ${plan.relatedRunContext.latestCheckpointLabel ?? 'none'}`,
-                `- Recommendation: ${plan.relatedRunContext.recommendation}`,
-                `- Resume command: ${plan.relatedRunContext.resumeCommand}`,
-                '',
-            ]),
-        'Safety:',
-        ...plan.safety.map((line) => `- ${line}`),
-        '',
-        `JSON: vgxness sdd continue --project ${plan.project} --change ${plan.change} --json${continuationDbFlag(plan.explicitDatabasePath)}`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddAdviceLines(advice) {
-    if (advice.length === 0)
-        return [];
-    return ['Advice:', ...advice.map((item) => `- ${item.title}: ${item.message}`)];
-}
-export function renderSddCockpit(cockpit) {
-    const readModel = cockpit.readModel;
-    const blockers = readModel.blockers;
-    const lines = [
-        'SDD Cockpit (read-only)',
-        `Project: ${readModel.project}`,
-        `Change: ${readModel.change}`,
-        `Next action: ${readModel.nextAction.kind}${readModel.nextAction.phase === undefined ? '' : ` / ${readModel.nextAction.phase}`}`,
-        `Recommended action: ${readModel.nextAction.label}`,
-        `Content included: ${readModel.contentIncluded ? 'yes' : 'no'}`,
-        `Accepted: ${readModel.summary.acceptedArtifacts}/${readModel.summary.totalPhases}`,
-        `Legacy artifacts: ${readModel.summary.legacyArtifacts}`,
-        '',
-        'Phases:',
-        ...readModel.phases.map((phase) => `- ${phase.phase}: status=${phase.artifact.status}; accepted=${phase.acceptance.acceptedByHuman ? 'human' : 'no'}; content=${phase.artifact.contentAvailable ? 'metadata-only' : 'none'}; topic=${phase.topicKey}`),
-        '',
-        'Blockers:',
-        ...(blockers.length === 0
-            ? ['- none']
-            : blockers.map((blocker) => `- ${blocker.severity}/${blocker.code}: ${blocker.phase ?? 'change'} at ${blocker.topicKey ?? '-'} - ${blocker.message}${blocker.action === undefined ? '' : `; action=${blocker.action}`}`)),
-        '',
-        'Guidance:',
-        ...readModel.guidance.map((item) => `- ${item}`),
-        '',
-        `Inspect: ${cockpit.inspectCommand}`,
-        `Cockpit JSON: ${cockpit.inspectCommand}`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-function continuationDbFlag(explicitDatabasePath) {
-    return explicitDatabasePath === undefined ? '' : ` --db ${explicitDatabasePath}`;
-}
-export function renderSddArtifactAccepted(input) {
-    const lines = [
-        'SDD Artifact Accepted',
-        `- Project: ${input.project}`,
-        `- Change: ${input.change}`,
-        `- Phase: ${input.phase}`,
-        `- Topic key: ${input.topicKey}`,
-        `- Artifact ID: ${input.artifactId}`,
-        `- Accepted by: ${input.acceptedBy.displayName} (${input.acceptedBy.id})`,
-        `- Accepted at: ${input.acceptedAt}`,
-        ...(input.note === undefined ? [] : [`- Note: ${input.note}`]),
-        `JSON: vgxness sdd accept-artifact --project ${input.project} --change ${input.change} --phase ${input.phase} --actor ${input.acceptedBy.id} --json`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddArtifactReopened(input) {
-    const lines = [
-        'SDD Artifact Reopened',
-        `- Project: ${input.project}`,
-        `- Change: ${input.change}`,
-        `- Phase: ${input.phase}`,
-        `- Status: ${input.status}`,
-        `- Topic key: ${input.topicKey}`,
-        `- Artifact ID: ${input.artifactId}`,
-        `- Reopened by: ${input.reopenedBy.displayName} (${input.reopenedBy.id})`,
-        `- Reopened at: ${input.reopenedAt}`,
-        ...(input.note === undefined ? [] : [`- Note: ${input.note}`]),
-        `Next step: update the ${input.phase} artifact, then request human acceptance again.`,
-        `JSON: vgxness sdd reopen-artifact --project ${input.project} --change ${input.change} --phase ${input.phase} --actor ${input.reopenedBy.id} --json`,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddArtifactList(input) {
-    const artifactsByPhase = new Map(input.artifacts.map((artifact) => [artifact.phase, artifact]));
-    const hasArtifacts = input.artifacts.length > 0;
-    const lines = [
-        'SDD artifacts',
-        `Project: ${input.project}`,
-        `Change: ${input.change}`,
-        '',
-        'Phases:',
-        ...sddPhases.map((phase) => {
-            const artifact = artifactsByPhase.get(phase);
-            if (artifact === undefined)
-                return `- ${phase}: state=missing; accepted=no; updated=-; preview=-`;
-            const normalized = normalizedArtifactState(artifact);
-            const preview = 'preview' in artifact ? artifact.preview : artifact.content;
-            return `- ${phase}: state=${normalized.state}; accepted=${normalized.accepted ? 'yes' : 'no'}; updated=${artifact.updatedAt ?? '-'}; preview=${formatArtifactPreview(preview)}`;
-        }),
-        ...(hasArtifacts ? [] : ['', 'No stored SDD artifacts found for this change.']),
-    ];
-    return `${lines.join('\n')}\n`;
-}
-export function renderSddArtifactDetail(input) {
-    const normalized = normalizeSddArtifact(input.artifact);
-    const hash = input.artifact.hash ?? input.artifact.contentHash ?? '-';
-    const lines = [
-        'SDD artifact',
-        `Project: ${input.project}`,
-        `Change: ${input.change}`,
-        `Phase: ${input.phase}`,
-        `State: ${normalized.metadata.status}`,
-        `Accepted: ${normalized.metadata.status === 'accepted' ? 'yes' : 'no'}`,
-        `Updated: ${input.artifact.updatedAt ?? '-'}`,
-        `Hash: ${hash}`,
-        `Topic key: ${input.artifact.topicKey}`,
-        `Artifact: ${input.artifact.id}`,
-        '',
-        '--- Content ---',
-        input.artifact.content,
-    ];
-    return `${lines.join('\n')}\n`;
-}
-function formatArtifactPreview(content) {
-    const compact = (content ?? '').replace(/\s+/g, ' ').trim();
-    if (compact.length === 0)
-        return '-';
-    if (compact.length <= 80)
-        return compact;
-    return `${compact.slice(0, 79)}…`;
-}
-function normalizedArtifactState(artifact) {
-    if ('state' in artifact)
-        return { state: artifact.state, accepted: artifact.accepted };
-    const normalized = normalizeSddArtifact(artifact);
-    return { state: normalized.metadata.status, accepted: normalized.metadata.status === 'accepted' };
-}
+export * from '../interfaces/cli/sdd-renderer.js';

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

@@ -1,79 +1 @@
-import { joinSections, renderActionLine, renderPanel } from './tui-render-helpers.js';
-export function renderSetupPlan(plan) {
-    return `${joinSections([
-        renderPanel('VGXNESS Setup [read-only]', renderOverview(plan), { status: 'preview-only' }),
-        renderOpenCode(plan),
-        renderPanel('Planned Actions', renderActions(plan), { status: 'preview-only' }),
-        renderPanel('Backups', renderBackups(plan), { status: 'requires confirmation' }),
-        renderConflicts(plan),
-        renderPanel('Next Commands', renderNextCommands(plan), { status: 'manual' }),
-        'Safety: [read-only] preview only. No provider config was written. Explicit confirmation is required before writing provider config; apply with --yes only after review.',
-    ])}\n`;
-}
-function renderOpenCode(plan) {
-    if (plan.opencode === undefined)
-        return undefined;
-    const target = plan.opencode.targetPath === undefined ? 'not applicable' : plan.opencode.targetPath;
-    const status = plan.status === 'ready' ? 'ready' : plan.status === 'conflict' ? 'blocked' : 'manual';
-    return renderPanel('OpenCode Provider', [
-        field('Scope', plan.opencode.scope),
-        field('Action', plan.opencode.action),
-        field('Target path', target),
-        field('Installs agents', yesNo(plan.opencode.installsAgents)),
-        field('Reinstall entries', yesNo(plan.opencode.overwriteVgxness === true)),
-        field('Bash policy', formatBashPermissionPolicy(plan.opencode.bashPermissionPolicy)),
-        field('Agent names', plan.opencode.agentNames.length === 0 ? 'none' : plan.opencode.agentNames.join(', ')),
-    ], { status });
-}
-function renderActions(plan) {
-    if (plan.actions.length === 0)
-        return ['No provider config writes are planned for this preview.'];
-    return plan.actions.flatMap((action) => renderActionLine(action.id, {
-        labels: [action.mutating ? 'writes provider config' : 'no provider writes', action.backupRequired ? 'requires confirmation' : 'preview-only'],
-        description: action.targetPath === undefined ? action.description : `${action.description} Target: ${action.targetPath}`,
-    }));
-}
-function renderBackups(plan) {
-    if (plan.backupsPlanned.length === 0)
-        return ['No backups are required for this preview.'];
-    return plan.backupsPlanned.flatMap((backup) => renderActionLine(backup.targetPath, { labels: ['requires confirmation'], description: backup.reason }));
-}
-function renderConflicts(plan) {
-    if (plan.conflicts.length === 0)
-        return undefined;
-    return renderPanel('Conflicts & Recovery', plan.conflicts.flatMap((conflict) => renderActionLine(conflict.id, {
-        labels: [conflict.severity === 'blocking' ? 'blocked' : 'manual'],
-        description: [
-            conflict.message,
-            conflict.targetPath === undefined ? undefined : `Target: ${conflict.targetPath}`,
-            conflict.recovery === undefined ? undefined : `Recovery: ${conflict.recovery}`,
-        ]
-            .filter((value) => value !== undefined)
-            .join(' '),
-    })), { status: 'blocked' });
-}
-function renderNextCommands(plan) {
-    if (plan.nextCommands.length === 0)
-        return ['No next command is recommended.'];
-    return plan.nextCommands.flatMap((command) => renderActionLine(command, { labels: ['manual'] }));
-}
-function renderOverview(plan) {
-    return [
-        field('Project', plan.project),
-        field('Workspace', plan.workspaceRoot),
-        field('Database', `${plan.db.mode} — ${plan.db.path}`),
-        field('DB source', plan.db.source),
-        field('Provider', plan.provider),
-        field('Status', plan.status),
-    ];
-}
-function field(label, value) {
-    return `${label.padEnd(18)} ${value}`;
-}
-function yesNo(value) {
-    return value ? 'yes' : 'no';
-}
-function formatBashPermissionPolicy(policy) {
-    const typedPolicy = policy;
-    return `top-level ${typedPolicy.topLevel}; manager ${typedPolicy.manager}`;
-}
+export * from '../interfaces/cli/setup-plan-renderer.js';

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

@@ -1,50 +1 @@
-export function renderSetupStatus(status) {
-    return [
-        'Setup Status [read-only]',
-        `- 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('; ')}`,
-        ...renderProviderPreviews(status.providers),
-        `- 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}`,
-        'Safety: [read-only] status only. No provider config was written; providers were not executed. Mutating setup commands require explicit confirmation.',
-    ].join('\n');
-}
-export function setupNeedsAction(status) {
-    return status.store.status !== 'ready' || status.verification.status !== 'ready' || status.defaults.status === 'blocked';
-}
-function renderProviderPreviews(providers) {
-    const previews = providers.flatMap((provider) => (provider.preview === undefined ? [] : renderProviderPreview(provider)));
-    return previews.length === 0 ? [] : ['- Provider plan previews:', ...previews];
-}
-function renderProviderPreview(provider) {
-    const preview = provider.preview;
-    if (preview === undefined)
-        return [];
-    return [
-        `  - ${provider.displayName}: ${preview.action} — ${preview.summary}${preview.targetPath === undefined ? '' : ` (${preview.targetPath})`}`,
-        ...(preview.backupRequired === undefined ? [] : [`    Backup required: ${String(preview.backupRequired)}`]),
-        ...(preview.confirmationRequired === undefined ? [] : [`    Confirmation required: ${String(preview.confirmationRequired)}`]),
-        ...(preview.risks.length === 0 ? [] : [`    Risks: ${preview.risks.join(' ')}`]),
-        ...(preview.warnings.length === 0 ? [] : [`    Warnings: ${preview.warnings.join(' ')}`]),
-    ];
-}
-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}/${renderSupportLevel(provider.supportLevel)} (${safety})`;
-}
-function renderSupportLevel(supportLevel) {
-    if (supportLevel === 'supported-primary' || supportLevel === 'supported-secondary')
-        return 'supported';
-    return supportLevel;
-}
+export * from '../interfaces/cli/setup-status-renderer.js';

package/dist/cli/setup-tui-app.js

@@ -1,130 +1 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { TuiCard, TuiFocusedLine, TuiFooter, TuiHeader, TuiTabs } from './tui/ink/components.js';
-import { inkTuiTheme, normalizeInkTuiWidth } from './tui/ink/theme.js';
-export const setupTuiTabs = ['overview', 'provider', 'actions', 'safety'];
-const setupTuiTabItems = setupTuiTabs.map((tab) => ({ key: tab, label: labelForTab(tab) }));
-export function SetupTuiApp({ plan, width, selectedTab, focusedActionIndex, confirmationVisible }) {
-    const cardWidth = normalizeInkTuiWidth(width);
-    return (_jsxs(Box, { flexDirection: "column", width: cardWidth, paddingX: 1, paddingY: 1, children: [_jsx(TuiHeader, { title: inkTuiTheme.copy.setupTitle, subtitle: inkTuiTheme.copy.setupSubtitle, project: plan.project }), _jsx(TuiTabs, { items: setupTuiTabItems, selectedKey: selectedTab }), _jsx(Box, { marginTop: 1, children: _jsx(SelectedPanel, { plan: plan, selectedTab: selectedTab, focusedActionIndex: focusedActionIndex }) }), selectedTab === 'actions' && confirmationVisible && (_jsx(Box, { marginTop: 1, children: _jsx(ConfirmationPanel, { plan: plan, focusedActionIndex: focusedActionIndex }) })), _jsx(TuiFooter, { text: selectedTab === 'actions' ? inkTuiTheme.copy.actionHelp : inkTuiTheme.copy.keyboardHelp })] }));
-}
-function SelectedPanel({ plan, selectedTab, focusedActionIndex }) {
-    if (selectedTab === 'overview')
-        return _jsx(TuiCard, { title: "Overview", badge: "preview-only", tone: "warning", lines: overviewLines(plan) });
-    if (selectedTab === 'provider')
-        return _jsx(TuiCard, { title: "Provider Detail", badge: plan.status === 'ready' ? 'ready' : 'blocked', tone: plan.status === 'ready' ? 'success' : 'danger', lines: providerLines(plan) });
-    if (selectedTab === 'actions')
-        return _jsx(ActionsPanel, { plan: plan, focusedActionIndex: focusedActionIndex });
-    return _jsx(TuiCard, { title: "Safety", badge: "no provider writes", tone: "info", lines: safetyLines() });
-}
-function ActionsPanel({ plan, focusedActionIndex }) {
-    if (plan.actions.length === 0 && hasSetupTuiReinstallOption(plan)) {
-        return (_jsx(TuiCard, { title: "Actions", badge: "reinstall available", tone: "warning", children: _jsxs(Box, { flexDirection: "column", children: [_jsx(TuiFocusedLine, { label: "setup-reinstall [requires --yes] [VGXNESS-managed only]", focused: focusedActionIndex === 0 }), _jsx(Text, { color: "gray", children: "  Reinstall existing VGXNESS-managed OpenCode entries only; unrelated OpenCode config is preserved." }), _jsx(Text, { color: "gray", children: "  Command after review: vgxness setup reinstall --yes" })] }) }));
-    }
-    if (plan.actions.length === 0)
-        return _jsx(TuiCard, { title: "Actions", badge: "preview-only", tone: "warning", lines: ['No provider config writes are planned for this preview.'] });
-    return (_jsx(TuiCard, { title: "Actions", badge: "preview-only", tone: "warning", children: plan.actions.map((action, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(TuiFocusedLine, { label: actionLineLabel(action), focused: index === focusedActionIndex }), _jsxs(Text, { color: "gray", children: ["  ", action.description] })] }, action.id))) }));
-}
-function actionLineLabel(action) {
-    return `${action.id} ${action.mutating ? '[writes provider config]' : '[no provider writes]'} ${action.backupRequired ? '[requires confirmation]' : '[preview-only]'}`;
-}
-function ConfirmationPanel({ plan, focusedActionIndex }) {
-    const action = plan.actions[focusedActionIndex];
-    if (action === undefined && hasSetupTuiReinstallOption(plan)) {
-        return (_jsx(TuiCard, { title: "Confirm Reinstall", badge: "requires confirmation", tone: "warning", lines: [
-                'Selected action: setup-reinstall',
-                'This TUI is read-only and did not reinstall anything.',
-                'Reinstall replaces only VGXNESS-managed entries: mcp.vgxness and known VGXNESS agents/instructions.',
-                'Unrelated OpenCode config is preserved; this is not a full opencode.json reset.',
-                'Run manually after review: vgxness setup reinstall --yes',
-                'Press q or Esc to leave this preview.',
-            ] }));
-    }
-    if (action === undefined)
-        return null;
-    return (_jsx(TuiCard, { title: "Confirm Action", badge: "requires confirmation", tone: "warning", lines: [
-            `Selected action: ${action.id}`,
-            inkTuiTheme.copy.readOnlyConfirmation,
-            inkTuiTheme.copy.manualApplyCommand,
-            'Press q or Esc to leave this preview.',
-        ] }));
-}
-function overviewLines(plan) {
-    return [
-        'Setup summary',
-        '',
-        field('Project', plan.project),
-        field('Status', plan.status),
-        field('Provider', plan.provider),
-        field('Database', `${plan.db.mode} (${plan.db.source})`),
-        field('Safety', 'read-only preview'),
-        '',
-        `Workspace: ${plan.workspaceRoot}`,
-        `DB path: ${plan.db.path}`,
-    ];
-}
-function providerLines(plan) {
-    if (plan.opencode === undefined)
-        return [field('Provider', plan.provider), 'No provider-specific plan is available.'];
-    const blocker = providerBlockerGuidance(plan);
-    if (blocker !== undefined)
-        return blocker;
-    return [
-        field('Provider', 'opencode'),
-        field('Scope', plan.opencode.scope),
-        field('Action', plan.opencode.action),
-        field('Installs agents', plan.opencode.installsAgents ? 'yes' : 'no'),
-        field('Agent count', String(plan.opencode.agentNames.length)),
-        field('Recommended', recommendedProviderAction(plan)),
-        '',
-        `Target: ${plan.opencode.targetPath ?? 'not applicable'}`,
-    ];
-}
-function providerBlockerGuidance(plan) {
-    const conflict = plan.conflicts.find((item) => isExistingVgxnessInstallConflict(item.id));
-    if (conflict === undefined || plan.opencode === undefined)
-        return undefined;
-    return [
-        'Already installed',
-        '',
-        conflict.id === 'existing_vgxness_mcp' ? 'OpenCode already has mcp.vgxness configured.' : 'OpenCode already has VGXNESS agent entries configured.',
-        'A reinstall option is available because existing VGXNESS-managed entries were detected.',
-        '',
-        field('Provider', 'opencode'),
-        field('Scope', plan.opencode.scope),
-        field('Target', plan.opencode.targetPath ?? conflict.targetPath ?? 'not applicable'),
-        '',
-        'Reinstall option',
-        'Open the Actions tab to preview reinstall guidance.',
-        'It replaces only VGXNESS-managed entries and preserves unrelated OpenCode config.',
-        'Command after review: vgxness setup reinstall --yes',
-    ];
-}
-export function hasSetupTuiReinstallOption(plan) {
-    return plan.opencode !== undefined && plan.conflicts.some((item) => isExistingVgxnessInstallConflict(item.id));
-}
-function isExistingVgxnessInstallConflict(id) {
-    return id === 'existing_vgxness_mcp' || id === 'existing_vgxness_agent';
-}
-function safetyLines() {
-    return ['This setup TUI is read-only.', 'No provider config was written.', 'No provider process was executed.', 'Apply remains explicit through setup apply --yes after review.'];
-}
-function labelForTab(tab) {
-    if (tab === 'overview')
-        return 'Setup';
-    if (tab === 'provider')
-        return 'Provider';
-    if (tab === 'actions')
-        return 'Actions';
-    return 'Safety';
-}
-function field(label, value) {
-    return `${label.padEnd(16)} ${value}`;
-}
-function recommendedProviderAction(plan) {
-    if (plan.status === 'conflict')
-        return 'Resolve blocker, then rerun setup plan';
-    if (plan.status === 'manual-required')
-        return 'Follow manual recovery guidance';
-    return 'Review plan, then run setup apply --yes only if it matches your intent';
-}
+export * from '../interfaces/cli/setup-tui-app.js';

package/dist/cli/setup-tui-controller.js

@@ -1,89 +1 @@
-import { okText } from './cli-help.js';
-import { renderSetupPlan } from './setup-plan-renderer.js';
-import { render as renderInk } from 'ink';
-import React from 'react';
-import { hasSetupTuiReinstallOption, SetupTuiApp } from './setup-tui-app.js';
-import { navigationIntentFromInput } from './tui/keymap.js';
-import { nextItem } from './tui/navigation.js';
-const enter = '\r';
-const escape = '\u001B';
-const ctrlC = '\u0003';
-const setupTabs = ['overview', 'provider', 'actions', 'safety'];
-export async function runSetupTuiController(input) {
-    const { stdin, stdout } = input.environment;
-    if (stdin === undefined || stdout === undefined)
-        return okText(renderSetupPlan(input.plan));
-    const width = setupTuiWidth(stdout);
-    let selectedTab = 'overview';
-    let focusedActionIndex = 0;
-    let confirmationVisible = false;
-    const app = renderInk(React.createElement(SetupTuiApp, { plan: input.plan, width, selectedTab, focusedActionIndex, confirmationVisible }), {
-        stdin: stdin,
-        stdout: stdout,
-        interactive: true,
-        patchConsole: false,
-        exitOnCtrlC: false,
-    });
-    const rerender = () => {
-        app.rerender(React.createElement(SetupTuiApp, { plan: input.plan, width, selectedTab, focusedActionIndex, confirmationVisible }));
-    };
-    stdin.setRawMode?.(true);
-    stdin.resume?.();
-    await new Promise((resolve) => {
-        const listener = (chunk) => {
-            const value = chunk.toString();
-            const intent = navigationIntentFromInput(value);
-            if (intent === 'cancel' || value === 'Q' || value === ctrlC) {
-                cleanup();
-                resolve();
-                return;
-            }
-            if ((intent === 'next' && (value === enter || value === '\n')) || intent === 'select') {
-                if (selectedTab === 'actions' && (input.plan.actions.length > 0 || hasSetupTuiReinstallOption(input.plan))) {
-                    confirmationVisible = true;
-                    rerender();
-                    return;
-                }
-            }
-            if (selectedTab === 'actions' && (intent === 'down' || intent === 'up')) {
-                focusedActionIndex = clampActionIndex(input.plan, intent === 'down' ? focusedActionIndex + 1 : focusedActionIndex - 1);
-                confirmationVisible = false;
-                rerender();
-                return;
-            }
-            if (intent === 'next' || intent === 'down') {
-                selectedTab = nextItem(setupTabs, selectedTab, 1);
-                confirmationVisible = false;
-                rerender();
-                return;
-            }
-            if (intent === 'back' || intent === 'up') {
-                selectedTab = nextItem(setupTabs, selectedTab, -1);
-                confirmationVisible = false;
-                rerender();
-            }
-        };
-        const cleanup = () => {
-            if (stdin.off !== undefined)
-                stdin.off('data', listener);
-            else
-                stdin.removeListener?.('data', listener);
-            stdin.setRawMode?.(false);
-            stdin.pause?.();
-            app.unmount();
-        };
-        stdin.on('data', listener);
-    });
-    await app.waitUntilExit();
-    return okText('');
-}
-function clampActionIndex(plan, index) {
-    if (plan.actions.length === 0)
-        return 0;
-    return Math.max(0, Math.min(index, plan.actions.length - 1));
-}
-function setupTuiWidth(stdout) {
-    const columns = stdout.columns;
-    const width = typeof columns === 'number' && Number.isFinite(columns) ? Math.floor(columns) : 88;
-    return Math.max(60, Math.min(width, 88));
-}
+export * from '../interfaces/cli/setup-tui-controller.js';

package/dist/cli/tui/focus-reducer.js

@@ -0,0 +1 @@
+export * from '../../interfaces/cli/tui/focus-reducer.js';

package/dist/cli/tui/focus-types.js

@@ -0,0 +1 @@
+export * from '../../interfaces/cli/tui/focus-types.js';

package/dist/cli/tui/ink/app-shell.js

@@ -0,0 +1 @@
+export * from '../../../interfaces/cli/tui/ink/app-shell.js';

package/dist/cli/tui/ink/components.js

@@ -1,38 +1 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { colorForTone, inkTuiTheme } from './theme.js';
-export function TuiHeader({ title, subtitle, project }) {
-    return (_jsxs(Box, { borderStyle: "round", borderColor: colorForTone('info'), paddingX: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, color: colorForTone('info'), children: [inkTuiTheme.symbols.brand, " ", title] }), _jsx(Text, { children: " " }), _jsx(TuiBadge, { label: inkTuiTheme.copy.readOnlyBadge, tone: "warning" }), _jsx(Text, { children: " " }), _jsx(TuiBadge, { label: inkTuiTheme.copy.previewOnlyBadge, tone: "warning" })] }), _jsxs(Text, { color: colorForTone('neutral'), children: [subtitle, " \u00B7 ", project] })] }));
-}
-export function TuiTabs({ items, selectedKey }) {
-    return (_jsx(Box, { marginTop: 1, gap: 2, children: items.map((item) => {
-            const selected = item.key === selectedKey;
-            return (_jsxs(Text, { color: selected ? colorForTone('info') : colorForTone('neutral'), bold: selected, children: [selected ? inkTuiTheme.symbols.selected : inkTuiTheme.symbols.unselected, " ", item.label] }, item.key));
-        }) }));
-}
-export function TuiSummaryBar({ items }) {
-    return (_jsx(Box, { marginTop: 1, gap: 1, children: items.map((item) => {
-            const tone = item.tone ?? 'neutral';
-            const color = colorForTone(tone);
-            return (_jsxs(Box, { borderStyle: "single", borderColor: color, paddingX: 1, flexDirection: "column", children: [_jsx(Text, { color: color, bold: true, children: item.value }), _jsx(Text, { color: colorForTone('neutral'), children: item.label })] }, `${item.label}:${item.value}`));
-        }) }));
-}
-export function TuiCard({ title, badge, tone = 'info', lines, children }) {
-    const color = colorForTone(tone);
-    return (_jsxs(Box, { borderStyle: "round", borderColor: color, paddingX: 1, flexDirection: "column", width: "100%", children: [_jsxs(Text, { bold: true, color: color, children: [title, badge === undefined ? '' : ` [${badge}]`] }), (lines ?? []).map((line, index) => line.length === 0 ? (_jsx(Text, { children: " " }, lineKey(line, index))) : (_jsx(Text, { children: line }, lineKey(line, index)))), children] }));
-}
-export function TuiFooter({ text }) {
-    return (_jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: colorForTone('neutral'), paddingX: 1, children: _jsx(Text, { color: colorForTone('neutral'), children: text }) }));
-}
-export function TuiBadge({ label, tone }) {
-    return _jsxs(Text, { color: colorForTone(tone), children: ["[", label, "]"] });
-}
-export function TuiFocusedLine({ label, focused }) {
-    if (focused) {
-        return (_jsxs(Text, { color: colorForTone('info'), bold: true, children: [inkTuiTheme.symbols.selected, " ", label] }));
-    }
-    return _jsxs(Text, { children: ["  ", label] });
-}
-function lineKey(line, index) {
-    return `${index}:${line}`;
-}
+export * from '../../../interfaces/cli/tui/ink/components.js';

package/dist/cli/tui/ink/help-overlay.js

@@ -0,0 +1 @@
+export * from '../../../interfaces/cli/tui/ink/help-overlay.js';