@4ge/cli 0.1.0

package/dist/commands/feature/pull.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { getCollectionDir } from '../../core/config/index.js';
+import { resolveRecursive, resolveRoadmapFilter } from '../../core/config/defaults.js';
+import { getFeatureDetail, getFeatureTree } from '../../generated/api/sdk.gen.js';
+import { zGetFeatureTreeResponse, zGetFeatureDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export default class FeaturePull extends BaseCommand {
+    static description = 'Download feature details';
+    static examples = [
+        '<%= config.bin %> feature:pull --id <uuid>',
+        '<%= config.bin %> feature:pull --id <uuid> --json',
+        '<%= config.bin %> feature:pull --id <uuid> --recursive',
+        '<%= config.bin %> feature:pull --id <uuid> --recursive --roadmap now --status BACKLOG',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        id: Flags.string({
+            description: 'Feature ID',
+            required: true,
+        }),
+        recursive: Flags.boolean({
+            description: 'Pull full hierarchy tree instead of just the feature 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(FeaturePull);
+        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 projectId = await this.getProjectIdOrExit();
+        const isRecursive = resolveRecursive(flags.recursive, this.localConfig);
+        const spinnerMsg = isRecursive ? `Pulling feature ${flags.id} tree...` : `Pulling feature ${flags.id}...`;
+        const roadmapFilter = resolveRoadmapFilter(flags.roadmap, this.localConfig);
+        const response = await this.withSpinner(spinnerMsg, () => {
+            if (isRecursive) {
+                return getFeatureTree({
+                    client,
+                    path: {
+                        projectId,
+                        featureId: flags.id,
+                    },
+                    query: {
+                        ...(roadmapFilter ? { roadmap: roadmapFilter } : {}),
+                        ...(flags.status ? { status: flags.status } : {}),
+                    },
+                });
+            }
+            else {
+                return getFeatureDetail({
+                    client,
+                    path: {
+                        projectId,
+                        featureId: flags.id,
+                    },
+                });
+            }
+        });
+        const { data, error } = response;
+        try {
+            let feature;
+            let metadata;
+            if (isRecursive) {
+                const validated = validateResponse(data, error, zGetFeatureTreeResponse);
+                feature = validated.data;
+                metadata = validated.metadata;
+            }
+            else {
+                const validated = validateResponse(data, error, zGetFeatureDetailResponse);
+                feature = validated.data;
+                metadata = validated.metadata;
+            }
+            const savePath = path.join(getCollectionDir('features'), `${flags.id}.json`);
+            if (this.isJsonMode) {
+                this.outputJson(feature);
+                if (flags.save) {
+                    await this.saveToFile(savePath, feature);
+                }
+            }
+            else if (flags.stdout) {
+                this.log(JSON.stringify(feature, null, 2));
+            }
+            else {
+                await this.saveToFile(savePath, feature);
+                await this.renderInk(_jsx(SuccessMessage, { message: `Feature saved to .4ge/assets/features/${flags.id}.json` }));
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to pull feature: ${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/feature/show.js

@@ -0,0 +1,60 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { getFeatureDetail } from '../../generated/api/sdk.gen.js';
+import { zGetFeatureDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+export default class FeatureShow extends BaseCommand {
+    static description = 'Show detailed information for a specific feature';
+    static examples = [
+        '<%= config.bin %> feature:show --id <uuid>',
+        '<%= config.bin %> feature:show --id <uuid> --json',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        id: Flags.string({
+            description: 'Feature ID',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(FeatureShow);
+        const client = await this.getClient();
+        const projectId = await this.getProjectIdOrExit();
+        await this.renderHeader('ready', 'compact');
+        const response = await this.withSpinner(`Fetching feature ${flags.id}...`, () => getFeatureDetail({
+            client,
+            path: {
+                projectId,
+                featureId: flags.id
+            },
+        }));
+        const { data, error } = response;
+        try {
+            const validated = validateResponse(data, error, zGetFeatureDetailResponse);
+            const feature = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(feature, { source: 'feature show' });
+            }
+            else {
+                this.log(`\nFeature: ${feature.label}`);
+                this.log(`ID:      ${feature.id}`);
+                this.log(`Status:  ${feature.status}`);
+                this.log(`Roadmap: ${feature.roadmap_status || 'N/A'}`);
+                this.log(`Priority: ${feature.priority || 'N/A'}`);
+                if (feature.parent_id) {
+                    this.log(`Parent ID: ${feature.parent_id}`);
+                }
+                if (feature.description) {
+                    this.log(`\nDescription:\n${feature.description}\n`);
+                }
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to fetch feature detail for ID: ${flags.id}`, err);
+        }
+    }
+}

package/dist/commands/feature/update.js

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

package/dist/commands/idea/create.js

@@ -0,0 +1,88 @@
+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 { createIdea } from '../../generated/api/sdk.gen.js';
+import { zCreateIdeaResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class IdeaCreate extends BaseCommand {
+    static description = 'Create a new idea in a workspace';
+    static examples = [
+        '<%= config.bin %> idea:create --workspace <id> --title "My Great Idea"',
+        '<%= config.bin %> idea:create --workspace <id> --title "My Great Idea" --description "Detailed description"',
+    ];
+    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: 'Idea title',
+            required: true,
+            char: 't',
+        }),
+        description: Flags.string({
+            description: 'Idea description',
+            char: 'd',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IdeaCreate);
+        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');
+        const confirmed = await this.confirmAction(`Create idea "${flags.title}" in workspace ${workspaceId}?`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed) {
+            this.log('Operation cancelled.');
+            return;
+        }
+        const payload = {
+            path: {
+                workspaceId,
+            },
+            body: {
+                title: flags.title,
+                description: flags.description,
+            },
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        try {
+            const { data, error } = await this.withSpinner('Creating idea...', () => createIdea({
+                client,
+                ...payload,
+            }));
+            const validated = validateResponse(data, error, zCreateIdeaResponse);
+            const result = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(result, { source: 'idea:create', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Idea created successfully with ID: ${result.id}` }));
+                if (this.isInteractiveMode) {
+                    const { default: chalk } = await import('chalk');
+                    this.log(`\n  🚀 Next steps:`);
+                    this.log(`  - Show details: ${chalk.cyan(`4ge idea:show ${result.id} --workspace ${workspaceId}`)}`);
+                    this.log(`  - Update: ${chalk.cyan(`4ge idea:update ${result.id} --workspace ${workspaceId}`)}`);
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('Failed to create idea', err);
+        }
+    }
+}

package/dist/commands/idea/graduate.js

@@ -0,0 +1,89 @@
+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 { graduateIdea } from '../../generated/api/sdk.gen.js';
+import { zGraduateIdeaResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class IdeaGraduate extends BaseCommand {
+    static description = 'Graduate an idea into a full project';
+    static examples = [
+        '<%= config.bin %> idea:graduate <id> --workspace <workspaceId>',
+        '<%= config.bin %> idea:graduate <id> --workspace <workspaceId> --name "New Project Name"',
+    ];
+    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',
+        }),
+        name: Flags.string({
+            description: 'Project name (defaults to idea title if not provided)',
+            char: 'n',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(IdeaGraduate);
+        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');
+        const confirmed = await this.confirmAction(`Graduate idea ${args.id} into a new project? This is a significant action.`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed) {
+            this.log('Operation cancelled.');
+            return;
+        }
+        const payload = {
+            path: {
+                workspaceId,
+                ideaId: args.id,
+            },
+            body: {
+                project_name: flags.name,
+            },
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        try {
+            const { data, error } = await this.withSpinner('Graduating idea...', () => graduateIdea({
+                client,
+                ...payload,
+            }));
+            const validated = validateResponse(data, error, zGraduateIdeaResponse);
+            const result = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(result, { source: 'idea:graduate', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Idea graduated successfully! New project created: ${result.name} (${result.id})` }));
+                if (this.isInteractiveMode) {
+                    const { default: chalk } = await import('chalk');
+                    this.log(`\n  🚀 Next steps:`);
+                    this.log(`  - Project info: ${chalk.cyan(`4ge project info --id ${result.id}`)}`);
+                    this.log(`  - Pull plan:    ${chalk.cyan(`4ge plan pull --project ${result.id}`)}`);
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to graduate idea: ${args.id}`, err);
+        }
+    }
+}

package/dist/commands/idea/index.js

@@ -0,0 +1,5 @@
+export { default as IdeaList } from './list.js';
+export { default as IdeaShow } from './show.js';
+export { default as IdeaCreate } from './create.js';
+export { default as IdeaUpdate } from './update.js';
+export { default as IdeaGraduate } from './graduate.js';

package/dist/commands/idea/list.js

@@ -0,0 +1,83 @@
+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 { listIdeas } from '../../generated/api/sdk.gen.js';
+import { zListIdeasResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class IdeaList extends BaseCommand {
+    static description = 'List ideas in a workspace';
+    static examples = [
+        '<%= config.bin %> idea:list --workspace <workspaceId>',
+        '<%= config.bin %> idea:list --workspace <workspaceId> --status backlog',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            description: 'Workspace ID',
+            char: 'w',
+        }),
+        status: Flags.string({
+            description: 'Filter by status',
+            char: 's',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IdeaList);
+        await this.renderHeader('ready', 'compact');
+        const client = await this.getClient();
+        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;
+        }
+        try {
+            const response = await this.withSpinner('Fetching ideas...', () => listIdeas({
+                client,
+                path: {
+                    workspaceId,
+                },
+            }));
+            const { data, error } = response;
+            const validated = validateResponse(data, error, zListIdeasResponse);
+            let items = validated.data;
+            const metadata = validated.metadata;
+            if (flags.status) {
+                items = items.filter((item) => item.status?.toLowerCase() === flags.status?.toLowerCase());
+            }
+            if (this.isJsonMode) {
+                this.outputJson(items, { source: 'idea:list' });
+            }
+            else {
+                await this.renderInk(_jsx(DataTable, { data: items, columns: [
+                        { key: 'id', header: 'ID' },
+                        { key: 'title', header: 'Title', minWidth: 30 },
+                        { key: 'status', header: 'Status', color: 'auto' },
+                        { key: 'created_at', header: 'Created At' },
+                    ], title: `Ideas in workspace ${workspaceId}`, emptyMessage: flags.status ? `No ideas found with status: ${flags.status}` : 'No ideas found.' }));
+                if (this.isInteractiveMode) {
+                    if (items.length > 0) {
+                        const options = items.map((item) => ({
+                            label: item.title || item.id,
+                            value: item.id,
+                            description: item.status || '',
+                        }));
+                        const selectedId = await this.selectOption('Select an idea for details:', options, { headerVariant: 'compact' });
+                        if (selectedId) {
+                            const { default: chalk } = await import('chalk');
+                            this.log(`\n  🚀 Run: ${chalk.cyan(`4ge idea:show ${selectedId} --workspace ${workspaceId}`)}\n`);
+                        }
+                    }
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+}

package/dist/commands/idea/show.js

@@ -0,0 +1,86 @@
+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 { listIdeas } from '../../generated/api/sdk.gen.js';
+import { zListIdeasResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DetailView } from '../../ui/index.js';
+export default class IdeaShow extends BaseCommand {
+    static description = 'Show detailed information for a specific idea';
+    static examples = [
+        '<%= config.bin %> idea:show <id> --workspace <workspaceId>',
+        '<%= config.bin %> idea:show <id> --workspace <workspaceId> --json',
+    ];
+    static args = {
+        id: Args.string({
+            description: 'Idea ID',
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            description: 'Workspace ID',
+            char: 'w',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(IdeaShow);
+        const client = await this.getClient();
+        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');
+        try {
+            // NOTE: the SDK does not yet expose a direct getIdeaDetail endpoint.
+            // Using listIdeas + client-side filter as a workaround. The response is
+            // still validated against zListIdeasResponse so the envelope contract is
+            // enforced at the boundary.
+            const { data, error } = await this.withSpinner(`Fetching idea ${args.id}...`, () => listIdeas({
+                client,
+                path: { workspaceId },
+            }));
+            const validated = validateResponse(data, error, zListIdeasResponse);
+            const items = validated.data;
+            const metadata = validated.metadata;
+            const payload = items.find((item) => item.id === args.id);
+            if (!payload) {
+                this.handleError(`Idea not found: ${args.id}`, { code: 'NOT_FOUND' });
+                return;
+            }
+            if (this.isJsonMode) {
+                this.outputJson(payload, { source: 'idea:show' });
+            }
+            else {
+                await this.renderInk(_jsx(DetailView, { title: `Idea: ${payload.title}`, rows: [
+                        { label: 'ID', value: payload.id },
+                        { label: 'Status', value: payload.status, color: 'auto' },
+                        { label: 'Workspace', value: payload.workspace_id },
+                        { label: 'Project ID', value: payload.converted_project_id },
+                        { label: 'Created At', value: payload.created_at },
+                        { label: 'Updated At', value: payload.updated_at },
+                        { label: 'Description', value: payload.description },
+                    ] }));
+                if (this.isInteractiveMode) {
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                    else {
+                        // Provide some default hints if metadata doesn't have them
+                        const { default: chalk } = await import('chalk');
+                        this.log(`\n  🚀 Actions:`);
+                        this.log(`  - Update: ${chalk.cyan(`4ge idea:update ${payload.id} --workspace ${workspaceId}`)}`);
+                        this.log(`  - Graduate: ${chalk.cyan(`4ge idea:graduate ${payload.id} --workspace ${workspaceId}`)}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to fetch idea ${args.id}`, err);
+        }
+    }
+}