@4ge/cli 0.1.0

package/dist/commands/project/create.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { createProject } from '../../generated/api/sdk.gen.js';
+import { zCreateProjectResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class ProjectCreate extends BaseCommand {
+    static description = 'Create a new project';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        workspace: Flags.string({
+            description: 'The workspace ID to create the project in',
+            required: true,
+        }),
+        name: Flags.string({
+            description: 'Project name',
+            required: true,
+        }),
+        description: Flags.string({
+            description: 'Project description',
+        }),
+        'problem-statement': Flags.string({
+            description: 'Problem statement',
+        }),
+        'project-rules': Flags.string({
+            description: 'Project rules',
+        }),
+        template: Flags.string({
+            description: 'Template ID (maps to project_type_id)',
+        }),
+        force: Flags.boolean({
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> project:create --workspace <uuid> --name "My Project"',
+        '<%= config.bin %> project:create --workspace <uuid> --name "My Project" --template <uuid>',
+    ];
+    async run() {
+        const { flags } = await this.parse(ProjectCreate);
+        await this.renderHeader('ready', 'compact');
+        const confirmed = await this.confirmAction(`Create new project "${flags.name}"?`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed)
+            return;
+        const payload = {
+            body: {
+                name: flags.name,
+                workspace_id: flags.workspace,
+                ...(flags.description !== undefined && { description: flags.description }),
+                ...(flags['problem-statement'] !== undefined && { problem_statement: flags['problem-statement'] }),
+                ...(flags['project-rules'] !== undefined && { project_rules: flags['project-rules'] }),
+                ...(flags.template !== undefined && { project_type_id: flags.template }),
+            },
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        const { data, error } = await this.withSpinner('Creating project...', () => createProject({
+            client,
+            ...payload,
+        }));
+        try {
+            const validated = validateResponse(data, error, zCreateProjectResponse);
+            const project = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(project, { source: 'project create', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Created project "${project.name}" (id: ${project.id}) in workspace (id: ${flags.workspace})` }));
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('Failed to create project', err);
+        }
+    }
+}

package/dist/commands/project/index.js

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../base.js';
+export default class Project extends BaseCommand {
+    static description = 'Interact with projects';
+    static hidden = true;
+    async run() {
+        await this.renderHeader('ready', 'compact');
+        this.log('Use `4ge project list` to list projects.');
+    }
+}

package/dist/commands/project/info.js

@@ -0,0 +1,74 @@
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { getProjectDetail } from '../../generated/api/sdk.gen.js';
+import { zGetProjectDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import chalk from 'chalk';
+export default class ProjectInfo extends BaseCommand {
+    static description = 'Get detailed information about the current project';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static examples = [
+        '<%= config.bin %> project:info',
+        '<%= config.bin %> project:info --json',
+    ];
+    async run() {
+        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 client = await this.getClient();
+        try {
+            const { data, error } = await this.withRetry(() => getProjectDetail({
+                client,
+                path: { projectId: config.project_id },
+            }));
+            const validated = validateResponse(data, error, zGetProjectDetailResponse);
+            const p = validated.data;
+            // 3. Output
+            if (this.isJsonMode) {
+                this.outputJson(p, {
+                    source: 'project info',
+                });
+            }
+            else {
+                this.log('--- Project Information ---');
+                const rows = [
+                    ['Name', p.name],
+                    ['ID', p.id],
+                    ['Status', p.status?.toUpperCase()],
+                    ['Description', p.description || '-'],
+                    ['Problem Statement', p.problem_statement || '-'],
+                    ['Project Rules', p.project_rules || '-'],
+                    ['Workspace ID', p.workspace_id],
+                    ['Project Type ID', p.project_type_id],
+                    ['Created At', p.created_at ? new Date(p.created_at).toLocaleString() : '-'],
+                    ['Updated At', p.updated_at ? new Date(p.updated_at).toLocaleString() : '-'],
+                ];
+                for (const [key, value] of rows) {
+                    this.log(`${chalk.blue((key ?? '').padEnd(20))}: ${value}`);
+                }
+            }
+        }
+        catch (err) {
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({
+                    message: err.message || 'An unexpected error occurred',
+                    code: 'UNKNOWN_ERROR',
+                });
+            }
+            else {
+                this.error(err.message || 'An unexpected error occurred');
+            }
+        }
+    }
+}

package/dist/commands/project/list.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BaseCommand } from '../../base.js';
+import { readConfig } from '../../core/config/index.js';
+import { listProjects } from '../../generated/api/sdk.gen.js';
+import { zListProjectsResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class ProjectList extends BaseCommand {
+    static description = 'List all projects in the current workspace';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static examples = [
+        '<%= config.bin %> project:list',
+        '<%= config.bin %> project:list --json',
+    ];
+    async run() {
+        const config = await readConfig();
+        await this.renderHeader('ready', 'compact');
+        if (!config?.workspace_id) {
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({
+                    message: 'Project not initialized. Run `4ge init` first to set workspace context.',
+                    code: 'NOT_INITIALIZED',
+                });
+            }
+            else {
+                this.error('Project not initialized. Run `4ge init` first to set workspace context.');
+            }
+            return;
+        }
+        const client = await this.getClient();
+        try {
+            const projects = await this.withSpinner('Fetching projects...', () => listProjects({ client }));
+            const { data, error } = projects;
+            const validated = validateResponse(data, error, zListProjectsResponse);
+            const items = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(items, {
+                    source: 'project list',
+                });
+            }
+            else {
+                await this.renderInk(_jsx(DataTable, { data: items, columns: [
+                        { key: 'name', header: 'Name', minWidth: 20 },
+                        { key: 'id', header: 'ID' },
+                        { key: 'status', header: 'Status', color: 'auto' },
+                        {
+                            key: 'created_at',
+                            header: 'Created',
+                            format: (v) => (v ? new Date(v).toLocaleDateString() : '-'),
+                        },
+                    ], title: `Projects in ${config.workspace_name || config.workspace_id}`, emptyMessage: "No projects found." }));
+                if (this.isInteractiveMode) {
+                    if (items.length > 0) {
+                        const options = items.map((item) => ({
+                            label: item.name || item.id,
+                            value: item.id,
+                            description: item.status || '',
+                        }));
+                        const selectedId = await this.selectOption('Select a project for details:', options, { headerVariant: 'compact' });
+                        if (selectedId) {
+                            const { default: chalk } = await import('chalk');
+                            this.log(`\n  🚀 Run: ${chalk.cyan(`4ge project 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/project/pull.js

@@ -0,0 +1,127 @@
+import { BaseCommand } from '../../base.js';
+import { readConfig, getAssetPath, getProjectDocsDir } from '../../core/config/index.js';
+import { getProjectDetail } from '../../generated/api/sdk.gen.js';
+import { zGetProjectDetailResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { generateProblemStatementMd, generateProjectRulesMd, generateReadmeMd, } from '../../core/project/markdown.js';
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export default class ProjectPull extends BaseCommand {
+    static description = 'Pull project metadata from the cloud and save it locally';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        save: Flags.boolean({
+            description: 'Force saving to disk even in --json mode',
+            default: false,
+        }),
+        stdout: Flags.boolean({
+            description: 'Print to terminal without saving (human mode only)',
+            default: false,
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> project:pull',
+        '<%= config.bin %> project:pull --stdout',
+        '<%= config.bin %> project:pull --json',
+        '<%= config.bin %> project:pull --json --save',
+    ];
+    async run() {
+        const { flags } = await this.parse(ProjectPull);
+        // 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');
+        // 1. Resolve Auth and Config
+        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;
+        }
+        // 2. Call API
+        try {
+            const { data, error } = await this.withRetry(() => getProjectDetail({
+                client,
+                path: { projectId: config.project_id },
+            }));
+            const validated = validateResponse(data, error, zGetProjectDetailResponse);
+            const projectData = validated.data;
+            const savePath = getAssetPath('project.json');
+            // 3. Output Logic
+            if (this.isJsonMode) {
+                this.outputJson(projectData);
+                if (flags.save) {
+                    await this.saveToFile(savePath, projectData);
+                    await this.saveMarkdownFiles(projectData, false);
+                }
+            }
+            else if (flags.stdout) {
+                const problemStatement = generateProblemStatementMd(projectData);
+                const projectRules = generateProjectRulesMd(projectData);
+                const filesGenerated = [];
+                if (problemStatement)
+                    filesGenerated.push('problem-statement.md');
+                if (projectRules)
+                    filesGenerated.push('project-rules.md');
+                const readme = generateReadmeMd(projectData, filesGenerated);
+                this.log(readme);
+                if (problemStatement) {
+                    this.log('\n---\n');
+                    this.log(problemStatement);
+                }
+                if (projectRules) {
+                    this.log('\n---\n');
+                    this.log(projectRules);
+                }
+            }
+            else {
+                await this.saveToFile(savePath, projectData);
+                this.log(`${chalk.green('✓')} Project metadata saved to .4ge/assets/project.json`);
+                await this.saveMarkdownFiles(projectData, true);
+            }
+        }
+        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');
+    }
+    async saveMarkdownFiles(project, verbose) {
+        const projectDir = getProjectDocsDir();
+        await fs.mkdir(projectDir, { recursive: true });
+        const filesToGenerate = [
+            { name: 'problem-statement.md', content: generateProblemStatementMd(project) },
+            { name: 'project-rules.md', content: generateProjectRulesMd(project) },
+        ];
+        const actualFiles = [];
+        for (const { name, content } of filesToGenerate) {
+            if (content) {
+                await fs.writeFile(path.join(projectDir, name), content, 'utf-8');
+                actualFiles.push(name);
+                if (verbose) {
+                    this.log(`${chalk.green('✓')} Created .4ge/assets/project/${name}`);
+                }
+            }
+        }
+        const readmeContent = generateReadmeMd(project, actualFiles);
+        await fs.writeFile(path.join(projectDir, 'README.md'), readmeContent, 'utf-8');
+        if (verbose) {
+            this.log(`${chalk.green('✓')} Created .4ge/assets/project/README.md`);
+        }
+    }
+}

package/dist/commands/project/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 { updateProject } from '../../generated/api/sdk.gen.js';
+import { zUpdateProjectResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { readConfig } from '../../core/config/parser.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class ProjectUpdate extends BaseCommand {
+    static description = 'Update the currently initialized project';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        name: Flags.string({
+            description: 'New project name',
+        }),
+        description: Flags.string({
+            description: 'New description',
+        }),
+        'problem-statement': Flags.string({
+            description: 'New problem statement',
+        }),
+        'project-rules': Flags.string({
+            description: 'New project rules',
+        }),
+        template: Flags.string({
+            description: 'New template ID (maps to project_type_id)',
+        }),
+        force: Flags.boolean({
+            description: 'Skip confirmation prompt',
+            default: false,
+        }),
+    };
+    static examples = [
+        '<%= config.bin %> project:update --name "New Project Name"',
+        '<%= config.bin %> project:update --description "New description"',
+        '<%= config.bin %> project:update --template <uuid>',
+    ];
+    async run() {
+        const { flags } = await this.parse(ProjectUpdate);
+        const config = await readConfig();
+        if (!config?.project_id) {
+            const message = 'No project initialized. Run `4ge init` first.';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'NOT_INITIALIZED' });
+            }
+            else {
+                this.error(message);
+            }
+            return;
+        }
+        await this.renderHeader('ready', 'compact');
+        const body = {
+            ...(flags.name !== undefined && { name: flags.name }),
+            ...(flags.description !== undefined && { description: flags.description }),
+            ...(flags['problem-statement'] !== undefined && { problem_statement: flags['problem-statement'] }),
+            ...(flags['project-rules'] !== undefined && { project_rules: flags['project-rules'] }),
+            ...(flags.template !== undefined && { project_type_id: flags.template }),
+        };
+        // Check if at least one field is provided for update
+        if (Object.keys(body).length === 0) {
+            const message = 'Provide at least one field to update';
+            if (this.isJsonMode) {
+                this.outputErrorAndExit({ message, code: 'MISSING_INPUT' });
+            }
+            else {
+                this.error(message);
+            }
+            return;
+        }
+        const confirmed = await this.confirmAction(`Update project "${config.project_id}"?`, flags.force, { headerVariant: 'compact' });
+        if (!confirmed)
+            return;
+        const payload = {
+            path: { projectId: config.project_id },
+            body,
+        };
+        if (this.isDryRun) {
+            await this.handleDryRun(payload);
+            return;
+        }
+        const client = await this.getClient();
+        const { data, error } = await this.withSpinner('Updating project...', () => updateProject({
+            client,
+            ...payload,
+        }));
+        try {
+            const validated = validateResponse(data, error, zUpdateProjectResponse);
+            const project = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(project, { source: 'project update', ...metadata });
+            }
+            else {
+                await this.renderInk(_jsx(SuccessMessage, { message: `Updated project "${project.name}" (id: ${project.id})` }));
+                if (this.isInteractiveMode && metadata?.action_hints) {
+                    await this.handleActionHints(metadata.action_hints);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(`Failed to update project: ${config.project_id}`, err);
+        }
+    }
+}

package/dist/commands/root.js

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../base.js';
+export default class Root extends BaseCommand {
+    static hidden = true;
+    static description = 'A Universal Interface for 4ge Resources';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async run() {
+        // If no subcommand, show help
+        await this.renderHeader('ready', 'compact');
+        await this.config.runCommand('help');
+    }
+}

package/dist/commands/skill/index.js

@@ -0,0 +1,8 @@
+import { Command } from '@oclif/core';
+export default class SkillIndex extends Command {
+    static description = 'Install and manage the 4ge CLI agent skill';
+    static hidden = true;
+    async run() {
+        this.log('Use `4ge skill:install` to install the 4ge CLI skill for AI agents.');
+    }
+}

package/dist/commands/skill/install.js

@@ -0,0 +1,71 @@
+import { Flags } from '@oclif/core';
+import React from 'react';
+import { BaseCommand } from '../../base.js';
+import { installSkill } from '../../core/skill/installer.js';
+import { isKnownAgent } from '../../core/skill/paths.js';
+import { SuccessMessage } from '../../ui/index.js';
+export default class SkillInstall extends BaseCommand {
+    static description = 'Install the 4ge CLI agent skill into the current project (or globally). Mirrors the `npx skills` directory convention.';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        agent: Flags.string({
+            description: 'Target agent harness (default: universal -> .agents/skills/)',
+            options: ['universal', 'pi', 'claude-code', 'cursor', 'codex', 'gemini-cli', 'windsurf', 'continue'],
+        }),
+        global: Flags.boolean({
+            description: 'Install to user scope (~/.<agent>/skills/) instead of project scope',
+            default: false,
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite an existing skill file',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SkillInstall);
+        if (flags.agent && !isKnownAgent(flags.agent)) {
+            this.outputErrorAndExit({
+                message: `Unknown agent "${flags.agent}".`,
+                code: 'UNKNOWN_AGENT',
+                hint: 'Use --help to see supported agents.',
+            });
+            return;
+        }
+        const force = !!flags.force;
+        const scope = flags.global ? 'user' : 'project';
+        const agent = flags.agent ?? 'universal';
+        try {
+            const result = await installSkill({ agent, scope, force });
+            if (this.isJsonMode) {
+                this.outputJson({
+                    path: result.path,
+                    agent: result.agent,
+                    scope: result.scope,
+                    overwritten: result.overwritten,
+                });
+                return;
+            }
+            await this.renderInk(React.createElement(SuccessMessage, {
+                message: result.overwritten
+                    ? `Skill overwritten at ${result.path}`
+                    : `Skill installed at ${result.path}`,
+            }));
+            this.log(`Agent:   ${result.agent}`);
+            this.log(`Scope:   ${result.scope}`);
+            this.log(`Path:    ${result.path}`);
+            if (!result.overwritten) {
+                this.log('');
+                this.log('Reload your agent to pick up the new skill.');
+            }
+        }
+        catch (err) {
+            const message = err?.message ?? String(err);
+            const isExists = /already exists/i.test(message);
+            this.outputErrorAndExit({
+                message,
+                code: isExists ? 'SKILL_EXISTS' : 'SKILL_INSTALL_FAILED',
+                hint: isExists ? 'Re-run with --force to overwrite.' : undefined,
+            });
+        }
+    }
+}

package/dist/commands/story/index.js

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

package/dist/commands/story/list.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { listStories } from '../../generated/api/sdk.gen.js';
+import { zListStoriesResponse } from '../../generated/api/zod.gen.js';
+import { validateResponse } from '../../core/api/index.js';
+import { DataTable } from '../../ui/index.js';
+export default class StoryList extends BaseCommand {
+    static description = 'List stories for the current project';
+    static examples = [
+        '<%= config.bin %> story:list',
+        '<%= config.bin %> story:list --roadmap next --json',
+        '<%= config.bin %> story: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(StoryList);
+        await this.renderHeader('ready', 'compact');
+        // 1. Resolve Auth and Config
+        const client = await this.getClient();
+        const projectId = await this.getProjectIdOrExit();
+        // 2. Call SDK
+        try {
+            const response = await this.withSpinner('Fetching stories...', () => listStories({
+                client,
+                path: {
+                    projectId,
+                },
+                query: {
+                    ...(flags.roadmap ? { roadmap: flags.roadmap } : {}),
+                    ...(flags.status ? { status: flags.status } : {}),
+                },
+            }));
+            const { data, error } = response;
+            const validated = validateResponse(data, error, zListStoriesResponse);
+            const items = validated.data;
+            const metadata = validated.metadata;
+            if (this.isJsonMode) {
+                this.outputJson(items, { source: 'story 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: 'parent_id', header: 'Epic ID' },
+                    ], title: `Stories in ${projectId}${flags.roadmap ? ` (${flags.roadmap})` : ''}`, emptyMessage: `No stories 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 story for details:', options, { headerVariant: 'compact' });
+                        if (selectedId) {
+                            const { default: chalk } = await import('chalk');
+                            this.log(`\n  🚀 Run: ${chalk.cyan(`4ge story show ${selectedId}`)}\n`);
+                        }
+                    }
+                    if (metadata?.action_hints) {
+                        await this.handleActionHints(metadata.action_hints);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.handleError('An unexpected error occurred', err);
+        }
+    }
+}