vgxness 1.3.0 → 1.4.0

package/dist/cli/guided-main-menu.js

@@ -1,470 +0,0 @@
-export const guidedMainMenuOptions = [
-    { id: 'guided-install', label: 'Guided installation', summary: 'Recommended setup path; plans first, writes only after review and explicit confirmation.' },
-    { id: 'doctor-recovery', label: 'Doctor / recovery', summary: 'Read-only status and recovery guidance.' },
-    { id: 'advanced-cli', label: 'Advanced CLI', summary: 'Command-oriented help for scripting and manual workflows.' },
-    { id: 'exit', label: 'Exit', summary: 'Quit without changes.' },
-];
-const guidedMemoryOptions = [
-    { id: 'global', label: 'Global/default memory (recommended)', summary: 'Use the existing default/global VGXNESS memory path.' },
-    {
-        id: 'project-local',
-        label: 'Project-local memory (deferred)',
-        summary: 'Shown for planning only; guided install does not create a new project-local store yet.',
-    },
-    { id: 'skip', label: 'Skip memory setup', summary: 'Continue with provider/status guidance only; no new memory storage logic is run.' },
-];
-const guidedProviderOptions = [
-    { id: 'opencode', label: 'OpenCode', summary: 'Default; automatic apply-capable only after review and explicit confirmation.' },
-    { id: 'claude', label: 'Claude', summary: 'Preview/manual guidance only; automatic apply is never called.' },
-    { id: 'antigravity', label: 'Antigravity', summary: 'Deferred/manual guidance; automatic apply is never called.' },
-    { id: 'custom', label: 'Custom', summary: 'Deferred/manual extension point; automatic apply is never called.' },
-    { id: 'none', label: 'None', summary: 'Planning/status-only; no provider apply path.' },
-];
-export function createGuidedMainMenuState() {
-    return {
-        screen: 'menu',
-        selectedIndex: 0,
-        memorySelectedIndex: 0,
-        providerSelectedIndex: 0,
-        selectedMemory: 'global',
-        selectedProvider: 'opencode',
-        shouldExit: false,
-    };
-}
-export function noTtyGuidedMenuGuidance() {
-    return `VGXNESS interactive menu requires a terminal.
-
-Run one of:
-  vgxness init
-  vgxness doctor
-  vgxness --help
-
-Or run \`vgxness\` in an interactive terminal to use Guided installation.
-
-No changes were made.
-`;
-}
-export function createGuidedSetupPreview(input) {
-    return {
-        status: input.status,
-        project: input.project,
-        databaseMode: input.database.mode,
-        databasePath: input.database.path,
-        provider: input.provider,
-        memorySelection: memorySelectionCopy(input.database.mode),
-        actions: input.actions.map((action) => `${action.description}${action.targetPath === undefined ? '' : ` (${action.targetPath})`}${action.backupRequired ? ' [backup planned]' : ''}${action.mutating ? ' [apply would mutate]' : ' [plan-only]'}`),
-        conflicts: input.conflicts.map((conflict) => `${conflict.message}${conflict.recovery === undefined ? '' : ` Recovery: ${conflict.recovery}`}`),
-        backups: input.backupsPlanned.map((backup) => `${backup.targetPath}: ${backup.reason}`),
-        nextCommands: [...input.nextCommands],
-        safety: {
-            planMutates: input.safety.mutating,
-            planWritesProviderConfig: input.safety.writesProviderConfig,
-            requiresConfirmationForApply: input.safety.requiresConfirmationForApply,
-        },
-    };
-}
-export function renderGuidedMainMenu(state = createGuidedMainMenuState(), context = {}) {
-    const setupPreview = guidedSetupPreviewForState(state, context.setupPreview);
-    if (state.screen === 'guided-install')
-        return renderGuidedInstallScreen();
-    if (state.screen === 'memory-selection')
-        return renderMemorySelectionScreen(state, setupPreview);
-    if (state.screen === 'provider-selection')
-        return renderProviderSelectionScreen(state, setupPreview);
-    if (state.screen === 'setup-review')
-        return renderSetupReviewScreen(setupPreview, state.confirmationNotice);
-    if (state.screen === 'setup-confirm')
-        return renderSetupConfirmScreen(setupPreview, state.confirmationNotice);
-    if (state.screen === 'apply-result')
-        return renderApplyResultScreen(state.applyResult);
-    if (state.screen === 'doctor-recovery')
-        return renderDoctorRecoveryScreen();
-    if (state.screen === 'advanced-cli')
-        return renderAdvancedCliScreen();
-    return `VGXNESS
-
-Set up VGXNESS in your coding agent, then do daily SDD work inside that provider.
-
-? What would you like to do?
-${guidedMainMenuOptions.map((option, index) => renderGuidedMainMenuOption(option, index === state.selectedIndex)).join('\n')}
-
-OpenCode automatic setup is available after review and explicit confirmation.
-Claude is preview/manual only; Antigravity and custom providers are manual/deferred.
-
-Keys: ↑/↓ or j/k move · Enter open · q quits. No changes are made from this menu until a reviewed plan is explicitly confirmed.
-`;
-}
-export async function runGuidedMainMenuLoop(terminal) {
-    return new Promise((resolve) => {
-        let state = createGuidedMainMenuState();
-        const render = () => {
-            terminal.output.write(`\u001Bc${renderGuidedMainMenu(state, terminal.context ?? {})}`);
-        };
-        const finish = () => {
-            terminal.input.setRawMode?.(false);
-            terminal.input.pause?.();
-            if (terminal.input.off !== undefined)
-                terminal.input.off('data', onData);
-            else
-                terminal.input.removeListener?.('data', onData);
-            resolve();
-        };
-        const onData = (chunk) => {
-            void (async () => {
-                const input = chunk.toString();
-                state = await handleGuidedMainMenuInput(state, input, terminal.context ?? {});
-                render();
-                if (state.shouldExit)
-                    finish();
-            })();
-        };
-        terminal.input.setRawMode?.(true);
-        terminal.input.resume?.();
-        terminal.input.on('data', onData);
-        render();
-    });
-}
-export function reduceGuidedMainMenuInput(state, input) {
-    if (input === 'q' || input === '\u0003')
-        return { ...state, shouldExit: true };
-    if (state.screen === 'guided-install') {
-        if (input === '\r' || input === '\n' || input === 'n')
-            return withoutConfirmationNotice({ ...state, screen: 'memory-selection' });
-        if (input === 'b' || input === '\u001B')
-            return withoutConfirmationNotice({ ...state, screen: 'menu' });
-        return state;
-    }
-    if (state.screen === 'memory-selection') {
-        if (input === 'j' || input === '\u001B[B')
-            return { ...state, memorySelectedIndex: (state.memorySelectedIndex + 1) % guidedMemoryOptions.length };
-        if (input === 'k' || input === '\u001B[A')
-            return { ...state, memorySelectedIndex: (state.memorySelectedIndex - 1 + guidedMemoryOptions.length) % guidedMemoryOptions.length };
-        if (input === 'b' || input === '\u001B')
-            return withoutConfirmationNotice({ ...state, screen: 'guided-install' });
-        if (input === '\r' || input === '\n') {
-            const selectedMemory = guidedMemoryOptions[state.memorySelectedIndex]?.id ?? 'global';
-            return withoutConfirmationNotice({ ...state, selectedMemory, screen: 'provider-selection' });
-        }
-        return state;
-    }
-    if (state.screen === 'provider-selection') {
-        if (input === 'j' || input === '\u001B[B')
-            return { ...state, providerSelectedIndex: (state.providerSelectedIndex + 1) % guidedProviderOptions.length };
-        if (input === 'k' || input === '\u001B[A')
-            return { ...state, providerSelectedIndex: (state.providerSelectedIndex - 1 + guidedProviderOptions.length) % guidedProviderOptions.length };
-        if (input === 'b' || input === '\u001B')
-            return withoutConfirmationNotice({ ...state, screen: 'memory-selection' });
-        if (input === '\r' || input === '\n') {
-            const selectedProvider = guidedProviderOptions[state.providerSelectedIndex]?.id ?? 'opencode';
-            return withoutConfirmationNotice({ ...state, selectedProvider, screen: 'setup-review' });
-        }
-        return state;
-    }
-    if (state.screen === 'setup-review') {
-        if (input === 'b' || input === '\u001B')
-            return withoutConfirmationNotice({ ...state, screen: 'provider-selection' });
-        if (input === 'a' || input === 'c' || input === '\r' || input === '\n')
-            return withoutConfirmationNotice({ ...state, screen: 'setup-confirm' });
-        return state;
-    }
-    if (state.screen === 'setup-confirm') {
-        if (input === 'b' || input === '\u001B' || input === 'n')
-            return withoutConfirmationNotice({ ...state, screen: 'setup-review' });
-        if (input === 'y')
-            return {
-                ...state,
-                confirmationNotice: 'Apply is not run from this preview unless a safe apply callback is installed. Use the explicit CLI apply command after review.',
-            };
-        return state;
-    }
-    if (state.screen === 'apply-result') {
-        if (input === 'b' || input === '\u001B')
-            return withoutApplyResult(withoutConfirmationNotice({ ...state, screen: 'setup-review' }));
-        return state;
-    }
-    if (state.screen !== 'menu') {
-        if (input === 'b' || input === '\u001B')
-            return { ...state, screen: 'menu' };
-        return state;
-    }
-    if (input === 'j' || input === '\u001B[B')
-        return { ...state, selectedIndex: (state.selectedIndex + 1) % guidedMainMenuOptions.length };
-    if (input === 'k' || input === '\u001B[A')
-        return { ...state, selectedIndex: (state.selectedIndex - 1 + guidedMainMenuOptions.length) % guidedMainMenuOptions.length };
-    if (input === '\r' || input === '\n') {
-        const selected = guidedMainMenuOptions[state.selectedIndex]?.id ?? 'guided-install';
-        if (selected === 'exit')
-            return { ...state, shouldExit: true };
-        return { ...state, screen: selected };
-    }
-    return state;
-}
-export async function handleGuidedMainMenuInput(state, input, context = {}) {
-    if (state.screen === 'setup-confirm' && input === 'y') {
-        const preview = guidedSetupPreviewForState(state, context.setupPreview);
-        if (preview === undefined)
-            return { ...state, confirmationNotice: 'Apply is unavailable because no reviewed setup plan preview is loaded.' };
-        if (state.selectedProvider !== 'opencode' || preview.provider !== 'opencode')
-            return { ...state, confirmationNotice: 'Automatic apply is available only for OpenCode. This provider remains manual/deferred/status-only.' };
-        if (state.selectedMemory !== 'global')
-            return {
-                ...state,
-                confirmationNotice: 'Automatic OpenCode apply currently uses the default/global memory setup only. The selected memory option remains preview/manual-only.',
-            };
-        if (context.onApplyConfirmed === undefined)
-            return {
-                ...state,
-                confirmationNotice: 'Apply callback is not installed in this guided preview. Use `vgxness setup apply --yes` only after reviewing the plan.',
-            };
-        const applyResult = await context.onApplyConfirmed(preview);
-        return withoutConfirmationNotice({ ...state, screen: 'apply-result', applyResult });
-    }
-    return reduceGuidedMainMenuInput(state, input);
-}
-function withoutConfirmationNotice(state) {
-    const { confirmationNotice: _confirmationNotice, ...rest } = state;
-    return rest;
-}
-function withoutApplyResult(state) {
-    const { applyResult: _applyResult, ...rest } = state;
-    return rest;
-}
-function renderGuidedMainMenuOption(option, selected) {
-    return `${selected ? '›' : ' '} ${option.label} — ${option.summary}`;
-}
-function renderGuidedInstallScreen() {
-    return `VGXNESS · Guided installation
-
-We'll set up VGXNESS safely.
-No files are changed until review + explicit confirmation.
-
-Steps
-1. Memory setup
-2. Provider
-3. Review
-4. Confirm/apply
-
-Next: choose memory setup.
-
-Enter/n: continue · b/Esc: back · q: quit
-`;
-}
-function renderMemorySelectionScreen(state, setupPreview) {
-    return `VGXNESS · Guided installation · Memory setup selection
-
-Choose memory setup
-${guidedMemoryOptions.map((option, index) => `${index === state.memorySelectedIndex ? '›' : ' '} ${option.label} — ${option.summary}`).join('\n')}
-
-Preview impact
-${renderSetupPlanPreview(setupPreview)}
-
-Safety
-- This selection screen is read-only and does not create or migrate memory storage.
-- Global/default is recommended and remains the default.
-- Skip is reflected in preview/review copy; it does not run new memory storage logic.
-
-Keys: ↑/↓ or j/k: move · Enter: select · b/Esc: back · q: quit
-`;
-}
-function renderProviderSelectionScreen(state, setupPreview) {
-    return `VGXNESS · Guided installation · Provider selection
-
-Choose provider
-${guidedProviderOptions.map((option, index) => `${index === state.providerSelectedIndex ? '›' : ' '} ${option.label} — ${option.summary}`).join('\n')}
-
-Preview impact
-${renderSetupPlanPreview(setupPreview)}
-
-Safety
-- OpenCode is the default and the only automatic apply-capable provider.
-- Claude shows preview/manual guidance and never calls automatic apply.
-- Antigravity and Custom are deferred/manual and never call automatic apply.
-- None is planning/status-only and cannot reach provider apply.
-
-Keys: ↑/↓ or j/k: move · Enter: review · b/Esc: back · q: quit
-`;
-}
-function renderSetupReviewScreen(setupPreview, confirmationNotice) {
-    return `VGXNESS · Guided installation · Review / confirmation
-
-Review before any write
-${renderSetupPlanPreview(setupPreview)}
-
-Confirmation gate
-- No provider or memory writes have been performed.
-- This review screen still does not run setup apply.
-- OpenCode is the only automatic provider with a confirmed apply path.
-- Claude remains preview/manual only; Antigravity and Custom remain manual/deferred; None remains status-only.
-- Pressing Apply/Confirm opens one final explicit confirmation; only y on that screen can apply.
-${confirmationNotice === undefined ? '' : `\nNotice: ${confirmationNotice}`}
-
-If you are ready outside this guided preview, use the existing explicit command path after review:
-  vgxness init --plan
-  vgxness setup plan
-  vgxness setup apply --yes
-
-Enter/a: confirm · b/Esc: back · q: quit
-`;
-}
-function renderSetupConfirmScreen(setupPreview, confirmationNotice) {
-    return `VGXNESS · Guided installation · Explicit confirmation
-
-Final review checkpoint
-${renderSetupPlanPreview(setupPreview)}
-
-Explicit confirmation required
-- Press y only after reviewing the plan above.
-- No files have been changed yet.
-- Only OpenCode may use an automatic apply callback.
-- Claude is preview/manual only; Antigravity and Custom are manual/deferred; None is status-only.
-- If no safe apply callback is installed, y remains a no-write notice and points to the explicit CLI path.
-${confirmationNotice === undefined ? '' : `\nNotice: ${confirmationNotice}`}
-
-Existing explicit command path remains available after review:
-  vgxness setup apply --yes
-
-y: apply if available · n/b/Esc: back · q: quit
-`;
-}
-function renderApplyResultScreen(applyResult) {
-    if (applyResult === undefined) {
-        return `VGXNESS · Guided installation · Result summary
-
-No apply result is available. No changes were made.
-
-Keys: b/Esc returns to Review · q quits.
-`;
-    }
-    return `VGXNESS · Guided installation · Result summary
-
-Status: ${applyResult.status}
-Summary: ${applyResult.summary}
-
-Details
-${applyResult.details === undefined || applyResult.details.length === 0 ? '- None.' : applyResult.details.map((detail) => `- ${detail}`).join('\n')}
-
-Next steps
-${applyResult.nextSteps === undefined || applyResult.nextSteps.length === 0 ? '- Run vgxness doctor.' : applyResult.nextSteps.map((step) => `- ${step}`).join('\n')}
-
-Keys: b/Esc returns to Review · q quits.
-`;
-}
-function guidedSetupPreviewForState(state, basePreview) {
-    if (basePreview === undefined)
-        return undefined;
-    const memorySelection = memorySelectionCopy(state.selectedMemory);
-    if (state.selectedProvider === 'opencode') {
-        return {
-            ...basePreview,
-            provider: 'opencode',
-            memorySelection,
-            actions: state.selectedMemory === 'global'
-                ? basePreview.actions
-                : [`${memorySelection}; OpenCode automatic apply is disabled until default/global memory is selected.`, ...basePreview.actions],
-        };
-    }
-    if (state.selectedProvider === 'none') {
-        return {
-            ...basePreview,
-            provider: 'none',
-            memorySelection,
-            actions: ['Planning/status-only provider choice; no provider install or apply will run from guided setup.'],
-            backups: [],
-            nextCommands: ['vgxness init --plan', 'vgxness setup status', 'vgxness doctor'],
-            safety: { planMutates: false, planWritesProviderConfig: false, requiresConfirmationForApply: false },
-        };
-    }
-    const providerCopy = providerSelectionCopy(state.selectedProvider);
-    return {
-        ...basePreview,
-        provider: state.selectedProvider,
-        memorySelection,
-        actions: [
-            `${providerCopy}; render manual/deferred guidance only. No automatic provider apply is available.`,
-            'Use the read-only plan to copy settings manually after reviewing existing explicit setup guidance.',
-        ],
-        backups: [],
-        nextCommands: ['vgxness init --plan', 'vgxness setup plan', 'vgxness doctor'],
-        safety: { planMutates: false, planWritesProviderConfig: false, requiresConfirmationForApply: false },
-    };
-}
-function memorySelectionCopy(memory) {
-    if (memory === 'skip')
-        return 'Skip memory setup (no new memory storage logic)';
-    if (memory === 'project-local')
-        return 'Project-local memory (deferred/unavailable in guided setup)';
-    return 'Global/default memory (recommended)';
-}
-function providerSelectionCopy(provider) {
-    if (provider === 'claude')
-        return 'Claude preview/manual-only guidance';
-    if (provider === 'antigravity')
-        return 'Antigravity deferred/manual guidance';
-    if (provider === 'custom')
-        return 'Custom deferred/manual guidance';
-    if (provider === 'none')
-        return 'None planning/status-only';
-    return 'OpenCode automatic-capable after review and explicit confirmation';
-}
-function renderSetupPlanPreview(setupPreview) {
-    if (setupPreview === undefined) {
-        return '- Setup plan preview is unavailable in this render; run `vgxness init --plan` or `vgxness setup plan` for the read-only plan.';
-    }
-    return [
-        `- Status: ${setupPreview.status}`,
-        `- Project: ${setupPreview.project}`,
-        `- Database: ${setupPreview.databaseMode} (${setupPreview.databasePath})`,
-        `- Memory selection: ${setupPreview.memorySelection}`,
-        `- Provider: ${setupPreview.provider}`,
-        `- Safety: plan mutates=${String(setupPreview.safety.planMutates)} · plan writes provider config=${String(setupPreview.safety.planWritesProviderConfig)} · apply requires confirmation=${String(setupPreview.safety.requiresConfirmationForApply)}`,
-        '- Planned actions:',
-        ...(setupPreview.actions.length === 0 ? ['  - None.'] : setupPreview.actions.map((action) => `  - ${action}`)),
-        '- Conflicts:',
-        ...(setupPreview.conflicts.length === 0 ? ['  - None.'] : setupPreview.conflicts.map((conflict) => `  - ${conflict}`)),
-        '- Backups if apply is later confirmed:',
-        ...(setupPreview.backups.length === 0 ? ['  - None.'] : setupPreview.backups.map((backup) => `  - ${backup}`)),
-        '- Existing explicit command path:',
-        ...setupPreview.nextCommands.map((command) => `  - ${command}`),
-    ].join('\n');
-}
-function renderDoctorRecoveryScreen() {
-    return `VGXNESS · Doctor / recovery
-
-Read-only recovery entry
-Use doctor/status commands to inspect provider visibility, memory/default DB status, and setup readiness.
-
-Suggested commands
-  vgxness doctor
-  vgxness setup status
-  vgxness mcp doctor opencode
-
-Safety
-- Opening this screen does not run repairs or provider writes.
-- Any future rollback/recovery write must require its own explicit command and confirmation.
-- If setup is missing, run Guided installation or inspect a setup plan first.
-
-Keys: b/Esc returns to menu · q quits. No changes were made.
-`;
-}
-function renderAdvancedCliScreen() {
-    return `VGXNESS · Advanced CLI
-
-The CLI remains available for setup, doctor, rollback/recovery, and advanced/manual workflows.
-After setup, daily SDD work should happen inside OpenCode, Claude, or another configured provider.
-
-Common commands
-  vgxness init
-  vgxness init --plan
-  vgxness setup plan
-  vgxness setup apply --yes
-  vgxness setup status
-  vgxness doctor
-  vgxness --help
-
-Safety
-- This screen is guidance only and does not execute setup/apply commands.
-- Provider writes remain behind explicit setup/apply commands and confirmation.
-
-Keys: b/Esc returns to menu · q quits. No changes were made.
-`;
-}

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

@@ -1,72 +0,0 @@
-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,
-            ...(provider.preview === undefined ? {} : { preview: provider.preview }),
-            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;
-}