vgxness 1.20.4 → 1.20.6

package/dist/interfaces/cli/commands/setup-dispatcher.js

@@ -0,0 +1,496 @@
+import { resolve } from 'node:path';
+import { installOpenCodeMcpClient } from '../../../adapters/opencode/install/client-install-opencode.js';
+import { createOpenCodeMcpVisibilityReport } from '../../../adapters/opencode/install/opencode-visibility.js';
+import { AgentRegistryService } from '../../../agents/agent-registry-service.js';
+import { computeEffectiveManagerInstructions } from '../../../agents/manager-profile-overlay-service.js';
+import { resolveAgentProfileModel } from '../../../agents/profile-model-routing.js';
+import { createMcpClientSetupPreview } from '../../../mcp/client-setup-preview.js';
+import { applyRollbackConfigBackup, listProviderConfigBackups, previewRollbackConfigBackup, } from '../../../setup/backup-rollback-service.js';
+import { vgxnessSetupDefaults } from '../../../setup/setup-defaults.js';
+import { SetupLifecycleService } from '../../../setup/setup-lifecycle-service.js';
+import { createSetupPlan } from '../../../setup/setup-plan.js';
+import { databasePathFor, opencodeInstallScopeFlag, optionalStringFlag, providerUserGlobalOnlyMigrationMessage, scopeFlag, setupDatabaseFlags, setupInstallModeFlag, setupProviderFlag, } from '../cli-flags.js';
+import { okText, usageFailure, validationFailure } from '../cli-help.js';
+import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
+import { runHomeTuiController } from '../home-tui-controller.js';
+import { renderSetupPlan } from '../setup-plan-renderer.js';
+import { renderSetupStatus } from '../setup-status-renderer.js';
+import { runSetupTuiController } from '../setup-tui-controller.js';
+import { canRunInteractiveTui } from '../tui/terminal-capabilities.js';
+function renderSetupRollbackApply(result, parsed) {
+    if (parsed.flags.json === true)
+        return jsonResult(result);
+    if (!result.ok)
+        return resultFailure(result);
+    const lines = [
+        'Rollback restored OpenCode config.',
+        `Target: ${result.value.targetPath}`,
+        `Restored from: ${result.value.backupPath}`,
+        ...(result.value.preRollbackBackupPath === undefined ? [] : [`Pre-rollback backup: ${result.value.preRollbackBackupPath}`]),
+        'Next: vgxness doctor; restart OpenCode and verify the vgxness MCP server is visible.',
+    ];
+    return okText(`${lines.join('\n')}\n`);
+}
+export function runSetupLifecycleCommand(parsed, environment) {
+    const [area, command] = parsed.positionals;
+    if (area === 'setup' && command === 'plan')
+        return runSetupPlanCommand(parsed, environment);
+    if (area === 'setup' && command === 'apply')
+        return usageFailure('setup apply is available through the async CLI entrypoint; run vgxness setup apply --yes from the installed CLI.');
+    if (area === 'setup' && command === 'reinstall')
+        return runSetupReinstallCommand(parsed, environment);
+    if (area === 'setup' && command === 'backup')
+        return runSetupBackupCommand(parsed, environment);
+    if (area === 'setup' && command === 'rollback')
+        return runSetupRollbackCommand(parsed, environment);
+    if (area === 'setup' && command !== 'status')
+        return usageFailure(command === undefined ? 'Missing command for setup' : `Unknown setup command: ${command}`);
+    const scope = scopeFlag(parsed.flags, 'scope', 'project');
+    if (!scope.ok)
+        return resultFailure(scope);
+    const project = optionalStringFlag(parsed.flags, 'project') ?? 'vgxness';
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return resultFailure(selectedDatabasePath);
+    const databasePath = selectedDatabasePath.value;
+    const opened = openCliDatabase(databasePath);
+    const service = createSetupLifecycleService({ opened, databasePath, environment });
+    try {
+        const status = service.getStatus({ project, projectRoot: environment.cwd, scope: scope.value, env: environment.env });
+        if (!status.ok || parsed.flags.json === true)
+            return jsonResult(status);
+        return okText(`${renderSetupStatus(status.value)}\n`);
+    }
+    finally {
+        if (opened.ok)
+            opened.value.close();
+    }
+}
+export function runSetupPlanCommand(parsed, environment) {
+    const input = setupPlanInputFromFlags(parsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const plan = createSetupPlan(input.value);
+    if (!plan.ok || parsed.flags.json === true)
+        return jsonResult(plan);
+    return okText(`${renderSetupPlan(plan.value)}\n`);
+}
+export function runSetupReinstallCommand(parsed, environment) {
+    const reinstallParsed = withReinstallFlags(parsed);
+    const input = setupPlanInputFromFlags(reinstallParsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const plan = createSetupPlan(input.value);
+    if (!plan.ok || parsed.flags.json === true)
+        return jsonResult(plan);
+    return okText(`${renderSetupReinstallPreview(plan.value)}\n`);
+}
+export function runSetupRollbackCommand(parsed, environment) {
+    const backupPath = optionalStringFlag(parsed.flags, 'backup');
+    if (backupPath === undefined)
+        return usageFailure('setup rollback requires --backup <path>');
+    const resolvedBackupPath = resolve(environment.cwd, backupPath);
+    if (parsed.flags.yes === true)
+        return renderSetupRollbackApply(applyRollbackConfigBackup({ backupPath: resolvedBackupPath, confirmed: true }), parsed);
+    const result = previewRollbackConfigBackup({ backupPath: resolvedBackupPath });
+    if (parsed.flags.json === true)
+        return jsonResult(result);
+    if (!result.ok)
+        return resultFailure(result);
+    const lines = [
+        result.value.restorable ? 'Rollback preview is restorable; no files were changed.' : 'Rollback preview is blocked; no files were changed.',
+        ...(result.value.targetPath === undefined ? [] : [`Target: ${result.value.targetPath}`]),
+        `Backup: ${result.value.backupPath}`,
+        ...result.value.blockers.map((blocker) => `Blocker: ${blocker}`),
+        ...result.value.warnings.map((warning) => `Warning: ${warning}`),
+        ...(result.value.restorable ? [`Apply with: vgxness setup rollback --backup ${result.value.backupPath} --yes`] : []),
+    ];
+    return okText(`${lines.join('\n')}\n`);
+}
+export function runSetupBackupCommand(parsed, environment) {
+    const subcommand = parsed.positionals[2];
+    if (subcommand !== 'list')
+        return usageFailure('setup backup requires list');
+    const provider = optionalStringFlag(parsed.flags, 'provider') ?? 'opencode';
+    if (provider !== 'opencode')
+        return usageFailure('setup backup list supports --provider opencode');
+    const scope = optionalStringFlag(parsed.flags, 'scope');
+    if (scope !== undefined && scope !== 'project' && scope !== 'user' && scope !== 'global')
+        return usageFailure('setup backup list --scope must be project, user, or global');
+    const target = optionalStringFlag(parsed.flags, 'target');
+    const result = listProviderConfigBackups({
+        searchRoot: environment.cwd,
+        provider: 'opencode',
+        ...(scope === undefined ? {} : { scope: scope }),
+        ...(target === undefined ? {} : { targetPath: resolve(target) }),
+    });
+    if (parsed.flags.json === true)
+        return jsonResult(result);
+    if (!result.ok)
+        return resultFailure(result);
+    if (result.value.backups.length === 0)
+        return okText('No OpenCode config backups found.\n');
+    return okText(`${result.value.backups.map((backup) => `${backup.kind} ${backup.backupPath}${backup.targetPath === undefined ? '' : ` -> ${backup.targetPath}`}`).join('\n')}\n`);
+}
+export async function runSetupApplyCommand(parsed, environment) {
+    if (parsed.flags.yes !== true)
+        return usageFailure('setup apply writes provider config and requires explicit confirmation with --yes. No provider config was written.');
+    const input = setupPlanInputFromFlags(parsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const applied = await applySetupPlanInput(input.value, environment);
+    return applied.ok ? jsonResult({ ok: true, value: applied.value }) : resultFailure(applied);
+}
+export async function runSetupReinstallApplyCommand(parsed, environment) {
+    if (parsed.flags.yes !== true)
+        return usageFailure('setup reinstall rewrites VGXNESS-managed provider entries and requires explicit confirmation with --yes. Unrelated OpenCode config is preserved. No provider config was written.');
+    const input = setupPlanInputFromFlags(withReinstallFlags(parsed), environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const applied = await applySetupPlanInput(input.value, environment);
+    return applied.ok ? jsonResult({ ok: true, value: applied.value }) : resultFailure(applied);
+}
+export async function applySetupPlanInput(input, environment) {
+    const plan = createSetupPlan(input);
+    if (!plan.ok)
+        return plan;
+    if (plan.value.status !== 'ready')
+        return validationFailure(`Setup plan is ${plan.value.status}; resolve conflicts before applying.`);
+    if (input.provider === 'none')
+        return { ok: true, value: { status: 'manual-required', message: 'Provider is none; there is no config to apply.', plan: plan.value } };
+    if (input.provider === 'claude')
+        return {
+            ok: true,
+            value: {
+                status: 'manual-required',
+                message: `Claude setup apply is intentionally non-mutating here; use vgxness mcp install claude --yes --run-id <id> for guarded user-global Claude writes. ${providerUserGlobalOnlyMigrationMessage}`,
+                plan: plan.value,
+            },
+        };
+    const opened = openCliDatabase(plan.value.db.path);
+    if (!opened.ok)
+        return opened;
+    let result;
+    try {
+        const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value, input.project);
+        result = await installOpenCodeMcpClient({
+            cwd: environment.cwd,
+            databasePath: plan.value.db.path,
+            databasePathSource: plan.value.db.source === 'global-default' || plan.value.db.source === 'environment' ? plan.value.db.source : 'flag',
+            scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
+            env: environment.env,
+            confirmed: true,
+            mcpOnly: input.installMode === 'mcp-only',
+            ...(input.overwriteVgxness === undefined ? {} : { overwriteVgxness: input.overwriteVgxness }),
+            ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+        });
+    }
+    finally {
+        opened.value.close();
+    }
+    return result.status === 'installed'
+        ? {
+            ok: true,
+            value: {
+                kind: 'setup-apply-result',
+                version: 1,
+                status: 'installed',
+                plan: plan.value,
+                opencode: result,
+                nextCommands: ['vgxness doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
+            },
+        }
+        : validationFailure(`${result.reason}: ${result.message}`);
+}
+export function setupPlanInputFromFlags(parsed, environment) {
+    const project = optionalStringFlag(parsed.flags, 'project');
+    const database = setupDatabaseFlags(parsed.flags);
+    if (!database.ok)
+        return database;
+    const provider = setupProviderFlag(parsed.flags);
+    if (!provider.ok)
+        return provider;
+    const scope = opencodeInstallScopeFlag(parsed.flags, 'scope');
+    if (!scope.ok)
+        return scope;
+    const installMode = setupInstallModeFlag(parsed.flags);
+    if (!installMode.ok)
+        return installMode;
+    const overwriteVgxness = parsed.flags['overwrite-vgxness'] === true || parsed.flags.reinstall === true;
+    return {
+        ok: true,
+        value: {
+            ...(project === undefined ? {} : { project }),
+            workspaceRoot: environment.cwd,
+            env: environment.env,
+            databaseMode: database.value.mode,
+            ...(database.value.path === undefined ? {} : { databasePath: database.value.path }),
+            provider: provider.value,
+            scope: scope.value,
+            installMode: installMode.value,
+            overwriteVgxness,
+        },
+    };
+}
+function withReinstallFlags(parsed) {
+    return { ...parsed, flags: { ...parsed.flags, 'overwrite-vgxness': true, reinstall: true } };
+}
+function renderSetupReinstallPreview(plan) {
+    return [
+        'VGXNESS Setup Reinstall Preview',
+        '',
+        'Warning: reinstall replaces only VGXNESS-managed OpenCode entries: mcp.vgxness and known VGXNESS agents/instructions.',
+        'Unrelated OpenCode config is preserved. This is not a full opencode.json reset.',
+        'A managed backup is planned before existing user-global OpenCode config is changed.',
+        '',
+        renderSetupPlan(plan).trimEnd(),
+        '',
+        'Apply after review: vgxness setup reinstall --yes',
+    ].join('\n');
+}
+function defaultWizardInput(environment) {
+    return {
+        project: environment.cwd
+            .replace(/[\\/]+$/, '')
+            .split(/[\\/]/)
+            .pop() || 'vgxness',
+        databaseMode: vgxnessSetupDefaults.defaultDatabaseMode,
+        provider: vgxnessSetupDefaults.defaultProvider,
+        scope: vgxnessSetupDefaults.defaultOpenCodeScope,
+        installMode: vgxnessSetupDefaults.defaultInstallMode,
+        overwriteVgxness: false,
+    };
+}
+function defaulted(value, fallback) {
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? fallback : trimmed;
+}
+const promptBuffers = new WeakMap();
+function promptLine(environment, prompt) {
+    environment.stdout?.write(prompt);
+    const stdin = environment.stdin;
+    if (stdin === undefined)
+        return Promise.resolve('');
+    const buffered = promptBuffers.get(stdin) ?? '';
+    const immediateNewline = buffered.search(/\r?\n/);
+    if (immediateNewline >= 0) {
+        const line = buffered.slice(0, immediateNewline);
+        promptBuffers.set(stdin, buffered.slice(immediateNewline + (buffered[immediateNewline] === '\r' && buffered[immediateNewline + 1] === '\n' ? 2 : 1)));
+        return Promise.resolve(line);
+    }
+    return new Promise((resolveLine) => {
+        const listener = (chunk) => {
+            const nextBuffered = (promptBuffers.get(stdin) ?? '') + chunk.toString();
+            const newline = nextBuffered.search(/\r?\n/);
+            if (newline >= 0) {
+                cleanup();
+                const line = nextBuffered.slice(0, newline);
+                promptBuffers.set(stdin, nextBuffered.slice(newline + (nextBuffered[newline] === '\r' && nextBuffered[newline + 1] === '\n' ? 2 : 1)));
+                resolveLine(line);
+            }
+            else {
+                promptBuffers.set(stdin, nextBuffered);
+            }
+        };
+        const cleanup = () => {
+            if (stdin.off !== undefined)
+                stdin.off('data', listener);
+            else
+                stdin.removeListener?.('data', listener);
+        };
+        stdin.on('data', listener);
+        stdin.resume?.();
+    });
+}
+function renderSetupPlanForHumans(plan) {
+    const actions = plan.actions.map((action) => `- ${action.description}${action.targetPath === undefined ? '' : ` (${action.targetPath})`}`).join('\n') ||
+        '- No provider config writes planned.';
+    const backups = plan.backupsPlanned.map((backup) => `- ${backup.targetPath}: ${backup.reason}`).join('\n') || '- None.';
+    return `\nSetup plan\nProject: ${plan.project}\nDatabase: ${plan.db.mode} (${plan.db.path})\nProvider: ${plan.provider}\nStatus: ${plan.status}\nActions:\n${actions}\nBackups:\n${backups}\n\n`;
+}
+export function promptSetupWizard(environment, defaults) {
+    return (async () => {
+        const project = defaulted(await promptLine(environment, `Project name [${defaults.project}]: `), defaults.project);
+        const db = defaulted(await promptLine(environment, 'DB location: global default, project-local, custom path [global]: '), defaults.databaseMode);
+        const databaseMode = db === 'global default' || db === 'global'
+            ? 'global'
+            : db === 'project-local'
+                ? 'project-local'
+                : db === 'custom path' || db === 'custom'
+                    ? 'custom'
+                    : undefined;
+        if (databaseMode === undefined)
+            return validationFailure('DB location must be global, project-local, or custom path.');
+        const databasePath = databaseMode === 'custom' ? defaulted(await promptLine(environment, 'Custom DB path: '), '') : undefined;
+        if (databaseMode === 'custom' && (databasePath ?? '').length === 0)
+            return validationFailure('Custom DB path is required.');
+        const providerText = defaulted(await promptLine(environment, 'Provider: OpenCode, none/manual [OpenCode]: '), defaults.provider);
+        const provider = providerText.toLowerCase() === 'opencode'
+            ? 'opencode'
+            : providerText.toLowerCase() === 'none/manual' || providerText.toLowerCase() === 'none' || providerText.toLowerCase() === 'manual'
+                ? 'none'
+                : undefined;
+        if (provider === undefined)
+            return validationFailure('Provider must be OpenCode or none/manual.');
+        const scopeText = defaulted(await promptLine(environment, 'OpenCode scope: project, user [project]: '), defaults.scope);
+        const scope = scopeText === 'project' || scopeText === 'user' ? scopeText : undefined;
+        if (scope === undefined)
+            return validationFailure('OpenCode scope must be project or user.');
+        const modeText = defaulted(await promptLine(environment, 'Install mode: MCP + manager/SDD agents, MCP only [MCP + manager/SDD agents]: '), defaults.installMode);
+        const installMode = modeText === 'mcp-plus-agents' || modeText.toLowerCase() === 'mcp + manager/sdd agents'
+            ? 'mcp-plus-agents'
+            : modeText === 'mcp-only' || modeText.toLowerCase() === 'mcp only'
+                ? 'mcp-only'
+                : undefined;
+        if (installMode === undefined)
+            return validationFailure('Install mode must be MCP + manager/SDD agents or MCP only.');
+        const overwriteText = defaulted(await promptLine(environment, 'Reinstall VGXNESS entries: overwrite existing mcp.vgxness and VGXNESS agents after final confirmation; preserve unrelated OpenCode config [no]: '), 'no');
+        const overwriteVgxness = overwriteText.toLowerCase() === 'yes' || overwriteText.toLowerCase() === 'y' || overwriteText.toLowerCase() === 'true';
+        const input = {
+            project,
+            workspaceRoot: environment.cwd,
+            env: environment.env,
+            databaseMode,
+            ...(databasePath === undefined ? {} : { databasePath }),
+            provider,
+            scope,
+            installMode,
+            overwriteVgxness,
+        };
+        const flags = {
+            project,
+            db: databaseMode,
+            provider,
+            scope,
+            mode: installMode,
+            yes: true,
+            ...(overwriteVgxness ? { 'overwrite-vgxness': true } : {}),
+            ...(databasePath === undefined ? {} : { 'db-path': databasePath }),
+        };
+        return { ok: true, value: { input, flags } };
+    })();
+}
+export function defaultWizardInputExport(environment) {
+    return defaultWizardInput(environment);
+}
+export function defaultedExport(value, fallback) {
+    return defaulted(value, fallback);
+}
+export function promptLineExport(environment, prompt) {
+    return promptLine(environment, prompt);
+}
+export function renderSetupPlanForHumansExport(plan) {
+    return renderSetupPlanForHumans(plan);
+}
+export function resolveInitDispatchMode(parsed, _environment) {
+    if (parsed.flags.plan === true || parsed.flags.json === true)
+        return 'setup-plan';
+    if (parsed.flags.yes === true)
+        return 'setup-apply';
+    return 'setup-plan';
+}
+export async function runInitCommand(parsed, environment) {
+    if (shouldRunSetupTui(parsed, environment)) {
+        const input = setupPlanInputFromFlags(parsed, environment);
+        if (!input.ok)
+            return resultFailure(input);
+        const plan = createSetupPlan(input.value);
+        if (!plan.ok)
+            return resultFailure(plan);
+        return runSetupTuiController({ environment, plan: plan.value });
+    }
+    return runInitCommandWithoutSetupTui(parsed, environment);
+}
+export async function runHomeTuiCommand(parsed, environment) {
+    const input = setupPlanInputFromFlags(parsed, environment);
+    if (!input.ok)
+        return resultFailure(input);
+    const plan = createSetupPlan(input.value);
+    if (!plan.ok)
+        return resultFailure(plan);
+    return runHomeTuiController({ environment, plan: plan.value });
+}
+export async function runInitCommandWithoutSetupTui(parsed, environment) {
+    const mode = resolveInitDispatchMode(parsed, environment);
+    if (mode === 'setup-plan')
+        return runSetupPlanCommand(parsed, environment);
+    return runSetupApplyCommand({ ...parsed, flags: { ...parsed.flags, yes: true } }, environment);
+}
+function shouldRunSetupTui(parsed, environment) {
+    if (parsed.flags.plan === true || parsed.flags.json === true || parsed.flags.yes === true)
+        return false;
+    return canRunInteractiveTui(environment.stdin, environment.stdout);
+}
+export function createSetupLifecycleService(input) {
+    return new SetupLifecycleService({
+        store: () => (input.opened.ok ? { ok: true, value: { path: input.databasePath } } : input.opened),
+        mcp: (setupInput) => {
+            const visibility = createOpenCodeMcpVisibilityReport({ cwd: input.environment.cwd, projectRoot: setupInput.projectRoot, env: input.environment.env });
+            const preview = createMcpClientSetupPreview({ provider: 'opencode', databasePath: setupInput.databasePath ?? input.databasePath });
+            return {
+                ok: true,
+                value: {
+                    ready: visibility.ready,
+                    evidence: setupMcpEvidence(visibility, preview),
+                    nextAction: visibility.ready
+                        ? 'Run `opencode mcp list` from inside the project to verify visibility.'
+                        : 'Preview OpenCode MCP setup, inspect `mcp install opencode --plan`, then apply with `--yes` only after review.',
+                },
+            };
+        },
+        defaultContext: (setupInput) => {
+            if (!input.opened.ok)
+                return validationFailure('Default context cannot be read until the local store is available.');
+            if (setupInput.project === undefined)
+                return validationFailure('Default context cannot be read until a project is selected.');
+            const registry = new AgentRegistryService(input.opened.value);
+            const agent = registry.getAgentByName(setupInput.project, setupInput.scope ?? 'project', setupInput.agentName);
+            if (!agent.ok)
+                return agent;
+            const selection = resolveAgentProfileModel({ agent: agent.value, providerAdapter: 'opencode' });
+            if (!selection.ok)
+                return selection;
+            return {
+                ok: true,
+                value: {
+                    agentId: agent.value.id,
+                    providerAdapter: selection.value.providerAdapter,
+                    model: selection.value.model,
+                    ...(selection.value.profile === undefined ? {} : { profile: selection.value.profile }),
+                },
+            };
+        },
+    });
+}
+export function readSetupStatus(service, input) {
+    return service.getStatus(input);
+}
+export function collectRunInsights(service, runs) {
+    const insightsByRunId = {};
+    for (const run of runs) {
+        const insights = service.getRunInsights(run.id);
+        if (!insights.ok)
+            return insights;
+        insightsByRunId[run.id] = insights.value;
+    }
+    return { ok: true, value: insightsByRunId };
+}
+export function collectRunDetails(service, runs) {
+    const detailsByRunId = {};
+    for (const run of runs) {
+        const details = service.getRun(run.id);
+        if (!details.ok)
+            return details;
+        detailsByRunId[run.id] = details.value;
+    }
+    return { ok: true, value: detailsByRunId };
+}
+export function setupMcpEvidence(visibility, preview) {
+    return [
+        visibility.ready
+            ? 'OpenCode project config defines mcp.vgxness and is visible from the current working directory.'
+            : `OpenCode MCP visibility is not ready at ${visibility.targetPath}.`,
+        `Preview command targets ${preview.server.args.join(' ')}.`,
+        ...visibility.guidance,
+    ];
+}

package/dist/interfaces/cli/commands/status-dispatcher.js

@@ -0,0 +1,130 @@
+import { MemoryService } from '../../../memory/memory-service.js';
+import { openMemoryDatabase } from '../../../memory/sqlite/database.js';
+import { buildProductResume } from '../../../resume/product-resume.js';
+import { RunService } from '../../../runs/run-service.js';
+import { SddWorkflowService } from '../../../sdd/sdd-workflow-service.js';
+import { buildProductStatus } from '../../../status/product-status.js';
+import { databasePathFor, optionalStringFlag, requiredFlag } from '../cli-flags.js';
+import { okText, usageFailure } from '../cli-help.js';
+import { jsonResult, resultFailure } from '../cli-helpers.js';
+import { renderProductResume } from '../product-resume-renderer.js';
+import { buildProductNext, renderProductNext, renderProductStatus } from '../product-status-renderer.js';
+export function runProductStatusCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'status');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const status = buildProductStatusForCli(parsed, environment);
+    if (!status.ok)
+        return status.value;
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: status.value }) : okText(renderProductStatus(status.value));
+}
+export function runProductNextCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'next');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const status = buildProductStatusForCli(parsed, environment);
+    if (!status.ok)
+        return status.value;
+    const next = buildProductNext(status.value);
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: next }) : okText(renderProductNext(next));
+}
+export function runProductResumeCommand(parsed, environment) {
+    const extraPositionals = rejectExtraPositionals(parsed, 'resume');
+    if (extraPositionals !== undefined)
+        return extraPositionals;
+    const resume = buildProductResumeForCli(parsed, environment);
+    if (!resume.ok)
+        return resume.value;
+    return parsed.flags.json === true ? jsonResult({ ok: true, value: resume.value }) : okText(renderProductResume(resume.value));
+}
+function rejectExtraPositionals(parsed, command) {
+    const extra = parsed.positionals.slice(1);
+    return extra.length === 0 ? undefined : usageFailure(`${command} does not accept positional arguments: ${extra.join(' ')}`);
+}
+function buildProductStatusForCli(parsed, environment) {
+    const projectFlag = parsed.flags.project === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'project');
+    if (!projectFlag.ok)
+        return { ok: false, value: resultFailure(projectFlag) };
+    const changeFlag = parsed.flags.change === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'change');
+    if (!changeFlag.ok)
+        return { ok: false, value: resultFailure(changeFlag) };
+    const project = projectFlag.value;
+    const change = changeFlag.value;
+    if (change === undefined) {
+        const status = buildProductStatus({ cwd: environment.cwd, ...(project === undefined ? {} : { project }) });
+        return { ok: true, value: status };
+    }
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return { ok: false, value: resultFailure(selectedDatabasePath) };
+    const explicitDatabasePath = optionalStringFlag(parsed.flags, 'db');
+    const opened = openMemoryDatabase({ path: selectedDatabasePath.value, readonly: true });
+    if (!opened.ok) {
+        const status = buildProductStatus({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            change,
+            databasePath: selectedDatabasePath.value,
+            databaseError: opened.error.message,
+        });
+        return { ok: true, value: status };
+    }
+    try {
+        const status = buildProductStatus({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            change,
+            databasePath: selectedDatabasePath.value,
+            ...(explicitDatabasePath === undefined ? {} : { explicitDatabasePath }),
+            sdd: new SddWorkflowService(new MemoryService(opened.value)),
+            runs: new RunService(opened.value),
+        });
+        return { ok: true, value: status };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function buildProductResumeForCli(parsed, environment) {
+    const projectFlag = parsed.flags.project === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'project');
+    if (!projectFlag.ok)
+        return { ok: false, value: resultFailure(projectFlag) };
+    const runIdFlag = parsed.flags['run-id'] === undefined ? { ok: true, value: undefined } : requiredFlag(parsed.flags, 'run-id');
+    if (!runIdFlag.ok)
+        return { ok: false, value: resultFailure(runIdFlag) };
+    const project = projectFlag.value;
+    const runId = runIdFlag.value;
+    if (runId === undefined && project === undefined) {
+        const resume = buildProductResume({ cwd: environment.cwd, ...(project === undefined ? {} : { project }) });
+        return { ok: true, value: resume };
+    }
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return { ok: false, value: resultFailure(selectedDatabasePath) };
+    const opened = openMemoryDatabase({ path: selectedDatabasePath.value, readonly: true });
+    if (!opened.ok) {
+        const visibleDatabasePath = runId === undefined && parsed.flags.db === undefined ? undefined : selectedDatabasePath.value;
+        const resume = buildProductResume({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            ...(runId === undefined ? {} : { runId }),
+            ...(visibleDatabasePath === undefined ? {} : { databasePath: visibleDatabasePath }),
+            databaseError: opened.error.message,
+        });
+        return { ok: true, value: resume };
+    }
+    try {
+        const flaggedDatabasePath = parsed.flags.db === undefined ? undefined : selectedDatabasePath.value;
+        const resume = buildProductResume({
+            cwd: environment.cwd,
+            ...(project === undefined ? {} : { project }),
+            ...(runId === undefined ? {} : { runId }),
+            ...(flaggedDatabasePath === undefined ? {} : { databasePath: flaggedDatabasePath }),
+            runs: new RunService(opened.value),
+        });
+        return { ok: true, value: resume };
+    }
+    finally {
+        opened.value.close();
+    }
+}

package/dist/interfaces/cli/commands/verification-dispatcher.js

@@ -0,0 +1,47 @@
+import { MemoryService } from '../../../memory/memory-service.js';
+import { SddWorkflowService } from '../../../sdd/sdd-workflow-service.js';
+import { VerificationPlanService, VerificationReportService } from '../../../verification/index.js';
+import { requiredFlag } from '../cli-flags.js';
+import { usageFailure } from '../cli-help.js';
+import { jsonResult, readJsonFile, resultFailure } from '../cli-helpers.js';
+import { renderVerificationPlan } from '../verification-plan-renderer.js';
+import { renderVerificationReportArtifact } from '../verification-report-renderer.js';
+export function runVerificationPlanCommand(command, parsed) {
+    if (command !== 'plan')
+        return usageFailure(`Unknown verification command: ${command}`);
+    const plan = new VerificationPlanService().getPlan(parsed.flags.type);
+    if (!plan.ok || parsed.flags.json === true)
+        return jsonResult(plan);
+    return { exitCode: 0, stdout: renderVerificationPlan(plan.value), stderr: '' };
+}
+export function runVerificationReportCommand(command, parsed, database, environment) {
+    if (command !== 'report')
+        return usageFailure(`Unknown verification command: ${command}`);
+    const subcommand = parsed.positionals[2];
+    const project = requiredFlag(parsed.flags, 'project');
+    const change = requiredFlag(parsed.flags, 'change');
+    if (!project.ok)
+        return resultFailure(project);
+    if (!change.ok)
+        return resultFailure(change);
+    const service = new VerificationReportService(new SddWorkflowService(new MemoryService(database)));
+    if (subcommand === 'save') {
+        const file = requiredFlag(parsed.flags, 'file');
+        if (!file.ok)
+            return resultFailure(file);
+        const report = readJsonFile(file.value, environment);
+        if (!report.ok)
+            return resultFailure(report);
+        const saved = service.saveManualReport({ project: project.value, change: change.value, report: report.value });
+        if (!saved.ok || parsed.flags.json === true)
+            return jsonResult(saved);
+        return { exitCode: 0, stdout: renderVerificationReportArtifact({ project: project.value, change: change.value, artifact: saved.value }), stderr: '' };
+    }
+    if (subcommand === 'get') {
+        const artifact = service.getReportArtifact({ project: project.value, change: change.value });
+        if (!artifact.ok || parsed.flags.json === true)
+            return jsonResult(artifact);
+        return { exitCode: 0, stdout: renderVerificationReportArtifact({ project: project.value, change: change.value, artifact: artifact.value }), stderr: '' };
+    }
+    return usageFailure(`Unknown verification report command: ${subcommand ?? 'missing'}`);
+}