vgxness 1.20.5 → 1.20.7

package/dist/interfaces/cli/home-tui-controller.js

@@ -0,0 +1,341 @@
+import { render as renderInk } from 'ink';
+import React from 'react';
+import { HomeTuiApp, homeTuiTabs, } from '../../cli/home-tui-app.js';
+import { MemoryService } from '../../memory/memory-service.js';
+import { openMemoryDatabase } from '../../memory/sqlite/database.js';
+import { RunService } from '../../runs/run-service.js';
+import { sddContinuationPlanFrom } from '../../sdd/sdd-continuation-plan.js';
+import { SddWorkflowService } from '../../sdd/sdd-workflow-service.js';
+import { SkillIndexService } from '../../skills/skill-index-service.js';
+import { SkillRegistryService } from '../../skills/skill-registry-service.js';
+import { okText } from './cli-help.js';
+import { renderSetupPlan } from './setup-plan-renderer.js';
+import { runSetupTuiController } from './setup-tui-controller.js';
+import { keyIntentFromInput } from './tui/key-intents.js';
+import { navigationIntentFromInput } from './tui/keymap.js';
+import { nextItem } from './tui/navigation.js';
+const enter = '\r';
+const escapeKey = '\u001B';
+const ctrlC = '\u0003';
+const backspace = '\u007F';
+const ctrlH = '\b';
+const clearScreen = '\u001B[2J\u001B[3J\u001B[H';
+export async function runHomeTuiController(input) {
+    const { stdin, stdout } = input.environment;
+    if (stdin === undefined || stdout === undefined)
+        return okText(renderSetupPlan(input.plan));
+    const width = tuiWidth(stdout);
+    let selectedTab = 'setup';
+    let view = 'overview';
+    let runsReadModel = { state: 'not-loaded' };
+    let skillsReadModel = { state: 'not-loaded' };
+    let sddInput = { change: '' };
+    let sddReadModel = { state: 'not-loaded' };
+    let helpOpen = false;
+    const app = renderInk(React.createElement(HomeTuiApp, { plan: input.plan, width, selectedTab, view, runsReadModel, skillsReadModel, sddInput, sddReadModel, helpOpen }), {
+        stdin: stdin,
+        stdout: stdout,
+        interactive: true,
+        patchConsole: false,
+        exitOnCtrlC: false,
+    });
+    const rerender = () => {
+        app.rerender(React.createElement(HomeTuiApp, { plan: input.plan, width, selectedTab, view, runsReadModel, skillsReadModel, sddInput, sddReadModel, helpOpen }));
+    };
+    stdin.setRawMode?.(true);
+    stdin.resume?.();
+    const action = await new Promise((resolve) => {
+        const listener = (chunk) => {
+            const value = chunk.toString();
+            const keyIntent = keyIntentFromInput(value);
+            if (keyIntent === 'toggle-help') {
+                helpOpen = !helpOpen;
+                rerender();
+                return;
+            }
+            if (helpOpen) {
+                if (keyIntent === 'back' || value === escapeKey) {
+                    helpOpen = false;
+                    rerender();
+                    return;
+                }
+                if (keyIntent === 'quit' || value === 'Q' || value === ctrlC) {
+                    cleanup();
+                    resolve('quit');
+                }
+                return;
+            }
+            if (view === 'sdd-focus') {
+                if (value === ctrlC) {
+                    cleanup();
+                    resolve('quit');
+                    return;
+                }
+                if (value === escapeKey) {
+                    view = 'overview';
+                    helpOpen = false;
+                    rerender();
+                    return;
+                }
+                if (value === backspace || value === ctrlH) {
+                    sddInput = { change: sddInput.change.slice(0, -1) };
+                    sddReadModel = readHomeSdd(input.plan, sddInput.change);
+                    rerender();
+                    return;
+                }
+                const nextSddChange = appendSddChangeInput(sddInput.change, value);
+                if (nextSddChange !== sddInput.change) {
+                    sddInput = { change: nextSddChange };
+                    sddReadModel = readHomeSdd(input.plan, nextSddChange);
+                    rerender();
+                    return;
+                }
+                if (value === enter || value === '\n')
+                    return;
+            }
+            const intent = navigationIntentFromInput(value);
+            if (value === 'q' || value === 'Q' || value === ctrlC) {
+                cleanup();
+                resolve('quit');
+                return;
+            }
+            if (view !== 'overview' && (value === escapeKey || value === 'b' || value === 'B' || intent === 'back')) {
+                view = 'overview';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if (view === 'runs-focus' && (value === enter || value === '\n' || intent === 'select')) {
+                runsReadModel = selectFirstHomeRunDetail(runsReadModel);
+                rerender();
+                return;
+            }
+            if (intent === 'cancel') {
+                cleanup();
+                resolve('quit');
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'setup') {
+                cleanup();
+                resolve('open-setup');
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'status') {
+                view = 'status-focus';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'runs') {
+                runsReadModel = readHomeRuns(input.plan);
+                view = 'runs-focus';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'sdd') {
+                sddReadModel = readHomeSdd(input.plan, sddInput.change);
+                view = 'sdd-focus';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'skills') {
+                skillsReadModel = readHomeSkills(input.plan);
+                view = 'skills-focus';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if ((value === enter || value === '\n' || intent === 'select') && selectedTab === 'provider') {
+                view = 'provider-focus';
+                helpOpen = false;
+                rerender();
+                return;
+            }
+            if (value === enter || value === '\n' || intent === 'select')
+                return;
+            if (view !== 'overview')
+                return;
+            if (intent === 'next' || intent === 'down') {
+                selectedTab = nextItem(homeTuiTabs, selectedTab, 1);
+                rerender();
+                return;
+            }
+            if (intent === 'back' || intent === 'up') {
+                selectedTab = nextItem(homeTuiTabs, selectedTab, -1);
+                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();
+    if (action === 'open-setup') {
+        clearTerminalBeforeNestedTui(stdout);
+        return runSetupTuiController({ environment: input.environment, plan: input.plan });
+    }
+    return okText('');
+}
+function appendSddChangeInput(current, input) {
+    if (input.length !== 1 || current.length >= 80)
+        return current;
+    if (current.length === 0)
+        return /^[A-Za-z0-9]$/.test(input) ? input : current;
+    return /^[A-Za-z0-9._-]$/.test(input) ? `${current}${input}` : current;
+}
+function clearTerminalBeforeNestedTui(stdout) {
+    stdout.write(clearScreen);
+}
+function readHomeRuns(plan) {
+    const opened = openMemoryDatabase({ path: plan.db.path, readonly: true });
+    if (!opened.ok)
+        return { state: 'unavailable', databasePath: plan.db.path, message: opened.error.message };
+    try {
+        const service = new RunService(opened.value);
+        const recent = service.listRuns({ project: plan.project, limit: 5 });
+        if (!recent.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: recent.error.message };
+        const interrupted = service.listRecentInterruptedRuns({ project: plan.project, limit: 5 });
+        if (!interrupted.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: interrupted.error.message };
+        return {
+            state: 'ready',
+            databasePath: plan.db.path,
+            recent: recent.value.map(runRecordSummary),
+            interrupted: interrupted.value.map((run) => ({
+                id: run.runId,
+                status: run.status,
+                workflow: run.workflow,
+                phase: run.phase,
+                ...(run.userIntent === undefined ? {} : { userIntent: run.userIntent }),
+            })),
+            details: collectRunDetails(service, [...interrupted.value.map((run) => run.runId), ...recent.value.map((run) => run.id)]),
+        };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function collectRunDetails(service, runIds) {
+    const uniqueRunIds = [...new Set(runIds)];
+    const details = [];
+    for (const runId of uniqueRunIds) {
+        const run = service.getRun(runId);
+        if (!run.ok)
+            continue;
+        details.push(runDetailSummary(run.value));
+    }
+    return details;
+}
+function runDetailSummary(run) {
+    const userIntent = run.userIntent.trim();
+    const latestCheckpoint = run.checkpoints.at(-1);
+    const latestEvent = run.events.at(-1);
+    return {
+        id: run.id,
+        status: run.status,
+        workflow: run.workflow,
+        phase: run.phase,
+        ...(userIntent.length === 0 ? {} : { userIntent }),
+        ...(run.outcome === undefined ? {} : { outcome: run.outcome }),
+        ...(run.outcomeReason === undefined ? {} : { outcomeReason: run.outcomeReason }),
+        events: run.events.length,
+        checkpoints: run.checkpoints.length,
+        approvals: run.approvals.length,
+        approvalStatusCounts: countApprovalStatuses(run.approvals.map((approval) => approval.status)),
+        attempts: run.operationAttempts.length,
+        attemptStatusCounts: countAttemptStatuses(run.operationAttempts.map((attempt) => attempt.status)),
+        ...(latestCheckpoint === undefined ? {} : { latestCheckpointLabel: latestCheckpoint.label }),
+        ...(latestEvent === undefined ? {} : { latestEventTitle: latestEvent.title }),
+    };
+}
+function countApprovalStatuses(statuses) {
+    return {
+        pending: statuses.filter((status) => status === 'pending').length,
+        approved: statuses.filter((status) => status === 'approved').length,
+        rejected: statuses.filter((status) => status === 'rejected').length,
+        cancelled: statuses.filter((status) => status === 'cancelled').length,
+    };
+}
+function countAttemptStatuses(statuses) {
+    return {
+        reserved: statuses.filter((status) => status === 'reserved').length,
+        succeeded: statuses.filter((status) => status === 'succeeded').length,
+        failed: statuses.filter((status) => status === 'failed').length,
+        abandoned: statuses.filter((status) => status === 'abandoned').length,
+    };
+}
+function selectFirstHomeRunDetail(runs) {
+    if (runs.state !== 'ready' || runs.selected !== undefined)
+        return runs;
+    const firstInterruptedId = runs.interrupted[0]?.id;
+    const firstRecentId = runs.recent[0]?.id;
+    const selectedId = firstInterruptedId ?? firstRecentId;
+    if (selectedId === undefined)
+        return runs;
+    const selected = runs.details.find((detail) => detail.id === selectedId);
+    return selected === undefined ? runs : { ...runs, selected };
+}
+function runRecordSummary(run) {
+    const userIntent = run.userIntent.trim();
+    return {
+        id: run.id,
+        status: run.status,
+        workflow: run.workflow,
+        phase: run.phase,
+        ...(userIntent.length === 0 ? {} : { userIntent }),
+    };
+}
+function readHomeSkills(plan) {
+    const opened = openMemoryDatabase({ path: plan.db.path, readonly: true });
+    if (!opened.ok)
+        return { state: 'unavailable', databasePath: plan.db.path, message: opened.error.message };
+    try {
+        const registry = new SkillRegistryService(opened.value);
+        const index = new SkillIndexService(registry).getIndex({ project: plan.project, scope: 'project' });
+        if (!index.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: index.error.message };
+        return { state: 'ready', databasePath: plan.db.path, index: index.value };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function readHomeSdd(plan, change) {
+    if (change.length === 0)
+        return { state: 'not-loaded' };
+    const opened = openMemoryDatabase({ path: plan.db.path, readonly: true });
+    if (!opened.ok)
+        return { state: 'unavailable', databasePath: plan.db.path, message: opened.error.message };
+    try {
+        const sdd = new SddWorkflowService(new MemoryService(opened.value));
+        const status = sdd.getStatus({ project: plan.project, change });
+        if (!status.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: status.error.message };
+        const next = sdd.getNext({ project: plan.project, change });
+        if (!next.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: next.error.message };
+        const cockpit = sdd.getCockpit({ project: plan.project, change });
+        if (!cockpit.ok)
+            return { state: 'unavailable', databasePath: plan.db.path, message: cockpit.error.message };
+        const continuation = sddContinuationPlanFrom({ project: plan.project, next: next.value, cockpit: cockpit.value });
+        return { state: 'ready', databasePath: plan.db.path, status: status.value, next: next.value, cockpit: cockpit.value, continuation };
+    }
+    finally {
+        opened.value.close();
+    }
+}
+function tuiWidth(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));
+}

package/dist/interfaces/cli/index.js

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

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

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

package/dist/interfaces/cli/product-resume-renderer.js

@@ -0,0 +1,32 @@
+export function renderProductResume(resume) {
+    const lines = [
+        'Resume',
+        ...resume.resume.map((line) => `- ${line}`),
+        '',
+        'Why',
+        ...resume.why.map((line) => `- ${line}`),
+        '',
+        'Blockers',
+        ...(resume.blockers.length === 0 ? ['- none'] : resume.blockers.map((line) => `- ${line}`)),
+        ...(resume.candidateRuns.length === 0
+            ? []
+            : [
+                '',
+                'Candidate runs',
+                ...resume.candidateRuns.flatMap((run) => [
+                    `- ${run.runId} [${run.status}] ${run.workflow}/${run.phase}`,
+                    ...(run.userIntent === undefined ? [] : [`  Intent: ${run.userIntent}`]),
+                    `  Latest checkpoint: ${run.latestCheckpointLabel ?? 'none'}`,
+                    `  Resume command: ${run.command}`,
+                ]),
+            ]),
+        '',
+        'Command',
+        `- ${resume.command}`,
+        ...(resume.manualNextCommands.length === 0 ? [] : ['', 'Related commands', ...resume.manualNextCommands.map((line) => `- ${line}`)]),
+        '',
+        'Safety',
+        ...resume.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}

package/dist/interfaces/cli/product-status-renderer.js

@@ -0,0 +1,81 @@
+export function renderProductStatus(status) {
+    const commandHeading = productCommandHeading(status);
+    const lines = [
+        'Status',
+        ...status.status.map((line) => `- ${line}`),
+        '',
+        'Blockers',
+        ...status.blockers.map((line) => `- ${line}`),
+        '',
+        'Next',
+        ...status.next.map((line) => `- ${line}`),
+        '',
+        commandHeading,
+        `- ${status.command}`,
+        '',
+        ...(status.relatedRunContext === undefined ? [] : relatedRunContextLines(status.relatedRunContext, true)),
+        'Safety',
+        ...status.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+export function buildProductNext(status) {
+    const blockers = status.blockers.filter((line) => line !== 'none');
+    const blocked = status.sddNextStatus === undefined ? blockers.length > 0 : status.sddNextStatus === 'blocked';
+    const visibleBlockers = blocked ? blockers : [];
+    const command = blocked ? buildBlockedNextCommand(status) : status.command;
+    return {
+        version: 1,
+        kind: 'product-next',
+        project: status.project,
+        ...(status.change === undefined ? {} : { change: status.change }),
+        blocked,
+        next: status.next,
+        why: status.status,
+        blockers: visibleBlockers,
+        command,
+        ...(status.relatedRunContext === undefined ? {} : { relatedRunContext: status.relatedRunContext }),
+        safety: status.safety,
+    };
+}
+function buildBlockedNextCommand(status) {
+    const change = status.change === undefined ? '<change>' : status.change;
+    const dbHint = status.command.includes('--db <path>') ? ' --db <path>' : '';
+    return `vgxness next --project ${status.project.value} --change ${change}${dbHint}`;
+}
+export function renderProductNext(next) {
+    const commandHeading = next.blocked ? 'Recovery/diagnostic command' : 'Continuation guidance command';
+    const lines = [
+        'Next',
+        ...next.next.map((line) => `- ${line}`),
+        '',
+        'Why',
+        ...next.why.map((line) => `- ${line}`),
+        ...(next.blockers.length === 0 ? [] : ['', 'Blockers', ...next.blockers.map((line) => `- ${line}`)]),
+        '',
+        commandHeading,
+        `- ${next.command}`,
+        '',
+        ...(next.relatedRunContext === undefined ? [] : relatedRunContextLines(next.relatedRunContext, true)),
+        'Safety',
+        ...next.safety.map((line) => `- ${line}`),
+    ];
+    return `${lines.join('\n')}\n`;
+}
+function productCommandHeading(status) {
+    if (status.sddNextStatus === 'runnable')
+        return 'Continuation guidance command';
+    return 'Recovery/diagnostic command';
+}
+function relatedRunContextLines(relatedRunContext, includeTrailingBlank) {
+    return [
+        'Related interrupted run:',
+        `- Run ID: ${relatedRunContext.runId}`,
+        `- Status: ${relatedRunContext.status}`,
+        `- Workflow/phase: ${relatedRunContext.workflow}/${relatedRunContext.phase}`,
+        `- Latest checkpoint: ${relatedRunContext.latestCheckpointLabel ?? 'none'}`,
+        `- Recommendation: ${relatedRunContext.recommendation}`,
+        `- Resume command: ${relatedRunContext.resumeCommand}`,
+        ...(includeTrailingBlank ? [''] : []),
+    ];
+}