vgxness 0.1.0 → 0.1.1-alpha.1

package/dist/cli/dispatcher.js

@@ -6,9 +6,14 @@ import { ManagerProfileOverlayService } from '../agents/manager-profile-overlay-
 import { resolveAgentProfileModel } from '../agents/profile-model-routing.js';
 import { ManagerProfileOverlayRepository } from '../agents/repositories/manager-profile-overlays.js';
 import { getProviderRenderer } from '../agents/renderers/index.js';
+import { runCodeCommand } from '../code/cli/code-command.js';
+import { MemoryServiceCodeGateway } from '../code/runtime/memory-service-gateway.js';
+import { RunsCodeRunGateway } from '../code/runtime/runs-code-run-gateway.js';
+import { SddWorkflowGateway } from '../code/runtime/sdd-workflow-gateway.js';
 import { renderDashboard as renderStatusDashboard } from './dashboard-renderer.js';
 import { buildDashboardApprovalsReadModel, buildDashboardRunsReadModel, buildDashboardWorkflowsReadModel } from './dashboard-operational-read-models.js';
 import { dashboardKeyFromInput, loadInitialDashboardState, reduceDashboardKey, refreshDashboard, renderDashboard as renderInteractiveDashboard, resolveDashboardRenderStyle } from './interactive-dashboard.js';
+import { createGuidedSetupPreview, noTtyGuidedMenuGuidance, runGuidedMainMenuLoop } from './guided-main-menu.js';
 import { sanitizeDashboardError } from './dashboard-tui-read-model.js';
 import { createAgentRegistryToolHandlers } from '../harness/tools/agents.js';
 import { createMemoryToolHandlers } from '../harness/tools/memory.js';
@@ -677,25 +682,29 @@ async function runSetupApplyCommand(parsed, environment) {
     const input = setupPlanInputFromFlags(parsed, environment);
     if (!input.ok)
         return resultFailure(input);
-    const plan = createSetupPlan(input.value);
+    const applied = await applySetupPlanInput(input.value, environment);
+    return applied.ok ? jsonResult({ ok: true, value: applied.value }) : resultFailure(applied);
+}
+async function applySetupPlanInput(input, environment) {
+    const plan = createSetupPlan(input);
     if (!plan.ok)
-        return resultFailure(plan);
+        return plan;
     if (plan.value.status !== 'ready')
-        return resultFailure(validationFailure(`Setup plan is ${plan.value.status}; resolve conflicts before applying.`));
-    if (input.value.provider === 'none')
-        return jsonResult({ ok: true, value: { status: 'manual-required', message: 'Provider is none; there is no config to apply.', plan: plan.value } });
+        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 } };
     const 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.value.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
+        scope: input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope,
         env: environment.env,
         confirmed: true,
-        mcpOnly: input.value.installMode === 'mcp-only',
+        mcpOnly: input.installMode === 'mcp-only',
     });
     return result.status === 'installed'
-        ? jsonResult({ ok: true, value: { kind: 'setup-apply-result', version: 1, status: 'installed', plan: plan.value, opencode: result, nextCommands: ['vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'] } })
-        : resultFailure(validationFailure(`${result.reason}: ${result.message}`));
+        ? { ok: true, value: { kind: 'setup-apply-result', version: 1, status: 'installed', plan: plan.value, opencode: result, nextCommands: ['vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'] } }
+        : validationFailure(`${result.reason}: ${result.message}`);
 }
 function setupPlanInputFromFlags(parsed, environment) {
     const project = optionalStringFlag(parsed.flags, 'project');
@@ -824,7 +833,7 @@ export async function dispatchCliAsync(argv, environment) {
     const parsed = parseArgs(argv);
     const [area, command] = parsed.positionals;
     if (argv.length === 0)
-        return runDashboardInteractiveCommand({ positionals: ['dashboard', 'interactive'], flags: parsed.flags }, environment);
+        return runGuidedMainMenuCommand(environment);
     if (area === 'dashboard' && command === 'interactive')
         return runDashboardInteractiveCommand(parsed, environment);
     if (area === 'mcp') {
@@ -840,6 +849,8 @@ export async function dispatchCliAsync(argv, environment) {
     }
     if (area === 'doctor')
         return runDoctorAliasCommand(parsed, environment);
+    if (area === 'code')
+        return runCodeCliCommand(parsed, environment);
     if (area === 'init')
         return runInitCommand(parsed, environment);
     if (area === 'setup' && command === 'apply')
@@ -848,6 +859,115 @@ export async function dispatchCliAsync(argv, environment) {
         return runSetupRollbackCommand(parsed);
     return dispatchCli(argv, environment);
 }
+async function runGuidedMainMenuCommand(environment) {
+    const terminal = resolveGuidedMainMenuTerminal(environment);
+    if (!terminal.ok)
+        return okText(noTtyGuidedMenuGuidance());
+    const setupPreview = createDefaultGuidedSetupPreview(environment);
+    await runGuidedMainMenuLoop({
+        ...terminal.value,
+        ...(setupPreview === undefined ? {} : {
+            context: {
+                setupPreview,
+                ...(setupPreview.provider === 'opencode' ? { onApplyConfirmed: () => applyDefaultGuidedOpenCodeSetup(environment) } : {}),
+            },
+        }),
+    });
+    return { exitCode: 0, stdout: '', stderr: '' };
+}
+async function applyDefaultGuidedOpenCodeSetup(environment) {
+    const applied = await applySetupPlanInput({ workspaceRoot: environment.cwd, env: environment.env, provider: 'opencode' }, environment);
+    return mapSetupApplyResultToGuidedApplyResult(applied);
+}
+function mapSetupApplyResultToGuidedApplyResult(result) {
+    if (!result.ok) {
+        return {
+            status: 'failure',
+            summary: `OpenCode setup apply failed: ${result.error.message}`,
+            details: [`Error code: ${result.error.code}`],
+            nextSteps: ['Inspect the setup plan with `vgxness setup plan`.', 'Run `vgxness doctor` after resolving the issue.'],
+        };
+    }
+    if (result.value.status === 'manual-required') {
+        return {
+            status: 'partial',
+            summary: result.value.message,
+            details: ['No provider config was written because this setup requires manual action.'],
+            nextSteps: result.value.plan.nextCommands,
+        };
+    }
+    return {
+        status: 'success',
+        summary: `OpenCode setup installed at ${result.value.opencode.targetPath}.`,
+        details: [
+            `Plan status: ${result.value.plan.status}.`,
+            `Installed MCP server command: ${result.value.opencode.server.command.join(' ')}.`,
+            ...(result.value.opencode.backupPath === undefined ? [] : [`Backup created: ${result.value.opencode.backupPath}.`]),
+            ...(result.value.opencode.warnings.length === 0 ? [] : result.value.opencode.warnings),
+        ],
+        nextSteps: result.value.nextCommands,
+    };
+}
+function createDefaultGuidedSetupPreview(environment) {
+    const plan = createSetupPlan({ workspaceRoot: environment.cwd, env: environment.env });
+    if (!plan.ok)
+        return undefined;
+    return createGuidedSetupPreview({
+        status: plan.value.status,
+        project: plan.value.project,
+        database: { mode: plan.value.db.mode, path: plan.value.db.path },
+        provider: plan.value.provider,
+        actions: plan.value.actions,
+        conflicts: plan.value.conflicts,
+        backupsPlanned: plan.value.backupsPlanned,
+        nextCommands: plan.value.nextCommands,
+        safety: plan.value.safety,
+    });
+}
+function resolveGuidedMainMenuTerminal(environment) {
+    const input = environment.stdin;
+    const output = environment.stdout;
+    if (input === undefined || output === undefined || input.isTTY !== true || output.isTTY !== true || input.setRawMode === undefined)
+        return validationFailure('Guided main menu requires an interactive terminal');
+    return { ok: true, value: { input, output } };
+}
+async function runCodeCliCommand(parsed, environment) {
+    const [, command] = parsed.positionals;
+    if (command !== 'inspect' && command !== 'plan' && command !== 'craft' && command !== 'sdd')
+        return usageFailure(`Unknown code command: ${command ?? ''}`.trim());
+    const maxSourceBytes = optionalNumberFlag(parsed.flags, 'max-source-bytes');
+    if (!maxSourceBytes.ok)
+        return resultFailure(maxSourceBytes);
+    const output = parsed.flags.json === true || optionalStringFlag(parsed.flags, 'output') === 'json' ? 'json' : 'human';
+    const approvalPolicy = codeApprovalPolicyFlag(parsed.flags);
+    if (!approvalPolicy.ok)
+        return resultFailure(approvalPolicy);
+    const verificationMode = codeVerificationModeFlag(parsed.flags);
+    if (!verificationMode.ok)
+        return resultFailure(verificationMode);
+    const transcriptMode = codeTranscriptModeFlag(parsed.flags);
+    if (!transcriptMode.ok)
+        return resultFailure(transcriptMode);
+    const memoryPolicy = codeMemoryPolicyFlag(parsed.flags);
+    if (!memoryPolicy.ok)
+        return resultFailure(memoryPolicy);
+    const selectedDatabasePath = databasePathFor(parsed.flags, environment);
+    if (!selectedDatabasePath.ok)
+        return resultFailure(selectedDatabasePath);
+    const opened = openCliDatabase(selectedDatabasePath.value);
+    if (!opened.ok)
+        return resultFailure(opened);
+    try {
+        const runs = new RunService(opened.value);
+        const memory = new MemoryService(opened.value);
+        const provider = optionalStringFlag(parsed.flags, 'provider');
+        const model = optionalStringFlag(parsed.flags, 'model');
+        return await runCodeCommand({ command, args: parsed.positionals.slice(2), cwd: environment.cwd, output, runGateway: new RunsCodeRunGateway(runs), sddGateway: new SddWorkflowGateway(new SddWorkflowService(memory)), memoryGateway: new MemoryServiceCodeGateway(memory), project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness', ...(provider === undefined ? {} : { provider }), ...(model === undefined ? {} : { model }), stream: parsed.flags.stream === true, env: environment.env, persistArtifact: parsed.flags['save-artifact'] === true || parsed.flags.persist === true, ...(maxSourceBytes.value !== undefined ? { maxSourceBytes: maxSourceBytes.value } : {}), ...(approvalPolicy.value === undefined ? {} : { approvalPolicy: approvalPolicy.value }), ...(verificationMode.value === undefined ? {} : { verificationMode: verificationMode.value }), ...(transcriptMode.value === undefined ? {} : { transcriptMode: transcriptMode.value }), ...(memoryPolicy.value === undefined ? {} : { memoryPolicy: memoryPolicy.value }) });
+    }
+    finally {
+        opened.value.close();
+    }
+}
 async function runInitCommand(parsed, environment) {
     if (parsed.flags.plan === true || parsed.flags.json === true)
         return runSetupPlanCommand(parsed, environment);
@@ -2501,6 +2621,11 @@ function validateCommand(area, command) {
             ? { ok: true }
             : { ok: false, message: `Unknown dashboard command: ${command}` };
     }
+    if (area === 'code') {
+        return command === 'inspect' || command === 'plan' || command === 'craft' || command === 'sdd'
+            ? { ok: true }
+            : { ok: false, message: `Unknown code command: ${command}` };
+    }
     return { ok: false, message: `Unknown command area: ${area}` };
 }
 function requiredFlag(flags, name) {
@@ -2511,6 +2636,34 @@ function optionalStringFlag(flags, name) {
     const value = flags[name];
     return typeof value === 'string' && value.trim() ? value : undefined;
 }
+function codeApprovalPolicyFlag(flags) {
+    const value = optionalStringFlag(flags, 'approval-policy');
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    return value === 'ask' || value === 'allow' || value === 'deny' ? { ok: true, value } : validationFailure('--approval-policy must be ask, allow, or deny');
+}
+function codeVerificationModeFlag(flags) {
+    const value = optionalStringFlag(flags, 'verification');
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    return value === 'none' || value === 'suggest' || value === 'run' || value === 'repair' ? { ok: true, value } : validationFailure('--verification must be none, suggest, run, or repair');
+}
+function codeTranscriptModeFlag(flags) {
+    const value = optionalStringFlag(flags, 'transcript');
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    return value === 'off' || value === 'summary' || value === 'full'
+        ? { ok: true, value }
+        : validationFailure('--transcript must be off, summary, or full');
+}
+function codeMemoryPolicyFlag(flags) {
+    const value = optionalStringFlag(flags, 'memory');
+    if (value === undefined)
+        return { ok: true, value: undefined };
+    return value === 'off' || value === 'ask' || value === 'auto'
+        ? { ok: true, value }
+        : validationFailure('--memory must be off, ask, or auto');
+}
 function scopeFlag(flags, name, fallback) {
     const value = optionalStringFlag(flags, name) ?? fallback;
     return value === 'project' || value === 'personal' ? { ok: true, value } : validationFailure(`--${name} must be project or personal`);
@@ -2780,6 +2933,12 @@ Areas:
 
   opencode preview --provider opencode (--agent <name> | --agent-id <id>) --project <name> --change <id> --phase <phase> [--scope project|personal]
 
+  code inspect "<question>" [--json] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--transcript off|summary|full] [--memory off|ask|auto]
+  code plan "<task>" [--json] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--transcript off|summary|full] [--memory off|ask|auto]
+  code craft "<task>" [--json] [--max-source-bytes <n>] [--provider fake|openai-compatible] [--model <id>] [--stream] [--approval-policy ask|allow|deny] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
+  code sdd <change> <phase> [--json] [--save-artifact] [--provider fake|openai-compatible] [--model <id>] [--stream] [--verification none|suggest|run|repair] [--transcript off|summary|full] [--memory off|ask|auto]
+  VGXNESS Code inspect and plan are native read-only repository flows. Craft is bounded edit-capable work with approval-gated edits and shell verification; SDD mode follows phase-specific artifact boundaries and saves only with --save-artifact.
+
   orchestrator preview --project <name> --intent <text> [--change <id>] [--db <path>]
   Orchestrator preview classifies natural-language requests only; it never executes providers, edits files, records runs, or writes provider config.