@4ge/cli 0.1.0

package/dist/commands/idea/update.js

@@ -0,0 +1,108 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { updateIdea } from '../../generated/api/sdk.gen.js';
+import { zUpdateIdeaResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class IdeaUpdate extends BaseCommand {
+    static description = 'Update an existing idea';
+    static examples = [
+        '<%= config.bin %> idea:update <id> --workspace <id> --title "Updated Title"',
+        '<%= config.bin %> idea:update <id> --workspace <id> --description "Updated description"',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Idea ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        force: Flags.boolean({ description: 'Skip confirmation prompt', default: false }),
+        workspace: Flags.string({
+            description: 'Workspace ID',
+            char: 'w',
+        }),
+        title: Flags.string({
+            description: 'New title',
+            char: 't',
+        }),
+        description: Flags.string({
+            description: 'New description',
+            char: 'd',
+        }),
+        status: Flags.string({
+            description: 'New status',
+            char: 's',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(IdeaUpdate);
+        const config = await readConfig();
+        const workspaceId = flags.workspace || config?.workspace_id;
+        if (!workspaceId) {
+            this.handleError('Workspace ID is required. Use --workspace or run in an initialized project.', { code: 'MISSING_WORKSPACE' });
+            return;
+        }
+        await this.renderHeader('ready', 'compact');
+        if (!flags.title && !flags.description && !flags.status) {
+            const message = 'At least one field to update must be provided (--title, --description, or --status).';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'MISSING_INPUT' });
+            }
+            else {
+                this.error(message);
+            }
+            return;
+        }
+        const confirmed = await this.confirmAction(`Update idea ${args.id} in workspace ${workspaceId}?`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed) {
+            this.log('Operation cancelled.');
+            return;
+        }
+        const payload = {
+            path: {
+                workspaceId,
+                ideaId: args.id,
+            },
+            body: {
+                ...(flags.title !== undefined && { title: flags.title }),
+                ...(flags.description !== undefined && { description: flags.description }),
+                ...(flags.status !== undefined && { status: flags.status }),
+            },
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        try {
+            const { data, error } = await this.withSpinner('Updating idea...', () => updateIdea({
+                client,
+                ...payload,
+            }));
+            const validated = validateResponse(data, error, zUpdateIdeaResponse);
+            const result = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(result, { source: 'idea:update', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Idea ${args.id} updated successfully.` }));
+                if (this.isInteractiveMode) {
+                    const { default: chalk } = await import('chalk');
+                    this.log(`\n  🚀 Actions:`);
+                    this.log(`  - Show details: ${chalk.cyan(`4ge idea:show ${args.id} --workspace ${workspaceId}`)}`);
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to update idea: ${args.id}`, err);
+        }
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,354 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import React from 'react';
+import * as ink from 'ink';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { BaseCommand } from '../base.js';
+import CliHeader from '../ui/components/cli-header.js';
+import { isProjectInitialized, writeConfig, getGitignoreEntries, getLocalConfigPath, hasLocal4geDir, readConfig, getLocal4geDir } from '../core/config/index.js';
+import { listWorkspaces, listProjects } from '../generated/api/sdk.gen.js';
+import { extractData, ApiValidationError } from '../core/api/index.js';
+import { zListWorkspacesResponse, zListProjectsResponse } from '../generated/api/zod.gen.js';
+import { installSkill } from '../core/skill/installer.js';
+var InitStep;
+(function (InitStep) {
+    InitStep["DETECTION"] = "DETECTION";
+    InitStep["WORKSPACE"] = "WORKSPACE";
+    InitStep["PROJECT"] = "PROJECT";
+    InitStep["COMPLETE"] = "COMPLETE";
+    InitStep["CANCELLED"] = "CANCELLED";
+})(InitStep || (InitStep = {}));
+function renderCliHeader(version) {
+    let statusSetter = null;
+    const StatusDrivenHeader = () => {
+        const [status, setStatus] = React.useState('checking-connectivity');
+        statusSetter = setStatus;
+        return React.createElement(CliHeader, { version, status });
+    };
+    const instance = ink.render(React.createElement(StatusDrivenHeader));
+    return {
+        instance,
+        setStatus: (newStatus) => {
+            if (statusSetter) {
+                statusSetter(newStatus);
+            }
+        },
+    };
+}
+export default class Init extends BaseCommand {
+    static description = 'Initialize a new 4ge project';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({ description: 'Workspace ID to use' }),
+        project: Flags.string({ description: 'Project ID to use' }),
+        skill: Flags.boolean({
+            description: 'Install the 4ge CLI agent skill after initialization (non-interactive)',
+            default: false,
+        }),
+    };
+    async run() {
+        try {
+            const { flags } = await this.parse(Init);
+            let currentStep = InitStep.DETECTION;
+            let selectedWorkspaceId = flags.workspace;
+            let selectedProjectId = flags.project;
+            let workspaceName = '';
+            let projectName = '';
+            let client;
+            if (!this.isJsonMode) {
+                const { instance, setStatus } = renderCliHeader(this.config.version);
+                // Yield to allow Ink to mount the component before we start updating status
+                await new Promise(resolve => setTimeout(resolve, 0));
+                try {
+                    client = await this.getClient({
+                        onStatusChange: (status) => setStatus(status),
+                    });
+                    instance.clear();
+                    instance.unmount();
+                    // Small delay to let Ink flush the final frame
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                    await this.renderHeader('ready');
+                }
+                catch (error) {
+                    instance.clear();
+                    instance.unmount();
+                    // Small delay to let Ink flush the final frame
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                    await this.renderHeader('no-connection');
+                    throw error;
+                }
+            }
+            else {
+                client = await this.getClient();
+            }
+            while (currentStep !== InitStep.COMPLETE && currentStep !== InitStep.CANCELLED) {
+                switch (currentStep) {
+                    case InitStep.DETECTION: {
+                        const isInitialized = await isProjectInitialized();
+                        const hasDir = await hasLocal4geDir();
+                        if (isInitialized) {
+                            const existingConfig = await readConfig();
+                            if (this.isJsonMode) {
+                                this.outputJson({ initialized: true, config: existingConfig });
+                                return;
+                            }
+                            if (existingConfig) {
+                                const { data: projectsData, error: projectsError } = await listProjects({
+                                    client,
+                                    headers: { 'x-workspace-id': existingConfig.workspace_id }
+                                });
+                                const existingProjects = extractData(projectsData, projectsError, zListProjectsResponse);
+                                const projectBelongsToWorkspace = existingProjects.some((p) => p.id === existingConfig.project_id);
+                                if (!projectBelongsToWorkspace) {
+                                    this.warn(`⚠ Project "${existingConfig.project_name || existingConfig.project_id}" does not belong to workspace "${existingConfig.workspace_name || existingConfig.workspace_id}"`);
+                                }
+                            }
+                            if (!(await this.confirmPrompt('Project already initialized. Reinitialize?', false, { helpText: 'Ctrl+D: exit' }))) {
+                                this.log('Aborted.');
+                                return;
+                            }
+                        }
+                        else if (hasDir) {
+                            if (this.isJsonMode) {
+                                this.outputErrorAndExit({ message: 'Incomplete .4ge configuration found. Re-initialize to complete setup.', code: 'INCOMPLETE_CONFIG' });
+                                return;
+                            }
+                            this.log('⚠ Found an incomplete .4ge configuration. Let\'s set it up properly.');
+                        }
+                        if (this.isJsonMode) {
+                            if (!selectedWorkspaceId || !selectedProjectId) {
+                                this.outputErrorAndExit({
+                                    message: '--workspace and --project are required in --json mode',
+                                    code: 'MISSING_REQUIRED_FLAGS'
+                                });
+                                return;
+                            }
+                            // Validate workspace
+                            const { data: wsData, error: wsError } = await listWorkspaces({ client });
+                            const workspaces = extractData(wsData, wsError, zListWorkspacesResponse);
+                            const workspace = workspaces.find((w) => w.id === selectedWorkspaceId);
+                            if (!workspace) {
+                                this.outputErrorAndExit({ message: `Workspace "${selectedWorkspaceId}" not found.`, code: 'INVALID_WORKSPACE' });
+                                return;
+                            }
+                            workspaceName = workspace.name;
+                            // Validate project
+                            const { data: projectsData, error: projectsError } = await listProjects({
+                                client,
+                                headers: { 'x-workspace-id': selectedWorkspaceId }
+                            });
+                            const projects = extractData(projectsData, projectsError, zListProjectsResponse);
+                            const project = projects.find((p) => p.id === selectedProjectId);
+                            if (!project) {
+                                this.outputErrorAndExit({ message: `Project "${selectedProjectId}" not found in workspace "${selectedWorkspaceId}".`, code: 'INVALID_PROJECT' });
+                                return;
+                            }
+                            projectName = project.name;
+                            currentStep = InitStep.COMPLETE;
+                        }
+                        else {
+                            currentStep = InitStep.WORKSPACE;
+                        }
+                        break;
+                    }
+                    case InitStep.WORKSPACE: {
+                        const { data: wsData, error: wsError } = await listWorkspaces({ client });
+                        const workspaces = extractData(wsData, wsError, zListWorkspacesResponse);
+                        if (workspaces.length === 0)
+                            this.error('No workspaces found for this account.');
+                        const workspace = flags.workspace
+                            ? workspaces.find(w => w.id === flags.workspace)
+                            : workspaces.length === 1
+                                ? workspaces[0]
+                                : null;
+                        if (workspace) {
+                            if (!flags.workspace && workspaces.length === 1) {
+                                this.log(`Using only available workspace: ${workspace.name} (${workspace.id})`);
+                            }
+                            selectedWorkspaceId = workspace.id;
+                            workspaceName = workspace.name;
+                            currentStep = InitStep.PROJECT;
+                            break;
+                        }
+                        if (flags.workspace)
+                            this.error(`Workspace "${flags.workspace}" not found.`);
+                        const options = workspaces.map((w) => ({ label: w.name, value: w.id, description: w.id }));
+                        const result = await this.selectOption('Select workspace:', options, {
+                            helpText: 'Esc: exit • Ctrl+D: exit'
+                        });
+                        if (result === null) {
+                            currentStep = InitStep.CANCELLED;
+                        }
+                        else {
+                            const selected = workspaces.find((w) => w.id === result);
+                            selectedWorkspaceId = result;
+                            workspaceName = selected?.name || '';
+                            currentStep = InitStep.PROJECT;
+                        }
+                        break;
+                    }
+                    case InitStep.PROJECT: {
+                        const { data: projectsData, error: projectsError } = await listProjects({
+                            client,
+                            headers: { 'x-workspace-id': selectedWorkspaceId }
+                        });
+                        const projects = extractData(projectsData, projectsError, zListProjectsResponse);
+                        if (projects.length === 0)
+                            this.error(`No projects found in workspace ${selectedWorkspaceId}`);
+                        const project = flags.project
+                            ? projects.find(p => p.id === flags.project)
+                            : projects.length === 1
+                                ? projects[0]
+                                : null;
+                        if (project) {
+                            if (!flags.project && projects.length === 1) {
+                                this.log(`Using only available project: ${project.name} (${project.id})`);
+                            }
+                            selectedProjectId = project.id;
+                            projectName = project.name;
+                            currentStep = InitStep.COMPLETE;
+                            break;
+                        }
+                        if (flags.project)
+                            this.error(`Project "${flags.project}" not found in workspace "${selectedWorkspaceId}".`);
+                        const options = projects.map((p) => ({ label: p.name, value: p.id, description: p.id }));
+                        const result = await this.selectOption('Select project:', options, {
+                            context: [{ label: 'Workspace', value: workspaceName }],
+                            helpText: flags.workspace ? 'Esc: exit • Ctrl+D: exit' : 'Esc: back • Ctrl+D: exit'
+                        });
+                        if (result === null) {
+                            currentStep = flags.workspace ? InitStep.CANCELLED : InitStep.WORKSPACE;
+                        }
+                        else {
+                            const selected = projects.find((p) => p.id === result);
+                            selectedProjectId = result;
+                            projectName = selected?.name || '';
+                            currentStep = InitStep.COMPLETE;
+                        }
+                        break;
+                    }
+                }
+            }
+            if (currentStep === InitStep.CANCELLED) {
+                this.log('Initialization cancelled.');
+                return;
+            }
+            if (!selectedProjectId || !selectedWorkspaceId) {
+                this.error('Unexpected state: missing project or workspace selection.');
+                return;
+            }
+            // 4. Write Config
+            await writeConfig({
+                project_id: selectedProjectId,
+                workspace_id: selectedWorkspaceId,
+                project_name: projectName || undefined,
+                workspace_name: workspaceName || undefined,
+                hierarchy: {
+                    default_roadmap_filter: 'now',
+                    recursive_pull: true,
+                },
+                pull: {
+                    generate_stubs: false,
+                    include_brief_deps: false,
+                },
+                cli: {
+                    default_mode: 'pretty',
+                }
+            });
+            // 5. Update .4ge/.gitignore
+            let gitignoreUpdated = false;
+            const entries = getGitignoreEntries();
+            try {
+                const gitignorePath = join(getLocal4geDir(), '.gitignore');
+                let content = '';
+                try {
+                    content = await readFile(gitignorePath, 'utf-8');
+                }
+                catch (e) {
+                    if (e.code !== 'ENOENT')
+                        throw e;
+                }
+                const lines = content.split('\n').map(l => l.trim());
+                const toAdd = entries.filter(e => !lines.includes(e));
+                if (toAdd.length > 0) {
+                    const newContent = content + (content.endsWith('\n') || content === '' ? '' : '\n') + toAdd.join('\n') + '\n';
+                    await writeFile(gitignorePath, newContent, 'utf-8');
+                    gitignoreUpdated = true;
+                }
+            }
+            catch (e) {
+                this.warn(`Failed to update .4ge/.gitignore: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            // 6. Skill install (optional)
+            let skillInstalled = false;
+            let skillPath;
+            const shouldInstallSkill = flags.skill || (!this.isJsonMode && await this.confirmPrompt('Install the 4ge CLI skill for AI agents here?', false, { helpText: 'Ctrl+D: exit' }));
+            if (shouldInstallSkill) {
+                try {
+                    const result = await installSkill({ agent: 'universal', scope: 'project', force: false });
+                    skillInstalled = true;
+                    skillPath = result.path;
+                }
+                catch (err) {
+                    if (this.isJsonMode) {
+                        this.outputErrorAndExit({
+                            message: err?.message ?? String(err),
+                            code: 'SKILL_INSTALL_FAILED',
+                            hint: /already exists/i.test(err?.message ?? '') ? 'Re-run `4ge skill:install --force`.' : undefined,
+                        });
+                        return;
+                    }
+                    this.warn(`Failed to install skill: ${err instanceof Error ? err.message : String(err)}`);
+                    this.warn('Run `4ge skill:install` later to add it.');
+                }
+            }
+            // 7. Success Output
+            if (this.isJsonMode) {
+                this.outputJson({
+                    project_id: selectedProjectId,
+                    workspace_id: selectedWorkspaceId,
+                    config_path: getLocalConfigPath(),
+                    gitignore_updated: gitignoreUpdated,
+                    skill_installed: skillInstalled,
+                    ...(skillPath ? { skill_path: skillPath } : {}),
+                });
+            }
+            else {
+                const { SuccessMessage } = await import('../ui/index.js');
+                const React = await import('react');
+                await this.renderInk(React.createElement(SuccessMessage, { message: 'Project initialized successfully!' }));
+                this.log(`Config written to: ${getLocalConfigPath()}`);
+                if (gitignoreUpdated) {
+                    this.log('.4ge/.gitignore updated with private entries.');
+                }
+                if (skillInstalled && skillPath) {
+                    this.log(`Skill installed at: ${skillPath}`);
+                    this.log(chalk.dim('Reload your AI agent to pick up the new skill.'));
+                }
+                this.log(chalk.dim('\nConfigure additional settings with: 4ge config manage'));
+                this.log(chalk.dim('Available: default mode, hierarchy settings, pull settings\n'));
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiValidationError) {
+                if (this.isJsonMode) {
+                    this.outputError({
+                        message: err.message,
+                        code: 'API_VALIDATION_ERROR',
+                        details: err.details
+                    });
+                    this.exit(1);
+                    return;
+                }
+                else {
+                    const detail = err.details instanceof Error ? err.details.message : String(err.details ?? '');
+                    this.log(chalk.red('\nAPI response format changed — please update your CLI with `npm update -g @4ge/cli`'));
+                    this.error(`${err.message}: ${detail}`);
+                }
+                return;
+            }
+            this.handleError('Initialization failed', err);
+        }
+    }
+}

package/dist/commands/login.js

@@ -0,0 +1,5 @@
+import AuthLogin from './auth/login.js';
+export default class Login extends AuthLogin {
+    static description = 'Alias for `4ge auth login`';
+    static hidden = false;
+}

package/dist/commands/plan/index.js

@@ -0,0 +1,10 @@
+import { Help } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+export default class PlanIndex extends BaseCommand {
+    static description = 'Manage project plans';
+    async run() {
+        await this.renderHeader('ready', 'compact');
+        const help = new Help(this.config);
+        await help.showHelp(['plan']);
+    }
+}

package/dist/commands/plan/pull.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BaseCommand } from '../../base.js';
+import { readConfig, getAssetPath } from '../../core/config/index.js';
+import { resolveRoadmapFilter } from '../../core/config/defaults.js';
+import { getPlanTree } from '../../generated/api/sdk.gen.js';
+import { zGetPlanTreeResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { Flags } from '@oclif/core';
+import { SuccessMessage } from '../../ui/index.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export default class PlanPull extends BaseCommand {
+    static description = 'Downloads the complete plan tree snapshot for the current project';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        roadmap: Flags.string({
+            description: 'Filter by roadmap status (now|next|later)',
+            options: ['now', 'next', 'later'],
+        }),
+        status: Flags.string({
+            description: 'Filter by status (BACKLOG|NOT_STARTED|IN_PLANNING|READY_FOR_DEVELOPMENT|IN_DEVELOPMENT|BLOCKED|REVIEW|COMPLETE)',
+        }),
+        save: Flags.boolean({
+            description: 'Force save to disk even in JSON mode',
+            default: false,
+        }),
+        stdout: Flags.boolean({
+            description: 'Print to stdout without saving',
+            default: false,
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> plan:pull',
+        '<%= config.bin %> plan:pull --roadmap next',
+        '<%= config.bin %> plan:pull --status COMPLETE',
+        '<%= config.bin %> plan:pull --roadmap now --status IN_DEVELOPMENT',
+        '<%= config.bin %> plan:pull --json',
+        '<%= config.bin %> plan:pull --json --save',
+        '<%= config.bin %> plan:pull --stdout',
+    ];
+    async run() {
+        const { flags } = await this.parse(PlanPull);
+        // Validate flag combination
+        if (flags.json && flags.stdout) {
+            this.error('Cannot use --json and --stdout together');
+        }
+        if (flags.save && flags.stdout) {
+            this.error('Cannot use --stdout and --save together');
+        }
+        await this.renderHeader('ready', 'compact');
+        await this.migrateAssetsIfNeeded();
+        const client = await this.getClient();
+        const config = await readConfig();
+        if (!config?.project_id) {
+            const message = 'Project not initialized. Run `4ge init` first to set project context.';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'NOT_INITIALIZED' });
+            }
+            else {
+                this.error(message);
+            }
+            return;
+        }
+        try {
+            const roadmapFilter = resolveRoadmapFilter(flags.roadmap, config);
+            const { data, error } = await this.withRetry(() => getPlanTree({
+                client,
+                path: { projectId: config.project_id },
+                query: {
+                    ...(roadmapFilter ? { roadmap: roadmapFilter } : {}),
+                    ...(flags.status ? { status: flags.status } : {}),
+                },
+            }));
+            const validated = validateResponse(data, error, zGetPlanTreeResponse);
+            const payload = validated.data;
+            const metadata = validated.metadata;
+            const savePath = getAssetPath('plan.json');
+            if (this.isJsonMode) {
+                this.outputJson(payload, metadata);
+                if (flags.save) {
+                    await this.saveToFile(savePath, payload);
+                    this.log('Saved to .4ge/assets/plan.json');
+                }
+            }
+            else if (flags.stdout) {
+                this.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                await this.saveToFile(savePath, payload);
+                await this.renderInk(_jsx(SuccessMessage, { message: "Plan saved to .4ge/assets/plan.json" }));
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+    async saveToFile(filePath, data) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+}

package/dist/commands/plan/versions.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { getPlanVersions } from '../../generated/api/sdk.gen.js';
+import { zGetPlanVersionsResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class PlanVersions extends BaseCommand {
+    static description = 'Lists available plan versions';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static examples = [
+        '<%= config.bin %> plan:versions',
+        '<%= config.bin %> plan:versions --json',
+    ];
+    async run() {
+        const { flags } = await this.parse(PlanVersions);
+        await this.renderHeader('ready', 'compact');
+        const client = await this.getClient();
+        const config = await readConfig();
+        if (!config?.project_id) {
+            const message = 'Project not initialized. Run `4ge init` first to set project context.';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'NOT_INITIALIZED' });
+            }
+            else {
+                this.error(message);
+            }
+            return;
+        }
+        try {
+            const { data, error } = await this.withRetry(() => getPlanVersions({
+                client,
+                path: { projectId: config.project_id },
+            }));
+            const validated = validateResponse(data, error, zGetPlanVersionsResponse);
+            const payload = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(payload, metadata);
+            }
+            else {
+                const versions = payload.versions || [];
+                const latestVersion = payload.latestVersion;
+                if (latestVersion !== undefined) {
+                    this.log(`Latest Version: ${latestVersion}`);
+                }
+                await this.renderInk(_jsx(DataTable, { data: versions, columns: [
+                        { key: 'id', header: 'ID' },
+                        { key: 'versionNumber', header: 'Version' },
+                        { key: 'changeDescription', header: 'Change Description', format: (v) => v || '-' },
+                        { key: 'createdAt', header: 'Created', format: (v) => new Date(v).toLocaleString() },
+                    ], title: "Plan Versions", emptyMessage: "No versions found" }));
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+}