@output.ai/cli 0.0.0 → 0.0.2

package/dist/commands/agents/init.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {};
+    static flags: {
+        'agent-provider': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private prepareTemplateVariables;
+    private processMappings;
+    private ensureDirectoryExists;
+    private fileExists;
+    private createFromTemplate;
+    private createSymlink;
+    private copyFile;
+}

package/dist/commands/agents/init.js

@@ -0,0 +1,175 @@
+import { Command, Flags } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getTemplateDir } from '../../utils/paths.js';
+import { processTemplate } from '../../utils/template.js';
+const AGENT_CONFIGS = {
+    outputai: {
+        id: 'outputai',
+        name: 'OutputAI Core Files',
+        mappings: [
+            {
+                type: 'template',
+                from: 'AGENTS.md.template',
+                to: '.outputai/AGENTS.md'
+            },
+            {
+                type: 'template',
+                from: 'agents/workflow_planner.md.template',
+                to: '.outputai/agents/workflow_planner.md'
+            },
+            {
+                type: 'template',
+                from: 'commands/plan_workflow.md.template',
+                to: '.outputai/commands/plan_workflow.md'
+            }
+        ]
+    },
+    'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        mappings: [
+            {
+                type: 'symlink',
+                from: '.outputai/AGENTS.md',
+                to: 'CLAUDE.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/agents/workflow_planner.md',
+                to: '.claude/agents/workflow_planner.md'
+            },
+            {
+                type: 'symlink',
+                from: '.outputai/commands/plan_workflow.md',
+                to: '.claude/commands/plan_workflow.md'
+            }
+        ]
+    }
+};
+export default class Init extends Command {
+    static description = 'Initialize agent configuration files for AI assistant integration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --agent-provider claude-code',
+        '<%= config.bin %> <%= command.id %> --force'
+    ];
+    static args = {};
+    static flags = {
+        'agent-provider': Flags.string({
+            description: 'Specify the coding agent provider',
+            default: AGENT_CONFIGS['claude-code'].id,
+            options: [AGENT_CONFIGS['claude-code'].id]
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Overwrite existing files',
+            default: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        this.log('Initializing agent configuration for Claude Code...');
+        try {
+            const variables = this.prepareTemplateVariables();
+            await this.processMappings(AGENT_CONFIGS.outputai, variables, flags.force);
+            await this.processMappings(AGENT_CONFIGS[flags['agent-provider']], variables, flags.force);
+            this.log('✅ Agent configuration initialized successfully!');
+            this.log('');
+            this.log('Created:');
+            this.log('  • .outputai/ directory with agent and command configurations');
+            this.log('  • .claude/ directory with symlinks for Claude Code integration');
+            this.log('');
+            this.log('Claude Code will automatically detect and use these configurations.');
+        }
+        catch (error) {
+            if (error.code === 'EACCES') {
+                this.error('Permission denied. Please check file permissions and try again.');
+            }
+            this.error(`Failed to initialize agent configuration: ${error.message}`);
+        }
+    }
+    prepareTemplateVariables() {
+        return {
+            date: new Date().toLocaleDateString('en-US', {
+                year: 'numeric',
+                month: 'long',
+                day: 'numeric'
+            })
+        };
+    }
+    async processMappings(config, variables, force) {
+        for (const mapping of config.mappings) {
+            const dir = path.dirname(mapping.to);
+            await this.ensureDirectoryExists(dir);
+            if (!force && await this.fileExists(mapping.to)) {
+                this.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
+                continue;
+            }
+            switch (mapping.type) {
+                case 'template':
+                    await this.createFromTemplate(mapping.from, mapping.to, variables);
+                    break;
+                case 'symlink':
+                    await this.createSymlink(mapping.from, mapping.to);
+                    break;
+                case 'copy':
+                    await this.copyFile(mapping.from, mapping.to);
+                    break;
+            }
+        }
+    }
+    async ensureDirectoryExists(dir) {
+        try {
+            await fs.mkdir(dir, { recursive: true });
+            this.debug(`Created directory: ${dir}`);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+        }
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async createFromTemplate(template, output, variables) {
+        const templateDir = getTemplateDir('agent_instructions');
+        const templatePath = path.join(templateDir, template);
+        const content = await fs.readFile(templatePath, 'utf-8');
+        const processed = processTemplate(content, variables);
+        await fs.writeFile(output, processed, 'utf-8');
+        this.debug(`Created from template: ${output}`);
+    }
+    async createSymlink(source, target) {
+        try {
+            if (await this.fileExists(target)) {
+                await fs.unlink(target);
+            }
+            const relativePath = path.relative(path.dirname(target), source);
+            await fs.symlink(relativePath, target);
+            this.debug(`Created symlink: ${target} -> ${source}`);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOTSUP' || code === 'EPERM') {
+                this.debug(`Symlinks not supported, creating copy: ${target}`);
+                const content = await fs.readFile(source, 'utf-8');
+                await fs.writeFile(target, content, 'utf-8');
+                return;
+            }
+            throw error;
+        }
+    }
+    async copyFile(source, target) {
+        const content = await fs.readFile(source, 'utf-8');
+        await fs.writeFile(target, content, 'utf-8');
+        this.debug(`Copied file: ${source} -> ${target}`);
+    }
+}

package/dist/commands/agents/init.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/agents/init.spec.js

@@ -0,0 +1,227 @@
+/* eslint-disable no-restricted-syntax, @typescript-eslint/no-explicit-any, init-declarations */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import Init from './init.js';
+import { getTemplateDir } from '../../utils/paths.js';
+import { processTemplate } from '../../utils/template.js';
+vi.mock('node:fs/promises');
+vi.mock('node:path', async () => {
+    const actual = await vi.importActual('node:path');
+    return {
+        ...actual,
+        join: vi.fn((...args) => args.join('/')),
+        dirname: vi.fn(p => p.split('/').slice(0, -1).join('/') || '.'),
+        relative: vi.fn((from, to) => {
+            if (to === 'CLAUDE.md' && from === '.') {
+                return '.outputai/AGENTS.md';
+            }
+            if (to.includes('.outputai/agents')) {
+                return `../../.outputai/agents/${path.basename(to)}`;
+            }
+            if (to.includes('.outputai/commands')) {
+                return `../../.outputai/commands/${path.basename(to)}`;
+            }
+            return to;
+        })
+    };
+});
+vi.mock('../../utils/paths.js');
+vi.mock('../../utils/template.js');
+describe('agents init', () => {
+    let mockGetTemplateDir;
+    let mockProcessTemplate;
+    const createTestCommand = (args = []) => {
+        const cmd = new Init(args, {});
+        cmd.log = vi.fn();
+        cmd.warn = vi.fn();
+        cmd.error = vi.fn();
+        cmd.debug = vi.fn();
+        cmd.parse = vi.fn();
+        return cmd;
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+        vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        vi.mocked(fs.symlink).mockResolvedValue(undefined);
+        vi.mocked(fs.stat).mockRejectedValue({ code: 'ENOENT' });
+        vi.mocked(fs.unlink).mockResolvedValue(undefined);
+        vi.mocked(fs.readFile).mockResolvedValue('Template content with {{date}}');
+        mockGetTemplateDir = vi.mocked(getTemplateDir);
+        mockGetTemplateDir.mockReturnValue('/templates/agent_instructions');
+        mockProcessTemplate = vi.mocked(processTemplate);
+        mockProcessTemplate.mockImplementation((content, variables) => {
+            return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => variables[key] || _match);
+        });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(Init.description).toBeDefined();
+            expect(Init.description).toContain('agent configuration');
+        });
+        it('should have correct examples', () => {
+            expect(Init.examples).toBeDefined();
+            expect(Array.isArray(Init.examples)).toBe(true);
+        });
+        it('should have no required arguments', () => {
+            expect(Init.args).toBeDefined();
+            expect(Object.keys(Init.args)).toHaveLength(0);
+        });
+        it('should have appropriate flags', () => {
+            expect(Init.flags).toBeDefined();
+            expect(Init.flags.force).toBeDefined();
+        });
+    });
+    describe('directory creation', () => {
+        it('should create .outputai directory structure', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands'), expect.objectContaining({ recursive: true }));
+        });
+        it('should create .claude directory structure', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/agents'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.claude/commands'), expect.objectContaining({ recursive: true }));
+        });
+    });
+    describe('file creation from templates', () => {
+        it('should create AGENTS.md file from template', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockReadFile = vi.mocked(fs.readFile);
+            mockReadFile.mockResolvedValue('Agent instructions {{date}}');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md.template'), 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('.outputai/AGENTS.md', expect.stringContaining('Agent instructions'), 'utf-8');
+        });
+        it('should create all agent configuration files', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            const agentFiles = [
+                '.outputai/agents/workflow_planner.md'
+            ];
+            for (const file of agentFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+            }
+        });
+        it('should create all command configuration files', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            const commandFiles = [
+                '.outputai/commands/plan_workflow.md'
+            ];
+            for (const file of commandFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+            }
+        });
+    });
+    describe('symlink creation', () => {
+        it('should create symlink from CLAUDE.md to .outputai/AGENTS.md', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockImplementation(async (path) => {
+                if (typeof path === 'string' && path.startsWith('.outputai')) {
+                    return { isFile: () => true };
+                }
+                throw { code: 'ENOENT' };
+            });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith('.outputai/AGENTS.md', 'CLAUDE.md');
+        });
+        it('should create symlinks for all agent files', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), '.claude/agents/workflow_planner.md');
+        });
+        it('should create symlinks for all command files', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), '.claude/commands/plan_workflow.md');
+        });
+        it('should handle Windows by copying files when symlinks are not supported', async () => {
+            const mockSymlink = vi.mocked(fs.symlink);
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockReadFile = vi.mocked(fs.readFile);
+            mockSymlink.mockRejectedValue({ code: 'ENOTSUP' });
+            mockReadFile.mockResolvedValue('File content');
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(mockReadFile).toHaveBeenCalledWith('.outputai/AGENTS.md', 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith('CLAUDE.md', 'File content', 'utf-8');
+        });
+    });
+    describe('error handling', () => {
+        it('should handle existing directory gracefully', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockRejectedValue({ code: 'EEXIST' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+        it('should handle permission errors', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            mockMkdir.mockRejectedValue({ code: 'EACCES' });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Permission denied'));
+        });
+        it('should be idempotent (safe to run multiple times)', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            mockWriteFile.mockResolvedValue(undefined);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            await cmd.run();
+            expect(cmd.error).not.toHaveBeenCalled();
+        });
+    });
+    describe('force flag', () => {
+        it('should overwrite existing files when force flag is set', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockResolvedValue({ isFile: () => true });
+            mockWriteFile.mockResolvedValue(undefined);
+            const cmd = createTestCommand(['--force']);
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: true }, args: {} });
+            await cmd.run();
+            expect(mockWriteFile).toHaveBeenCalled();
+            expect(cmd.warn).not.toHaveBeenCalled();
+        });
+        it('should warn about existing files without force flag', async () => {
+            const mockStat = vi.mocked(fs.stat);
+            mockStat.mockResolvedValue({ isFile: () => true });
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('already exists'));
+        });
+    });
+});

package/dist/commands/workflow/generate.js

@@ -2,7 +2,7 @@ import { Args, Command, Flags } from '@oclif/core';
 import { generateWorkflow } from '../../services/workflow_generator.js';
 import { DEFAULT_OUTPUT_DIRS } from '../../utils/paths.js';
 export default class Generate extends Command {
-    static description = 'Generate a new Flow SDK workflow';
+    static description = 'Generate a new Output SDK workflow';
     static examples = [
         '<%= config.bin %> <%= command.id %> my-workflow',
         '<%= config.bin %> <%= command.id %> my-workflow --skeleton',

package/dist/commands/workflow/list.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+import { type Workflow } from '../../api/generated/api.js';
+interface WorkflowDisplay {
+    name: string;
+    description: string;
+    inputs: string;
+    outputs: string;
+}
+export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
+export default class WorkflowList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        detailed: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        filter: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private handleError;
+}
+export {};

package/dist/commands/workflow/list.js

@@ -0,0 +1,169 @@
+import { Command, Flags } from '@oclif/core';
+import Table from 'cli-table3';
+import { getWorkflowCatalog } from '../../api/generated/api.js';
+import { parseWorkflowDefinition, formatParameters } from '../../api/parser.js';
+import { config } from '../../config.js';
+const OUTPUT_FORMAT = {
+    LIST: 'list',
+    TABLE: 'table',
+    JSON: 'json'
+};
+export function parseWorkflowForDisplay(workflow) {
+    const parsed = parseWorkflowDefinition(workflow);
+    return {
+        name: parsed.name,
+        description: parsed.description || 'No description',
+        inputs: formatParameters(parsed.inputs),
+        outputs: formatParameters(parsed.outputs)
+    };
+}
+function caseInsensitiveIncludes(str, filter) {
+    return str.toLowerCase().includes(filter.toLowerCase());
+}
+function matchName(filterString) {
+    return workflow => {
+        const name = workflow.name || '';
+        return caseInsensitiveIncludes(name, filterString);
+    };
+}
+function sortWorkflowsByName(workflows) {
+    return [...workflows].sort((a, b) => {
+        const nameA = (a.name || '').toLowerCase();
+        const nameB = (b.name || '').toLowerCase();
+        return nameA.localeCompare(nameB);
+    });
+}
+function createWorkflowTable(workflows, detailed) {
+    const table = new Table({
+        head: ['Name', 'Description', 'Inputs', 'Outputs'],
+        colWidths: detailed ? [25, 40, 40, 40] : [20, 30, 25, 25],
+        wordWrap: true,
+        style: {
+            head: ['cyan']
+        }
+    });
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    sortedWorkflows.forEach(workflow => {
+        const display = parseWorkflowForDisplay(workflow);
+        if (detailed) {
+            const inputs = display.inputs.split(', ').join('\n');
+            const outputs = display.outputs.split(', ').join('\n');
+            table.push([display.name, display.description, inputs, outputs]);
+        }
+        else {
+            const maxLen = 22;
+            const inputs = display.inputs.length > maxLen ?
+                display.inputs.substring(0, maxLen) + '...' :
+                display.inputs;
+            const outputs = display.outputs.length > maxLen ?
+                display.outputs.substring(0, maxLen) + '...' :
+                display.outputs;
+            table.push([display.name, display.description, inputs, outputs]);
+        }
+    });
+    return table.toString();
+}
+function formatWorkflowsAsList(workflows) {
+    const sortedWorkflows = sortWorkflowsByName(workflows);
+    const names = sortedWorkflows.map(w => parseWorkflowForDisplay(w).name);
+    return `\nWorkflows:\n\n${names.map(name => `- ${name}`).join('\n')}`;
+}
+function formatWorkflowsAsJson(workflows) {
+    const output = {
+        workflows: workflows.map(w => {
+            const display = parseWorkflowForDisplay(w);
+            return {
+                name: display.name,
+                description: display.description,
+                inputs: display.inputs.split(', '),
+                outputs: display.outputs.split(', '),
+                raw: w
+            };
+        })
+    };
+    return JSON.stringify(output, null, 2);
+}
+function formatWorkflows(workflows, format, detailed) {
+    if (format === OUTPUT_FORMAT.JSON) {
+        return formatWorkflowsAsJson(workflows);
+    }
+    if (format === OUTPUT_FORMAT.TABLE) {
+        return createWorkflowTable(workflows, detailed);
+    }
+    return formatWorkflowsAsList(workflows);
+}
+export default class WorkflowList extends Command {
+    static description = 'List available workflows from the catalog';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --format table',
+        '<%= config.bin %> <%= command.id %> --format json',
+        '<%= config.bin %> <%= command.id %> --detailed',
+        '<%= config.bin %> <%= command.id %> --filter simple'
+    ];
+    static flags = {
+        format: Flags.string({
+            char: 'f',
+            description: 'Output format',
+            options: [OUTPUT_FORMAT.LIST, OUTPUT_FORMAT.TABLE, OUTPUT_FORMAT.JSON],
+            default: OUTPUT_FORMAT.LIST
+        }),
+        detailed: Flags.boolean({
+            char: 'd',
+            description: 'Show detailed parameter information',
+            default: false
+        }),
+        filter: Flags.string({
+            description: 'Filter workflows by name'
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowList);
+        try {
+            this.log('Fetching workflow catalog...');
+            const response = await getWorkflowCatalog();
+            if (!response) {
+                this.error('Failed to connect to API server. Is it running?', { exit: 1 });
+            }
+            if (!response.data) {
+                this.error('API returned invalid response (missing data)', { exit: 1 });
+            }
+            if (!response.data.workflows) {
+                this.error('API returned invalid response (missing workflows)', { exit: 1 });
+            }
+            if (response.data.workflows.length === 0) {
+                this.log('No workflows found in catalog.');
+                return;
+            }
+            const workflows = flags.filter ?
+                response.data.workflows.filter(matchName(flags.filter)) :
+                response.data.workflows;
+            if (workflows.length === 0 && flags.filter) {
+                this.log(`No workflows matching filter: ${flags.filter}`);
+                return;
+            }
+            const output = formatWorkflows(workflows, flags.format, flags.detailed);
+            this.log(output);
+            this.log(`\nFound ${workflows.length} workflow(s)`);
+        }
+        catch (error) {
+            this.handleError(error);
+        }
+    }
+    handleError(error) {
+        const apiError = error;
+        if (apiError.code === 'ECONNREFUSED') {
+            this.error(`Connection refused to ${config.apiUrl}`, { exit: 1 });
+        }
+        if (apiError.response?.status === 401) {
+            this.error('Authentication failed.', { exit: 1 });
+        }
+        if (apiError.response?.status === 404) {
+            this.error('Not found.', { exit: 1 });
+        }
+        if (apiError.message) {
+            this.error(`Failed to fetch workflow catalog: ${apiError.message}`, { exit: 1 });
+        }
+        this.error('Failed to fetch workflow catalog: Unknown error', { exit: 1 });
+    }
+}

package/dist/commands/workflow/list.test.d.ts

@@ -0,0 +1 @@
+export {};