@4ge/cli 0.1.0

package/dist/commands/config/set.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { updateConfig, readConfig } from '../../core/config/parser.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class ConfigSet extends BaseCommand {
+    static description = 'Set a configuration value';
+    static args = {
+        key: Args.string({ description: 'Config key (dot notation, e.g., cli.default_mode)', required: true }),
+        value: Args.string({ description: 'Config value', required: true }),
+    };
+    async run() {
+        const { args } = await this.parse(ConfigSet);
+        // Load local config
+        const config = await readConfig();
+        if (!config) {
+            this.handleError('No project config found. Run `4ge init` first.', { code: 'NOT_INITIALIZED' });
+            return;
+        }
+        await this.renderHeader('ready', 'compact');
+        // Parse dot-notation key and set value
+        const keys = args.key.split('.');
+        const update = {};
+        let current = update;
+        for (let i = 0; i < keys.length - 1; i++) {
+            current[keys[i]] = {};
+            current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = args.value;
+        try {
+            await updateConfig(update);
+            if (this.isJsonMode) {
+                this.outputJson({ [args.key]: args.value }, { source: 'config set' });
+                return;
+            }
+            await this.renderInk(_jsx(SuccessMessage, { message: `${args.key} set to ${args.value}` }));
+        }
+        catch (err) {
+            this.handleError(`Invalid config value: ${err.message}`, { code: 'INVALID_CONFIG' });
+        }
+    }
+}

package/dist/commands/config/show.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/parser.js';
+import { DataTable } from '../../ui/components/data-table.js';
+export default class ConfigShow extends BaseCommand {
+    static description = 'Show all configuration values';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        const config = await readConfig();
+        if (!config) {
+            this.handleError('No project config found. Run `4ge init` first.', { code: 'NOT_INITIALIZED' });
+            return;
+        }
+        await this.renderHeader('ready', 'compact');
+        if (this.isJsonMode) {
+            this.outputJson(config);
+            return;
+        }
+        const flattened = this.flattenObject(config);
+        const data = Object.entries(flattened).map(([key, value]) => ({ key, value: String(value) }));
+        await this.renderInk(_jsx(DataTable, { data: data, columns: [
+                { key: 'key', header: 'Key' },
+                { key: 'value', header: 'Value' }
+            ] }));
+        if (this.isInteractiveMode) {
+            await this.handleActionHints([
+                { label: 'Set config', command: '4ge config set <key> <value>' },
+                { label: 'Get config', command: '4ge config get <key>' },
+            ]);
+        }
+    }
+    flattenObject(obj, prefix = '') {
+        return Object.keys(obj).reduce((acc, k) => {
+            const pre = prefix.length ? prefix + '.' : '';
+            if (typeof obj[k] === 'object' && obj[k] !== null && !Array.isArray(obj[k])) {
+                Object.assign(acc, this.flattenObject(obj[k], pre + k));
+            }
+            else {
+                acc[pre + k] = obj[k];
+            }
+            return acc;
+        }, {});
+    }
+}

package/dist/commands/epic/index.js

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

package/dist/commands/epic/list.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { listEpics } from '../../generated/api/sdk.gen.js';
+import { zListEpicsResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class EpicList extends BaseCommand {
+    static description = 'List epics for the current project';
+    static examples = [
+        '<%= config.bin %> epic:list',
+        '<%= config.bin %> epic:list --roadmap next --json',
+        '<%= config.bin %> epic:list --status IN_DEVELOPMENT',
+    ];
+    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 (e.g. BACKLOG, IN_DEVELOPMENT, COMPLETE)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EpicList);
+        await this.renderHeader('ready', 'compact');
+        // 1. Resolve Auth and Config
+        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;
+        }
+        // 2. Call SDK
+        try {
+            const response = await this.withSpinner('Fetching epics...', () => listEpics({
+                client,
+                path: {
+                    projectId: config.project_id,
+                },
+                query: {
+                    ...(flags.roadmap ? { roadmap: flags.roadmap } : {}),
+                    ...(flags.status ? { status: flags.status } : {}),
+                },
+            }));
+            const { data, error } = response;
+            const validated = validateResponse(data, error, zListEpicsResponse);
+            const items = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(items, { source: 'epic list' });
+            }
+            else {
+                await this.renderInk(_jsx(DataTable, { data: items, columns: [
+                        { key: 'label', header: 'Title', minWidth: 20 },
+                        { key: 'id', header: 'ID' },
+                        { key: 'status', header: 'Status', color: 'auto' },
+                        { key: 'roadmap_status', header: 'Roadmap' },
+                    ], title: `Epics in ${config.project_id}${flags.roadmap ? ` (${flags.roadmap})` : ''}`, emptyMessage: `No epics found${flags.roadmap ? ` for roadmap: ${flags.roadmap}` : ''}` }));
+                if (this.isInteractiveMode) {
+                    if (items.length > 0) {
+                        const options = items.map((item) => ({
+                            label: item.label || item.id,
+                            value: item.id,
+                            description: item.status || '',
+                        }));
+                        const selectedId = await this.selectOption('Select an epic for details:', options, { headerVariant: 'compact' });
+                        if (selectedId) {
+                            const { default: chalk } = await import('chalk');
+                            this.log(`\n  🚀 Run: ${chalk.cyan(`4ge epic show ${selectedId}`)}\n`);
+                        }
+                    }
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+}

package/dist/commands/epic/pull.js

@@ -0,0 +1,137 @@
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import { BaseCommand } from '../../base.js';
+import { readConfig, getCollectionDir } from '../../core/config/index.js';
+import { resolveRecursive, resolveRoadmapFilter } from '../../core/config/defaults.js';
+import { getEpicDetail, getEpicTree } from '../../generated/api/sdk.gen.js';
+import { zGetEpicTreeResponse, zGetEpicDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export default class EpicPull extends BaseCommand {
+    static description = 'Download epic details and optionally its hierarchy';
+    static examples = [
+        '<%= config.bin %> epic:pull --id <uuid>',
+        '<%= config.bin %> epic:pull --id <uuid> --json',
+        '<%= config.bin %> epic:pull --id <uuid> --recursive',
+        '<%= config.bin %> epic:pull --id <uuid> --recursive --roadmap now --status BACKLOG',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        id: Flags.string({
+            description: 'Epic ID',
+            required: true,
+        }),
+        recursive: Flags.boolean({
+            description: 'Pull full hierarchy tree instead of just the epic detail',
+            allowNo: true,
+        }),
+        roadmap: Flags.string({
+            description: 'Filter hierarchy by roadmap status (now|next|later). Only used with --recursive.',
+            options: ['now', 'next', 'later'],
+        }),
+        status: Flags.string({
+            description: 'Filter hierarchy by status. Only used with --recursive.',
+        }),
+        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,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EpicPull);
+        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;
+        }
+        const isRecursive = resolveRecursive(flags.recursive, config);
+        const spinnerMsg = isRecursive ? `Pulling epic ${flags.id} tree...` : `Pulling epic ${flags.id}...`;
+        const roadmapFilter = resolveRoadmapFilter(flags.roadmap, config);
+        const response = await this.withSpinner(spinnerMsg, () => {
+            if (isRecursive) {
+                return getEpicTree({
+                    client,
+                    path: {
+                        projectId: config.project_id,
+                        epicId: flags.id,
+                    },
+                    query: {
+                        ...(roadmapFilter ? { roadmap: roadmapFilter } : {}),
+                        ...(flags.status ? { status: flags.status } : {}),
+                    },
+                });
+            }
+            else {
+                return getEpicDetail({
+                    client,
+                    path: {
+                        projectId: config.project_id,
+                        epicId: flags.id,
+                    },
+                });
+            }
+        });
+        const { data, error } = response;
+        try {
+            let payload;
+            let metadata;
+            if (isRecursive) {
+                // The generated tree schema models `data` as optional (the tree payload
+                // is loosely typed). Cast to the envelope type — the validation still
+                // runs and the payload is treated as `unknown`.
+                const validated = validateResponse(data, error, zGetEpicTreeResponse);
+                payload = validated.data;
+                metadata = validated.metadata;
+            }
+            else {
+                const validated = validateResponse(data, error, zGetEpicDetailResponse);
+                payload = validated.data;
+                metadata = validated.metadata;
+            }
+            const savePath = path.join(getCollectionDir('epics'), `${flags.id}.json`);
+            if (this.isJsonMode) {
+                this.outputJson(payload);
+                if (flags.save) {
+                    await this.saveToFile(savePath, payload);
+                }
+            }
+            else if (flags.stdout) {
+                this.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                await this.saveToFile(savePath, payload);
+                this.log(`${chalk.green('✓')} Epic saved to .4ge/assets/epics/${flags.id}.json`);
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to pull epic: ${flags.id}`, 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/epic/show.js

@@ -0,0 +1,67 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { getEpicDetail } from '../../generated/api/sdk.gen.js';
+import { zGetEpicDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+export default class EpicShow extends BaseCommand {
+    static description = 'Show detailed information for a specific epic';
+    static examples = [
+        '<%= config.bin %> epic:show --id <uuid>',
+        '<%= config.bin %> epic:show --id <uuid> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        id: Flags.string({
+            description: 'Epic ID',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EpicShow);
+        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;
+        }
+        await this.renderHeader('ready', 'compact');
+        const response = await this.withSpinner(`Fetching epic ${flags.id}...`, () => getEpicDetail({
+            client,
+            path: {
+                projectId: config.project_id,
+                epicId: flags.id
+            },
+        }));
+        const { data, error } = response;
+        try {
+            const validated = validateResponse(data, error, zGetEpicDetailResponse);
+            const payload = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(payload, { source: 'epic show' });
+            }
+            else {
+                this.log(`\nEpic: ${payload.label}`);
+                this.log(`ID:     ${payload.id}`);
+                this.log(`Status: ${payload.status}`);
+                this.log(`Roadmap: ${payload.roadmap_status || 'N/A'}`);
+                if (payload.description) {
+                    this.log(`\nDescription:\n${payload.description}\n`);
+                }
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to fetch epic detail for ID: ${flags.id}`, err);
+        }
+    }
+}

package/dist/commands/epic/update.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { updateEpic } from '../../generated/api/sdk.gen.js';
+import { zUpdateEpicResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class EpicUpdate extends BaseCommand {
+    static description = 'Update an epic';
+    static examples = [
+        '<%= config.bin %> epic:update --id <uuid> --status IN_DEVELOPMENT',
+        '<%= config.bin %> epic:update --id <uuid> --status COMPLETE --title "New Title"',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        id: Flags.string({
+            description: 'Epic ID (UUID)',
+            required: true,
+        }),
+        status: Flags.string({
+            description: 'New status (BACKLOG|NOT_STARTED|IN_PLANNING|READY_FOR_DEVELOPMENT|IN_DEVELOPMENT|BLOCKED|REVIEW|COMPLETE)',
+            options: ['BACKLOG', 'NOT_STARTED', 'IN_PLANNING', 'READY_FOR_DEVELOPMENT', 'IN_DEVELOPMENT', 'BLOCKED', 'REVIEW', 'COMPLETE'],
+        }),
+        title: Flags.string({
+            description: 'New title',
+        }),
+        description: Flags.string({
+            description: 'New description',
+        }),
+        priority: Flags.string({
+            description: 'New priority',
+        }),
+        'roadmap-status': Flags.string({
+            description: 'New roadmap status (now|next|later)',
+            options: ['now', 'next', 'later'],
+        }),
+        force: Flags.boolean({
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(EpicUpdate);
+        const projectId = await this.getProjectIdOrExit();
+        await this.renderHeader('ready', 'compact');
+        const body = {};
+        if (flags.status !== undefined)
+            body.status = flags.status;
+        if (flags.title !== undefined)
+            body.label = flags.title;
+        if (flags.description !== undefined)
+            body.description = flags.description;
+        if (flags.priority !== undefined)
+            body.priority = flags.priority;
+        if (flags['roadmap-status'] !== undefined)
+            body.roadmap_status = flags['roadmap-status'];
+        if (Object.keys(body).length === 0) {
+            const message = 'At least one field must be provided to update (--status, --title, --description, --priority, --roadmap-status)';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'MISSING_INPUT' });
+            }
+            else {
+                this.error(message);
+            }
+        }
+        const confirmed = await this.confirmAction(`Update epic ${flags.id}?`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed)
+            return;
+        const payload = {
+            path: {
+                projectId,
+                epicId: flags.id,
+            },
+            body,
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        const response = await this.withSpinner(`Updating epic ${flags.id}...`, () => updateEpic({
+            client,
+            ...payload,
+        }));
+        const { data, error } = response;
+        try {
+            const validated = validateResponse(data, error, zUpdateEpicResponse);
+            const epic = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(epic, { source: 'epic update', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Epic ${flags.id} updated successfully!` }));
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to update epic: ${flags.id}`, err);
+        }
+    }
+}

package/dist/commands/feature/index.js

@@ -0,0 +1,2 @@
+export { default as list } from './list.js';
+export { default as show } from './show.js';

package/dist/commands/feature/list.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { listFeatures } from '../../generated/api/sdk.gen.js';
+import { zListFeaturesResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class FeatureList extends BaseCommand {
+    static description = 'List features for the current project';
+    static examples = [
+        '<%= config.bin %> feature:list',
+        '<%= config.bin %> feature:list --roadmap next --json',
+        '<%= config.bin %> feature:list --status IN_DEVELOPMENT',
+    ];
+    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 (e.g. BACKLOG, IN_DEVELOPMENT, COMPLETE)',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(FeatureList);
+        await this.renderHeader('ready', 'compact');
+        // 1. Resolve Auth and Config
+        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;
+        }
+        // 2. Call SDK
+        try {
+            const response = await this.withSpinner('Fetching features...', () => listFeatures({
+                client,
+                path: {
+                    projectId: config.project_id,
+                },
+                query: {
+                    ...(flags.roadmap ? { roadmap: flags.roadmap } : {}),
+                    ...(flags.status ? { status: flags.status } : {}),
+                },
+            }));
+            const { data, error } = response;
+            const validated = validateResponse(data, error, zListFeaturesResponse);
+            const items = validated.data;
+            const metadata = validated.metadata;
+            // 3. Dual output
+            if (this.isJsonMode) {
+                this.outputJson(items, { source: 'feature list' });
+            }
+            else {
+                await this.renderInk(_jsx(DataTable, { data: items, columns: [
+                        { key: 'label', header: 'Title', minWidth: 20 },
+                        { key: 'id', header: 'ID' },
+                        { key: 'status', header: 'Status', color: 'auto' },
+                        { key: 'roadmap_status', header: 'Roadmap' },
+                        { key: 'priority', header: 'Priority' },
+                    ], title: `Features in ${config.project_id}${flags.roadmap ? ` (${flags.roadmap})` : ''}`, emptyMessage: `No features found${flags.roadmap ? ` for roadmap: ${flags.roadmap}` : ''}` }));
+                if (this.isInteractiveMode) {
+                    if (items.length > 0) {
+                        const options = items.map((item) => ({
+                            label: item.label || item.id,
+                            value: item.id,
+                            description: item.status || '',
+                        }));
+                        const selectedId = await this.selectOption('Select a feature for details:', options, { headerVariant: 'compact' });
+                        if (selectedId) {
+                            const { default: chalk } = await import('chalk');
+                            this.log(`\n  🚀 Run: ${chalk.cyan(`4ge feature show ${selectedId}`)}\n`);
+                        }
+                    }
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+}