@output.ai/cli 0.6.0 → 0.7.1

package/README.md

@@ -18,7 +18,7 @@ cd <project-name>
 npx output dev
 
 # Run a workflow
-npx output workflow run simple --input '{"question": "who is ada lovelace?"}'
+npx output workflow run example_question --input '{"question": "who is ada lovelace?"}'
 ```
 
 ## Environment Configuration
@@ -54,6 +54,7 @@ OUTPUT_CLI_ENV=/etc/output/production.env npx output workflow status wf-123
 | `output workflow status` | Get workflow execution status |
 | `output workflow result` | Get workflow execution result |
 | `output workflow stop` | Stop a workflow execution |
+| `output workflow terminate` | Terminate a workflow execution (force stop) |
 | `output workflow debug` | Display workflow execution trace |
 
 ## Development Services

package/dist/api/generated/api.d.ts

@@ -198,6 +198,14 @@ export type GetWorkflowIdStatus200 = {
     /** An epoch timestamp representing when the workflow ended */
     completedAt?: number;
 };
+export type PostWorkflowIdTerminateBody = {
+    /** Optional reason for termination */
+    reason?: string;
+};
+export type PostWorkflowIdTerminate200 = {
+    terminated?: boolean;
+    workflowId?: string;
+};
 export type GetWorkflowIdResult200 = {
     /** The workflow execution id */
     workflowId?: string;
@@ -316,6 +324,27 @@ export type patchWorkflowIdStopResponseError = (patchWorkflowIdStopResponse404)
 export type patchWorkflowIdStopResponse = (patchWorkflowIdStopResponseSuccess | patchWorkflowIdStopResponseError);
 export declare const getPatchWorkflowIdStopUrl: (id: string) => string;
 export declare const patchWorkflowIdStop: (id: string, options?: ApiRequestOptions) => Promise<patchWorkflowIdStopResponse>;
+/**
+ * Force terminates a workflow. Unlike stop/cancel, terminate immediately stops the workflow without allowing cleanup.
+ * @summary Terminate a workflow execution (force stop)
+ */
+export type postWorkflowIdTerminateResponse200 = {
+    data: PostWorkflowIdTerminate200;
+    status: 200;
+};
+export type postWorkflowIdTerminateResponse404 = {
+    data: void;
+    status: 404;
+};
+export type postWorkflowIdTerminateResponseSuccess = (postWorkflowIdTerminateResponse200) & {
+    headers: Headers;
+};
+export type postWorkflowIdTerminateResponseError = (postWorkflowIdTerminateResponse404) & {
+    headers: Headers;
+};
+export type postWorkflowIdTerminateResponse = (postWorkflowIdTerminateResponseSuccess | postWorkflowIdTerminateResponseError);
+export declare const getPostWorkflowIdTerminateUrl: (id: string) => string;
+export declare const postWorkflowIdTerminate: (id: string, postWorkflowIdTerminateBody: PostWorkflowIdTerminateBody, options?: ApiRequestOptions) => Promise<postWorkflowIdTerminateResponse>;
 /**
  * @summary Return the result of a workflow
  */

package/dist/api/generated/api.js

@@ -87,6 +87,17 @@ export const patchWorkflowIdStop = async (id, options) => {
         method: 'PATCH'
     });
 };
+export const getPostWorkflowIdTerminateUrl = (id) => {
+    return `/workflow/${id}/terminate`;
+};
+export const postWorkflowIdTerminate = async (id, postWorkflowIdTerminateBody, options) => {
+    return customFetchInstance(getPostWorkflowIdTerminateUrl(id), {
+        ...options,
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        body: JSON.stringify(postWorkflowIdTerminateBody)
+    });
+};
 export const getGetWorkflowIdResultUrl = (id) => {
     return `/workflow/${id}/result`;
 };

package/dist/commands/init.d.ts

@@ -2,7 +2,9 @@ import { Command } from '@oclif/core';
 export default class Init extends Command {
     static description: string;
     static examples: string[];
-    static args: {};
+    static args: {
+        folderName: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
     static flags: {
         'skip-env': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/init.js

@@ -1,12 +1,18 @@
-import { Command, Flags } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
 import { UserCancelledError } from '#types/errors.js';
-import { runInit, handleRunInitError } from '#services/project_scaffold.js';
+import { runInit } from '#services/project_scaffold.js';
 export default class Init extends Command {
     static description = 'Initialize a new Output SDK workflow project by scaffolding the complete project structure';
     static examples = [
-        '<%= config.bin %> <%= command.id %>'
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> my-workflow-project'
     ];
-    static args = {};
+    static args = {
+        folderName: Args.string({
+            description: 'Optional folder name for the project (skips folder name prompt)',
+            required: false
+        })
+    };
     static flags = {
         'skip-env': Flags.boolean({
             description: 'Skip interactive environment variable configuration',
@@ -15,15 +21,16 @@ export default class Init extends Command {
     };
     async run() {
         try {
-            const { flags } = await this.parse(Init);
-            await runInit((msg) => this.log(msg), (msg) => this.warn(msg), flags['skip-env']);
+            const { args, flags } = await this.parse(Init);
+            await runInit(flags['skip-env'], args.folderName);
         }
         catch (error) {
             if (error instanceof UserCancelledError) {
                 this.log(error.message);
                 return;
             }
-            const { errorMessage } = await handleRunInitError(error, (msg) => this.warn(msg));
+            // runInit handles cleanup internally and throws Error with message
+            const errorMessage = error instanceof Error ? error.message : String(error);
             this.error(errorMessage);
         }
     }

package/dist/commands/init.spec.js

@@ -8,11 +8,6 @@ describe('init command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         vi.mocked(projectScaffold.runInit).mockResolvedValue(undefined);
-        vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
-            shouldCleanup: false,
-            errorMessage: 'Failed to create project',
-            projectPath: null
-        });
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -27,20 +22,21 @@ describe('init command', () => {
             expect(Array.isArray(Init.examples)).toBe(true);
             expect(Init.examples.length).toBeGreaterThan(0);
         });
-        it('should have no required arguments', () => {
+        it('should have an optional folderName argument', () => {
             expect(Init.args).toBeDefined();
-            expect(Object.keys(Init.args)).toHaveLength(0);
+            expect(Init.args.folderName).toBeDefined();
+            expect(Init.args.folderName.required).toBe(false);
         });
     });
     describe('command execution', () => {
-        const createTestCommand = (args = [], flags = {}) => {
+        const createTestCommand = (args = [], flags = {}, parsedArgs = {}) => {
             const cmd = new Init(args, {});
             cmd.log = vi.fn();
             cmd.warn = vi.fn();
             cmd.error = vi.fn();
             Object.defineProperty(cmd, 'parse', {
                 value: vi.fn().mockResolvedValue({
-                    args: {},
+                    args: { folderName: undefined, ...parsedArgs },
                     flags: { 'skip-env': false, ...flags }
                 }),
                 configurable: true
@@ -56,10 +52,10 @@ describe('init command', () => {
             expect(cmd.run).toBeDefined();
             expect(typeof cmd.run).toBe('function');
         });
-        it('should call runInit with log, warn callbacks, and skip-env flag', async () => {
+        it('should call runInit with skip-env flag and folder name', async () => {
             const cmd = createTestCommand();
             await cmd.run();
-            expect(projectScaffold.runInit).toHaveBeenCalledWith(expect.any(Function), expect.any(Function), false);
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, undefined);
         });
         it('should handle UserCancelledError', async () => {
             const error = new UserCancelledError();
@@ -69,27 +65,17 @@ describe('init command', () => {
             expect(cmd.log).toHaveBeenCalledWith('Init cancelled by user.');
             expect(cmd.error).not.toHaveBeenCalled();
         });
-        it('should handle other errors with error handler', async () => {
-            const testError = new Error('Test error');
+        it('should handle other errors by passing error message', async () => {
+            // runInit now handles cleanup internally and throws Error with message
+            const testError = new Error('Failed to create project');
             vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
-            vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
-                shouldCleanup: true,
-                errorMessage: 'Failed to create project',
-                projectPath: '/some/path'
-            });
             const cmd = createTestCommand();
             await cmd.run();
-            expect(projectScaffold.handleRunInitError).toHaveBeenCalledWith(testError, expect.any(Function));
             expect(cmd.error).toHaveBeenCalledWith('Failed to create project');
         });
-        it('should pass error message from handler to error', async () => {
-            const testError = new Error('Custom error');
+        it('should pass error message to this.error', async () => {
+            const testError = new Error('Folder already exists');
             vi.mocked(projectScaffold.runInit).mockRejectedValue(testError);
-            vi.mocked(projectScaffold.handleRunInitError).mockResolvedValue({
-                shouldCleanup: false,
-                errorMessage: 'Folder already exists',
-                projectPath: null
-            });
             const cmd = createTestCommand();
             await cmd.run();
             expect(cmd.error).toHaveBeenCalledWith('Folder already exists');
@@ -103,7 +89,12 @@ describe('init command', () => {
         it('should pass skip-env flag to runInit when --skip-env is provided', async () => {
             const cmd = createTestCommand([], { 'skip-env': true });
             await cmd.run();
-            expect(projectScaffold.runInit).toHaveBeenCalledWith(expect.any(Function), expect.any(Function), true);
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(true, undefined);
+        });
+        it('should pass folder name to runInit when provided', async () => {
+            const cmd = createTestCommand([], {}, { folderName: 'my-project' });
+            await cmd.run();
+            expect(projectScaffold.runInit).toHaveBeenCalledWith(false, 'my-project');
         });
     });
 });

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

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class WorkflowTerminate extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workflowId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}

package/dist/commands/workflow/terminate.js

@@ -0,0 +1,39 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { postWorkflowIdTerminate } from '#api/generated/api.js';
+import { handleApiError } from '#utils/error_handler.js';
+export default class WorkflowTerminate extends Command {
+    static description = 'Terminate a workflow execution (force stop)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> wf-12345',
+        '<%= config.bin %> <%= command.id %> wf-12345 --reason "Cleaning up old workflows"'
+    ];
+    static args = {
+        workflowId: Args.string({
+            description: 'The workflow ID to terminate',
+            required: true
+        })
+    };
+    static flags = {
+        reason: Flags.string({
+            char: 'r',
+            description: 'Reason for termination'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(WorkflowTerminate);
+        this.log(`Terminating workflow: ${args.workflowId}...`);
+        await postWorkflowIdTerminate(args.workflowId, { reason: flags.reason });
+        const output = [
+            'Workflow terminated successfully',
+            '',
+            `Workflow ID: ${args.workflowId}`,
+            flags.reason ? `Reason: ${flags.reason}` : ''
+        ].filter(Boolean).join('\n');
+        this.log(`\n${output}`);
+    }
+    async catch(error) {
+        return handleApiError(error, (...args) => this.error(...args), {
+            404: 'Workflow not found. Check the workflow ID.'
+        });
+    }
+}

package/dist/services/coding_agents.js

@@ -7,10 +7,12 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { join } from 'node:path';
 import { ux } from '@oclif/core';
+import { confirm } from '@inquirer/prompts';
 import { AGENT_CONFIG_DIR } from '#config.js';
 import { getTemplateDir } from '#utils/paths.js';
 import { executeClaudeCommand } from '#utils/claude.js';
 import { processTemplate } from '#utils/template.js';
+import { ClaudePluginError, UserCancelledError } from '#types/errors.js';
 const EXPECTED_MARKETPLACE_REPO = 'growthxai/output-claude-plugins';
 /**
  * Get the full path to the agent configuration directory
@@ -192,21 +194,65 @@ async function createClaudeMdSymlink(projectRoot, force) {
         ux.warn('File already exists: CLAUDE.md (use --force to overwrite)');
     }
 }
+/**
+ * Handle Claude plugin command errors with user confirmation to proceed
+ * @param error - The error that occurred
+ * @param commandName - Name of the command that failed
+ * @throws UserCancelledError if user declines to proceed or presses Ctrl+C
+ */
+async function handlePluginError(error, commandName) {
+    const pluginError = new ClaudePluginError(commandName, error instanceof Error ? error : undefined);
+    ux.warn(pluginError.message);
+    try {
+        const shouldProceed = await confirm({
+            message: 'Claude plugin setup failed.\n\nThis means your project will be without Output.ai-specific commands, skills, and subagents.' +
+                ' You will not be able to use our AI-assisted workflow planning and building functionality.\n\n' +
+                'Would you like to proceed without the Claude plugin setup?',
+            default: false
+        });
+        if (!shouldProceed) {
+            throw new UserCancelledError();
+        }
+    }
+    catch (promptError) {
+        if (promptError instanceof UserCancelledError) {
+            throw promptError;
+        }
+        // Ctrl+C throws ExitPromptError - convert to UserCancelledError
+        throw new UserCancelledError();
+    }
+}
 /**
  * Register and update the OutputAI plugin marketplace
  */
 async function registerPluginMarketplace(projectRoot) {
     ux.stdout(ux.colorize('gray', 'Registering plugin marketplace...'));
-    await executeClaudeCommand(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], projectRoot, { ignoreFailure: true });
+    try {
+        await executeClaudeCommand(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], projectRoot, { ignoreFailure: true });
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin marketplace add');
+        return;
+    }
     ux.stdout(ux.colorize('gray', 'Updating plugin marketplace...'));
-    await executeClaudeCommand(['plugin', 'marketplace', 'update', 'outputai'], projectRoot);
+    try {
+        await executeClaudeCommand(['plugin', 'marketplace', 'update', 'outputai'], projectRoot);
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin marketplace update outputai');
+    }
 }
 /**
  * Install the OutputAI plugin
  */
 async function installOutputAIPlugin(projectRoot) {
     ux.stdout(ux.colorize('gray', 'Installing OutputAI plugin...'));
-    await executeClaudeCommand(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], projectRoot);
+    try {
+        await executeClaudeCommand(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], projectRoot);
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin install outputai@outputai');
+    }
 }
 /**
  * Initialize agent configuration files and register Claude Code plugin

package/dist/services/coding_agents.spec.js

@@ -19,6 +19,9 @@ vi.mock('@oclif/core', () => ({
         colorize: vi.fn().mockImplementation((_color, text) => text)
     }
 }));
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn()
+}));
 describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -222,4 +225,48 @@ describe('coding_agents service', () => {
             expect(fs.mkdir).toHaveBeenCalled();
         });
     });
+    describe('Claude plugin error handling', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            vi.mocked(fs.symlink).mockResolvedValue(undefined);
+        });
+        it('should show error and prompt user when registerPluginMarketplace fails', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should show error and prompt user when installOutputAIPlugin fails', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockResolvedValueOnce(undefined) // marketplace update
+                .mockRejectedValueOnce(new Error('Plugin install failed')); // plugin install
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should allow user to proceed without plugin setup if they confirm', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValue(new Error('All plugin commands fail'));
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            // File operations should still complete
+            expect(fs.mkdir).toHaveBeenCalled();
+        });
+    });
 });

package/dist/services/env_configurator.d.ts

@@ -7,7 +7,7 @@
  * unchanged as a template for other developers.
  *
  * @param projectPath - The absolute path to the project directory containing the .env.example file
- * @param skipPrompt - If true, skips the configuration prompt and returns false immediately
+ * @param skipPrompt - If true, copies .env.example to .env without interactive prompts and returns false
  * @returns A promise that resolves to true if environment variables were successfully configured,
  *          false if configuration was skipped (no .env.example file, user declined, no variables to configure,
  *          or an error occurred)

package/dist/services/env_configurator.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ux } from '@oclif/core';
 import { getErrorMessage } from '#utils/error_utils.js';
+import { UserCancelledError } from '#types/errors.js';
 const COMMENT_LINE = /^\s*#/;
 const COMMENTED_VAR = /^\s*#\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
 const ACTIVE_VAR = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
@@ -120,35 +121,28 @@ async function writeEnvFile(filePath, variables) {
  * unchanged as a template for other developers.
  *
  * @param projectPath - The absolute path to the project directory containing the .env.example file
- * @param skipPrompt - If true, skips the configuration prompt and returns false immediately
+ * @param skipPrompt - If true, copies .env.example to .env without interactive prompts and returns false
  * @returns A promise that resolves to true if environment variables were successfully configured,
  *          false if configuration was skipped (no .env.example file, user declined, no variables to configure,
  *          or an error occurred)
  */
 export async function configureEnvironmentVariables(projectPath, skipPrompt = false) {
-    if (skipPrompt) {
-        return false;
-    }
-    ux.stdout('configuring environment variables...');
-    const envExamplePath = path.join(projectPath, '.env.example');
-    const envPath = path.join(projectPath, '.env');
-    try {
-        await fs.access(envExamplePath);
-    }
-    catch {
-        ux.stdout(ux.colorize('red', '.env.example file does not exist, nothing to configure'));
-        return false;
-    }
-    const shouldConfigure = await confirm({
-        message: 'Would you like to configure environment variables now?',
-        default: true
-    });
-    if (!shouldConfigure) {
-        return false;
-    }
     try {
+        ux.stdout('configuring environment variables...');
+        const envExamplePath = path.join(projectPath, '.env.example');
+        const envPath = path.join(projectPath, '.env');
         // Copy .env.example to .env before configuring
         await fs.copyFile(envExamplePath, envPath);
+        if (skipPrompt) {
+            return false;
+        }
+        const shouldConfigure = await confirm({
+            message: 'Would you like to configure environment variables now?',
+            default: true
+        });
+        if (!shouldConfigure) {
+            return false;
+        }
         const variables = await parseEnvFile(envPath);
         const variablesToConfigure = variables.filter(v => isEmpty(v.value) || v.isSecret);
         if (variablesToConfigure.length === 0) {
@@ -159,6 +153,10 @@ export async function configureEnvironmentVariables(projectPath, skipPrompt = fa
         return true;
     }
     catch (error) {
+        // Ctrl+C in @inquirer/prompts throws ExitPromptError - propagate as UserCancelledError
+        if (error instanceof Error && error.name === 'ExitPromptError') {
+            throw new UserCancelledError();
+        }
         ux.warn(`Failed to configure environment variables: ${getErrorMessage(error)}`);
         return false;
     }

package/dist/services/env_configurator.spec.js

@@ -28,16 +28,22 @@ describe('configureEnvironmentVariables', () => {
             // Ignore cleanup errors
         }
     });
-    it('should return false if skipPrompt is true', async () => {
-        // Create a minimal .env.example file
-        await fs.writeFile(testState.envExamplePath, 'KEY=value');
+    it('should copy .env.example to .env when skipPrompt is true', async () => {
+        const envExampleContent = 'API_KEY=<SECRET>\nDATABASE_URL=localhost';
+        await fs.writeFile(testState.envExamplePath, envExampleContent);
         const result = await configureEnvironmentVariables(testState.tempDir, true);
         expect(result).toBe(false);
+        const envContent = await fs.readFile(testState.envPath, 'utf-8');
+        expect(envContent).toBe(envExampleContent);
     });
     it('should return false if .env.example file does not exist', async () => {
         const result = await configureEnvironmentVariables(testState.tempDir, false);
         expect(result).toBe(false);
     });
+    it('should handle missing .env.example gracefully when skipPrompt is true', async () => {
+        const result = await configureEnvironmentVariables(testState.tempDir, true);
+        expect(result).toBe(false);
+    });
     it('should return false if user declines configuration', async () => {
         const { confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(false);
@@ -46,16 +52,6 @@ describe('configureEnvironmentVariables', () => {
         expect(result).toBe(false);
         expect(vi.mocked(confirm)).toHaveBeenCalled();
     });
-    it('should NOT create .env when user declines configuration', async () => {
-        const { confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(false);
-        await fs.writeFile(testState.envExamplePath, '# API key\nAPIKEY=');
-        await configureEnvironmentVariables(testState.tempDir, false);
-        // .env should NOT exist when user declines
-        await expect(fs.access(testState.envPath)).rejects.toThrow();
-        // .env.example should still exist
-        await expect(fs.access(testState.envExamplePath)).resolves.toBeUndefined();
-    });
     it('should return false if no empty variables exist', async () => {
         const { confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);

package/dist/services/messages.js

@@ -177,7 +177,7 @@ export const getProjectSuccessMessage = (folderName, installSuccess, envConfigur
         note: 'Launches Temporal, Redis, PostgreSQL, API, Worker, and UI'
     }, {
         step: 'Run example workflow',
-        command: 'npx output workflow run simple --input src/simple/scenarios/question_ada_lovelace.json',
+        command: 'npx output workflow run example_question --input src/workflows/example_question/scenarios/question_ada_lovelace.json',
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',
@@ -321,7 +321,7 @@ ${createSectionHeader('RUN A WORKFLOW', '🚀')}
 
   ${ux.colorize('white', 'In a new terminal, execute:')}
 
-    ${formatCommand('npx output workflow run simple --input \'{"question": "Hello!"}\'')}
+    ${formatCommand('npx output workflow run example_question --input \'{"question": "Hello!"}\'')}
 
 ${divider}
 

package/dist/services/project_scaffold.d.ts

@@ -1,6 +1,31 @@
-export declare function runInit(log: (message: string) => void, _warn: (message: string) => void, skipEnv?: boolean): Promise<void>;
-export declare function handleRunInitError(error: unknown, warn: (message: string) => void): Promise<{
-    shouldCleanup: boolean;
-    errorMessage: string;
-    projectPath: string | null;
-}>;
+interface ProjectConfig {
+    projectName: string;
+    folderName: string;
+    projectPath: string;
+    description: string;
+}
+/**
+ * Check for required dependencies (Docker and Claude CLI)
+ * Prompts user to continue if dependencies are missing
+ * @throws UserCancelledError if user declines to proceed without dependencies
+ */
+export declare function checkDependencies(): Promise<void>;
+/**
+ * Get project configuration from user input
+ * @param userFolderNameArg - Optional folder name to skip folder name prompt
+ */
+export declare const getProjectConfig: (userFolderNameArg?: string) => Promise<ProjectConfig>;
+/**
+ * Create a SIGINT handler for cleanup during init
+ * Exits immediately without prompting to avoid race conditions
+ * @param projectPath - Path to the project folder
+ * @param folderCreated - Whether the folder has been created
+ */
+export declare function createSigintHandler(projectPath: string, folderCreated: boolean): () => void;
+/**
+ * Run the init command workflow
+ * @param skipEnv - Whether to skip environment configuration prompts
+ * @param folderName - Optional folder name to skip folder name prompt
+ */
+export declare function runInit(skipEnv?: boolean, folderName?: string): Promise<void>;
+export {};

package/dist/services/project_scaffold.js

@@ -1,30 +1,86 @@
-import { input } from '@inquirer/prompts';
+import { input, confirm } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
 import { kebabCase, pascalCase } from 'change-case';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { FolderAlreadyExistsError, UserCancelledError, DirectoryCreationError } from '#types/errors.js';
-import { createDirectory, removeDirectory } from '#utils/file_system.js';
+import { createDirectory } from '#utils/file_system.js';
 import { executeCommand, executeCommandWithMessages } from '#utils/process.js';
 import { getSDKVersions } from '#utils/sdk_versions.js';
 import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
+import { isDockerInstalled } from '#services/docker.js';
+import { isClaudeCliAvailable } from '#utils/claude.js';
 import { configureEnvironmentVariables } from './env_configurator.js';
 import { getTemplateFiles, processTemplateFile } from './template_processor.js';
 import { ensureOutputAISystem } from './coding_agents.js';
 import { getProjectSuccessMessage } from './messages.js';
-const getProjectConfig = async () => {
+/**
+ * Check for required dependencies (Docker and Claude CLI)
+ * Prompts user to continue if dependencies are missing
+ * @throws UserCancelledError if user declines to proceed without dependencies
+ */
+export async function checkDependencies() {
+    const dockerInstalled = isDockerInstalled();
+    const claudeAvailable = isClaudeCliAvailable();
+    if (dockerInstalled && claudeAvailable) {
+        return;
+    }
+    const missingDeps = [];
+    if (!dockerInstalled) {
+        missingDeps.push('Docker (https://docs.docker.com/)');
+    }
+    if (!claudeAvailable) {
+        missingDeps.push('Claude CLI (https://code.claude.com/)');
+    }
+    const depList = missingDeps.join('\n  - ');
+    const message = `The following dependencies are missing:\n  - ${depList}\n\n` +
+        'Some features may not work correctly without these dependencies.';
+    ux.warn(message);
     try {
-        const projectName = await input({
-            message: 'What is your project name?',
-            default: 'my-outputai-workflows'
-        }) || 'my-outputai-workflows';
-        const folderName = await input({
-            message: 'What folder name should be used?',
-            default: kebabCase(projectName)
-        }) || kebabCase(projectName);
-        const description = await input({
-            message: 'What is your project description? (optional)',
-            default: `An Output SDK workflow for ${kebabCase(projectName)}`
-        }) || `An Output SDK workflow for ${kebabCase(projectName)}`;
+        const shouldProceed = await confirm({
+            message: 'Would you like to proceed anyway?',
+            default: false
+        });
+        if (!shouldProceed) {
+            throw new UserCancelledError();
+        }
+    }
+    catch {
+        throw new UserCancelledError();
+    }
+}
+const promptForFolderName = async (projectName) => {
+    return await input({
+        message: 'What folder name should be used?',
+        default: kebabCase(projectName)
+    }) || kebabCase(projectName);
+};
+const promptForProjectName = async (defaultProjectName) => {
+    return await input({
+        message: 'What is your project name?',
+        default: defaultProjectName
+    }) || defaultProjectName;
+};
+const promptForProjectDescription = async (projectName) => {
+    return await input({
+        message: 'What is your project description? (optional)',
+        default: `An Output SDK workflow for ${kebabCase(projectName)}`
+    }) || `An Output SDK workflow for ${kebabCase(projectName)}`;
+};
+/**
+ * Get project configuration from user input
+ * @param userFolderNameArg - Optional folder name to skip folder name prompt
+ */
+export const getProjectConfig = async (userFolderNameArg) => {
+    const defaultProjectName = 'my-outputai-workflows';
+    try {
+        const projectName = userFolderNameArg ?
+            userFolderNameArg :
+            await promptForProjectName(defaultProjectName);
+        const folderName = userFolderNameArg ?
+            userFolderNameArg :
+            await promptForFolderName(projectName);
+        const description = await promptForProjectDescription(projectName);
         return {
             projectName,
             folderName,
@@ -61,100 +117,102 @@ async function executeNpmInstall(projectPath) {
 async function initializeAgents(projectPath) {
     await ensureOutputAISystem(projectPath);
 }
-function extractProjectPath(error) {
-    if (error instanceof FolderAlreadyExistsError) {
-        return error.folderPath;
-    }
-    const errorObject = error;
-    if (errorObject.projectPath) {
-        return errorObject.projectPath;
-    }
-    return null;
-}
-function handleInitError(error, projectPath) {
+/**
+ * Format error message for init errors
+ * Single responsibility: only format error messages, no cleanup logic
+ */
+function formatInitError(error, projectPath) {
     if (error instanceof UserCancelledError) {
-        return {
-            shouldCleanup: false,
-            errorMessage: error.message
-        };
+        return error.message;
     }
     if (error instanceof FolderAlreadyExistsError) {
-        return {
-            shouldCleanup: false,
-            errorMessage: error.message
-        };
+        return error.message;
     }
     const errorCode = getErrorCode(error);
-    if (errorCode === 'EEXIST') {
-        return {
-            shouldCleanup: false,
-            errorMessage: 'Folder already exists'
-        };
-    }
     const pathSuffix = projectPath ? ` at ${projectPath}` : '';
-    if (errorCode === 'EACCES') {
-        return {
-            shouldCleanup: projectPath !== null,
-            errorMessage: `Permission denied${pathSuffix}`
-        };
-    }
-    if (errorCode === 'ENOSPC') {
-        return {
-            shouldCleanup: projectPath !== null,
-            errorMessage: `Not enough disk space${pathSuffix}`
-        };
-    }
-    if (errorCode === 'EPERM') {
-        return {
-            shouldCleanup: projectPath !== null,
-            errorMessage: `Operation not permitted${pathSuffix}`
-        };
-    }
-    if (errorCode === 'ENOENT') {
-        return {
-            shouldCleanup: projectPath !== null,
-            errorMessage: `Required file or directory not found${pathSuffix}`
-        };
+    switch (errorCode) {
+        case 'EEXIST': return 'Folder already exists';
+        case 'EACCES': return `Permission denied${pathSuffix}`;
+        case 'ENOSPC': return `Not enough disk space${pathSuffix}`;
+        case 'EPERM': return `Operation not permitted${pathSuffix}`;
+        case 'ENOENT': return `Required file or directory not found${pathSuffix}`;
+        default: {
+            const originalMessage = error instanceof Error ? error.message : String(error);
+            return `Failed to create project${pathSuffix}: ${originalMessage}`;
+        }
     }
-    const originalMessage = error instanceof Error ? error.message : String(error);
-    return {
-        shouldCleanup: projectPath !== null,
-        errorMessage: `Failed to create project${pathSuffix}: ${originalMessage}`
+}
+/**
+ * Create a SIGINT handler for cleanup during init
+ * Exits immediately without prompting to avoid race conditions
+ * @param projectPath - Path to the project folder
+ * @param folderCreated - Whether the folder has been created
+ */
+export function createSigintHandler(projectPath, folderCreated) {
+    return () => {
+        ux.stdout('\n');
+        if (folderCreated) {
+            ux.warn(`Incomplete project folder may exist at: ${projectPath}`);
+            ux.warn(`Run: rm -rf "${projectPath}" to clean up`);
+        }
+        process.exit(130);
     };
 }
-export async function runInit(log, _warn, skipEnv = false) {
-    const config = await getProjectConfig();
-    try {
-        createDirectory(config.projectPath);
-    }
-    catch (error) {
-        throw new DirectoryCreationError(getErrorMessage(error), config.projectPath);
+function handleRunInitError(error, projectPath, projectFolderCreated) {
+    const errorMessage = formatInitError(error, projectPath);
+    if (projectFolderCreated && projectPath) {
+        ux.warn(`Incomplete project folder may exist at: ${projectPath}`);
+        ux.warn(`Run: rm -rf "${projectPath}" to clean up`);
     }
-    log(`✅ Created project folder: ${config.folderName}`);
+    throw new Error(errorMessage);
+}
+/**
+ * Run the init command workflow
+ * @param skipEnv - Whether to skip environment configuration prompts
+ * @param folderName - Optional folder name to skip folder name prompt
+ */
+export async function runInit(skipEnv = false, folderName) {
+    // Track state for SIGINT cleanup using an object to avoid let
+    const state = {
+        projectFolderCreated: false,
+        projectPath: ''
+    };
+    // Create and register SIGINT handler
+    const sigintHandler = () => {
+        const handler = createSigintHandler(state.projectPath, state.projectFolderCreated);
+        handler();
+    };
+    process.on('SIGINT', sigintHandler);
     try {
+        // Check dependencies first
+        await checkDependencies();
+        const config = await getProjectConfig(folderName);
+        state.projectPath = config.projectPath;
+        try {
+            createDirectory(config.projectPath);
+            state.projectFolderCreated = true;
+        }
+        catch (error) {
+            throw new DirectoryCreationError(getErrorMessage(error), config.projectPath);
+        }
+        ux.stdout(`Created project folder: ${config.folderName}`);
         const filesCreated = await scaffoldProjectFiles(config.projectPath, config.projectName, config.description);
-        log(`✅ Created ${filesCreated.length} project files`);
+        ux.stdout(`Created ${filesCreated.length} project files`);
+        const envConfigured = await configureEnvironmentVariables(config.projectPath, skipEnv);
+        if (envConfigured) {
+            ux.stdout('Environment variables configured in .env');
+        }
+        await executeCommandWithMessages(() => initializeAgents(config.projectPath), 'Initializing agent system...', 'Agent system initialized');
+        const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), 'Installing dependencies...', 'Dependencies installed');
+        const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, envConfigured);
+        ux.stdout('Project created successfully!');
+        ux.stdout(nextSteps);
     }
     catch (error) {
-        const enrichedError = error;
-        enrichedError.projectPath = config.projectPath;
-        throw enrichedError;
+        handleRunInitError(error, state.projectPath || null, state.projectFolderCreated);
     }
-    const envConfigured = await configureEnvironmentVariables(config.projectPath, skipEnv);
-    if (envConfigured) {
-        log('🔐 Environment variables configured in .env');
-    }
-    await executeCommandWithMessages(() => initializeAgents(config.projectPath), '🤖 Initializing agent system...', '✅ Agent system initialized');
-    const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), '📦 Installing dependencies...', '✅ Dependencies installed');
-    const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, envConfigured);
-    log('✅ Project created successfully!');
-    log(nextSteps);
-}
-export async function handleRunInitError(error, warn) {
-    const projectPath = extractProjectPath(error);
-    const { shouldCleanup, errorMessage } = handleInitError(error, projectPath);
-    if (shouldCleanup && projectPath) {
-        await removeDirectory(projectPath, warn);
+    finally {
+        // Remove SIGINT handler on completion (success or error)
+        process.removeListener('SIGINT', sigintHandler);
     }
-    return { shouldCleanup, errorMessage, projectPath };
 }

package/dist/services/project_scaffold.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { handleRunInitError } from './project_scaffold.js';
+import { getProjectConfig, checkDependencies, createSigintHandler } from './project_scaffold.js';
 import { UserCancelledError } from '#types/errors.js';
 // Mock the SDK versions utility
 vi.mock('#utils/sdk_versions.js', () => ({
@@ -12,7 +12,8 @@ vi.mock('#utils/sdk_versions.js', () => ({
 }));
 // Mock other dependencies
 vi.mock('@inquirer/prompts', () => ({
-    input: vi.fn()
+    input: vi.fn(),
+    confirm: vi.fn()
 }));
 vi.mock('#utils/file_system.js');
 vi.mock('#utils/process.js');
@@ -21,31 +22,112 @@ vi.mock('./env_configurator.js', () => ({
 }));
 vi.mock('./template_processor.js');
 vi.mock('./coding_agents.js');
+vi.mock('#services/docker.js', () => ({
+    isDockerInstalled: vi.fn().mockReturnValue(true)
+}));
+vi.mock('#utils/claude.js', () => ({
+    isClaudeCliAvailable: vi.fn().mockReturnValue(true)
+}));
+vi.mock('@oclif/core', () => ({
+    ux: {
+        stdout: vi.fn(),
+        warn: vi.fn()
+    }
+}));
 describe('project_scaffold', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    describe('handleRunInitError', () => {
-        it('should handle UserCancelledError', async () => {
-            const error = new UserCancelledError();
-            const warn = vi.fn();
-            const result = await handleRunInitError(error, warn);
-            expect(result.errorMessage).toBe(error.message);
-            expect(result.shouldCleanup).toBe(false);
-        });
-        it('should return error message for generic errors including original message', async () => {
-            const error = new Error('Unknown error');
-            const warn = vi.fn();
-            const result = await handleRunInitError(error, warn);
-            expect(result.errorMessage).toBe('Failed to create project: Unknown error');
-        });
-        it('should include project path in error message when available', async () => {
-            const error = new Error('npm install failed');
-            error.projectPath = '/Users/test/my-project';
-            const warn = vi.fn();
-            const result = await handleRunInitError(error, warn);
-            expect(result.errorMessage).toBe('Failed to create project at /Users/test/my-project: npm install failed');
-            expect(result.projectPath).toBe('/Users/test/my-project');
+    describe('getProjectConfig', () => {
+        it('should skip project name and folder name prompts when folderName is provided', async () => {
+            const { input } = await import('@inquirer/prompts');
+            vi.mocked(input).mockResolvedValueOnce('Test description');
+            const config = await getProjectConfig('my-project');
+            expect(config.folderName).toBe('my-project');
+            expect(config.projectName).toBe('my-project');
+            // Should only prompt for description when folderName is provided
+            expect(input).toHaveBeenCalledTimes(1);
+        });
+        it('should still prompt for description when folderName provided', async () => {
+            const { input } = await import('@inquirer/prompts');
+            vi.mocked(input).mockResolvedValueOnce('My custom description');
+            const config = await getProjectConfig('test-folder');
+            expect(config.description).toBe('My custom description');
+            expect(input).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('description')
+            }));
+        });
+        it('should prompt for all fields when folderName is not provided', async () => {
+            const { input } = await import('@inquirer/prompts');
+            vi.mocked(input)
+                .mockResolvedValueOnce('Test Project')
+                .mockResolvedValueOnce('test-project')
+                .mockResolvedValueOnce('A test project');
+            const config = await getProjectConfig();
+            expect(config.projectName).toBe('Test Project');
+            expect(config.folderName).toBe('test-project');
+            expect(config.description).toBe('A test project');
+            expect(input).toHaveBeenCalledTimes(3);
+        });
+    });
+    describe('checkDependencies', () => {
+        it('should not prompt when all dependencies are available', async () => {
+            const { isDockerInstalled } = await import('#services/docker.js');
+            const { isClaudeCliAvailable } = await import('#utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(isDockerInstalled).mockReturnValue(true);
+            vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
+            await checkDependencies();
+            expect(confirm).not.toHaveBeenCalled();
+        });
+        it('should prompt user when docker is missing', async () => {
+            const { isDockerInstalled } = await import('#services/docker.js');
+            const { isClaudeCliAvailable } = await import('#utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(isDockerInstalled).mockReturnValue(false);
+            vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
+            vi.mocked(confirm).mockResolvedValue(true);
+            await checkDependencies();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should throw UserCancelledError when user declines to proceed', async () => {
+            const { isDockerInstalled } = await import('#services/docker.js');
+            const { isClaudeCliAvailable } = await import('#utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(isDockerInstalled).mockReturnValue(false);
+            vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
+            vi.mocked(confirm).mockResolvedValue(false);
+            await expect(checkDependencies()).rejects.toThrow(UserCancelledError);
+        });
+    });
+    describe('SIGINT handler', () => {
+        it('should show cleanup message when project folder was created', async () => {
+            const { ux } = await import('@oclif/core');
+            const handler = createSigintHandler('/test/project', true);
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+            handler();
+            expect(ux.warn).toHaveBeenCalledWith(expect.stringContaining('/test/project'));
+            expect(ux.warn).toHaveBeenCalledWith(expect.stringContaining('rm -rf'));
+            expect(exitSpy).toHaveBeenCalledWith(130);
+            exitSpy.mockRestore();
+        });
+        it('should exit immediately without warning when folder not created', async () => {
+            const { ux } = await import('@oclif/core');
+            const handler = createSigintHandler('/nonexistent', false);
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+            handler();
+            expect(ux.warn).not.toHaveBeenCalled();
+            expect(exitSpy).toHaveBeenCalledWith(130);
+            exitSpy.mockRestore();
+        });
+        it('should exit with code 130 (SIGINT convention)', async () => {
+            const handler = createSigintHandler('/test/project', true);
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+            handler();
+            expect(exitSpy).toHaveBeenCalledWith(130);
+            exitSpy.mockRestore();
         });
     });
 });

package/dist/services/workflow_planner.js

@@ -4,7 +4,10 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { AGENT_CONFIG_DIR } from '#config.js';
 export async function generatePlanName(description, date = new Date()) {
-    const datePrefix = new Date(date).toISOString().split('T')[0].replaceAll('-', '_');
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const datePrefix = `${year}_${month}_${day}`;
     const planNameSlug = await generateText({
         prompt: 'generate_plan_name@v1',
         variables: { description }

package/dist/templates/project/README.md.template

@@ -44,7 +44,7 @@ This starts:
 In a new terminal:
 
 ```bash
-npx output workflow run simple --input '{"question": "who really is ada lovelace?"}'
+npx output workflow run example_question --input '{"question": "who really is ada lovelace?"}'
 ```
 
 ### 5. Stop Services

package/dist/templates/project/src/{simple → workflows/example_question}/workflow.ts.template

@@ -2,7 +2,7 @@ import { workflow, z } from '@output.ai/core';
 import { answerQuestion } from './steps.js';
 
 export default workflow( {
-  name: 'simple',
+  name: 'example_question',
   description: '{{description}}',
   inputSchema: z.object( {
     question: z.string().describe( 'A question to answer' )

package/dist/types/errors.d.ts

@@ -54,3 +54,15 @@ export declare class DirectoryCreationError extends Error {
      */
     constructor(message: string, projectPath: string);
 }
+/**
+ * Error thrown when a Claude CLI plugin command fails
+ */
+export declare class ClaudePluginError extends Error {
+    readonly commandName: string;
+    readonly originalError?: Error | undefined;
+    /**
+     * @param commandName - The Claude command that failed (e.g., 'plugin update outputai')
+     * @param originalError - The underlying error from the command execution
+     */
+    constructor(commandName: string, originalError?: Error | undefined);
+}

package/dist/types/errors.js

@@ -81,3 +81,20 @@ export class DirectoryCreationError extends Error {
         this.projectPath = projectPath;
     }
 }
+/**
+ * Error thrown when a Claude CLI plugin command fails
+ */
+export class ClaudePluginError extends Error {
+    commandName;
+    originalError;
+    /**
+     * @param commandName - The Claude command that failed (e.g., 'plugin update outputai')
+     * @param originalError - The underlying error from the command execution
+     */
+    constructor(commandName, originalError) {
+        const originalMessage = originalError?.message || 'Unknown error';
+        super(`Claude command '${commandName}' failed: ${originalMessage}`);
+        this.commandName = commandName;
+        this.originalError = originalError;
+    }
+}

package/dist/types/errors.spec.d.ts

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

package/dist/types/errors.spec.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { ClaudePluginError } from './errors.js';
+describe('ClaudePluginError', () => {
+    it('should instantiate with command name and original error', () => {
+        const originalError = new Error('Connection failed');
+        const error = new ClaudePluginError('plugin update outputai', originalError);
+        expect(error).toBeInstanceOf(Error);
+        expect(error).toBeInstanceOf(ClaudePluginError);
+        expect(error.commandName).toBe('plugin update outputai');
+        expect(error.originalError).toBe(originalError);
+    });
+    it('should format error message to include command context', () => {
+        const originalError = new Error('Command not found');
+        const error = new ClaudePluginError('plugin install outputai@outputai', originalError);
+        expect(error.message).toContain('plugin install outputai@outputai');
+        expect(error.message).toContain('Command not found');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",