@outputai/cli 0.1.12 → 0.1.13-dev.98dfd72.0

package/bin/run.js

@@ -2,10 +2,12 @@
 
 import { execute } from '@oclif/core';
 import { loadEnvironment } from '../dist/utils/env_loader.js';
+import { bootstrapProxy } from '../dist/utils/proxy.js';
 import { resolveCredentialRefs } from '@outputai/credentials';
 
 // Load environment variables from .env files before executing CLI
 loadEnvironment();
+bootstrapProxy();
 resolveCredentialRefs();
 
 await execute( { dir: import.meta.url } );

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

@@ -63,6 +63,8 @@ export interface Workflow {
     path?: string;
     inputSchema?: JSONSchema;
     outputSchema?: JSONSchema;
+    /** Alternative names that resolve to this workflow */
+    aliases?: string[];
 }
 /**
  * File destinations for trace data
@@ -304,6 +306,8 @@ export declare const GetWorkflowIdResult200Status: {
 export type GetWorkflowIdResult200 = {
     /** The workflow execution id */
     workflowId?: string;
+    /** The original input passed to the workflow, null if unavailable */
+    input?: unknown;
     /** The result of workflow, null if workflow failed */
     output?: unknown;
     trace?: TraceInfo;

package/dist/assets/docker/docker-compose-dev.yml

@@ -81,7 +81,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.1.12}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-dev.98dfd72.0}
     init: true
     networks:
       - main

package/dist/commands/credentials/set.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class CredentialsSet extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        value: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        environment: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        workflow: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/credentials/set.js

@@ -0,0 +1,57 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
+import { decryptCredentials, credentialsExist, writeEncrypted, resolveCredentialsPath } from '#services/credentials_service.js';
+const setNestedValue = (obj, dotPath, value) => {
+    const parts = dotPath.split('.');
+    const parent = parts.slice(0, -1).reduce((current, key) => {
+        if (!current[key] || typeof current[key] !== 'object') {
+            current[key] = {};
+        }
+        return current[key];
+    }, obj);
+    parent[parts[parts.length - 1]] = value;
+};
+export default class CredentialsSet extends Command {
+    static description = 'Set a credential value by dot-notation path';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> anthropic.api_key sk-ant-...',
+        '<%= config.bin %> <%= command.id %> openai.api_key sk-... --environment production',
+        '<%= config.bin %> <%= command.id %> stripe.key sk_live_... --workflow my_workflow'
+    ];
+    static args = {
+        path: Args.string({
+            description: 'Dot-notation path to the credential (e.g. anthropic.api_key)',
+            required: true
+        }),
+        value: Args.string({
+            description: 'Value to set',
+            required: true
+        })
+    };
+    static flags = {
+        environment: Flags.string({
+            char: 'e',
+            description: 'Target environment (e.g. production, development)'
+        }),
+        workflow: Flags.string({
+            char: 'w',
+            description: 'Target a specific workflow directory'
+        })
+    };
+    async run() {
+        const { args, flags } = await this.parse(CredentialsSet);
+        const environment = flags.environment;
+        const workflow = flags.workflow;
+        if (environment && workflow) {
+            this.error('Cannot specify both --environment and --workflow.');
+        }
+        if (!credentialsExist(environment, workflow)) {
+            this.error(`No credentials file found at ${resolveCredentialsPath(environment, workflow)}. Run "output credentials init" first.`);
+        }
+        const plaintext = decryptCredentials(environment, workflow);
+        const data = (parseYaml(plaintext) || {});
+        setNestedValue(data, args.path, args.value);
+        writeEncrypted(environment, stringifyYaml(data), workflow);
+        this.log(`Set ${args.path}`);
+    }
+}

package/dist/commands/credentials/set.spec.d.ts

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

package/dist/commands/credentials/set.spec.js

@@ -0,0 +1,95 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsSet from './set.js';
+vi.mock('#services/credentials_service.js');
+vi.mock('js-yaml', () => ({
+    load: vi.fn((yaml) => {
+        if (yaml.includes('sk-existing')) {
+            return { anthropic: { api_key: 'sk-existing' } };
+        }
+        return {};
+    }),
+    dump: vi.fn((obj) => JSON.stringify(obj))
+}));
+describe('credentials set command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(credentialsService.credentialsExist).mockReturnValue(true);
+        vi.mocked(credentialsService.decryptCredentials).mockReturnValue('anthropic:\n  api_key: sk-existing\n');
+        vi.mocked(credentialsService.writeEncrypted).mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (parsedArgs = {}, flags = {}) => {
+        const cmd = new CredentialsSet([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn((msg) => {
+            throw new Error(msg);
+        });
+        Object.defineProperty(cmd, 'parse', {
+            value: vi.fn().mockResolvedValue({
+                args: { path: 'anthropic.api_key', value: 'sk-new-key', ...parsedArgs },
+                flags: { environment: undefined, workflow: undefined, ...flags }
+            }),
+            configurable: true
+        });
+        return cmd;
+    };
+    describe('command structure', () => {
+        it('should have correct description', () => {
+            expect(CredentialsSet.description).toContain('credential value');
+        });
+        it('should have required path and value arguments', () => {
+            expect(CredentialsSet.args.path).toBeDefined();
+            expect(CredentialsSet.args.path.required).toBe(true);
+            expect(CredentialsSet.args.value).toBeDefined();
+            expect(CredentialsSet.args.value.required).toBe(true);
+        });
+        it('should have environment and workflow flags', () => {
+            expect(CredentialsSet.flags.environment).toBeDefined();
+            expect(CredentialsSet.flags.workflow).toBeDefined();
+        });
+    });
+    describe('command execution', () => {
+        it('should decrypt, update, and re-encrypt credentials', async () => {
+            const cmd = createTestCommand();
+            await cmd.run();
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), undefined);
+            expect(cmd.log).toHaveBeenCalledWith('Set anthropic.api_key');
+        });
+        it('should create nested keys that do not exist', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('');
+            const cmd = createTestCommand({ path: 'new.nested.key', value: 'my-value' });
+            await cmd.run();
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set new.nested.key');
+        });
+        it('should pass environment flag to service functions', async () => {
+            const cmd = createTestCommand({}, { environment: 'production' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith('production', undefined);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith('production', expect.any(String), undefined);
+        });
+        it('should pass workflow flag to service functions', async () => {
+            const cmd = createTestCommand({}, { workflow: 'my_workflow' });
+            await cmd.run();
+            expect(credentialsService.credentialsExist).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.decryptCredentials).toHaveBeenCalledWith(undefined, 'my_workflow');
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledWith(undefined, expect.any(String), 'my_workflow');
+        });
+        it('should error when both environment and workflow are specified', async () => {
+            const cmd = createTestCommand({}, { environment: 'production', workflow: 'my_workflow' });
+            await expect(cmd.run()).rejects.toThrow('Cannot specify both');
+        });
+        it('should error when credentials file does not exist', async () => {
+            vi.mocked(credentialsService.credentialsExist).mockReturnValue(false);
+            vi.mocked(credentialsService.resolveCredentialsPath).mockReturnValue('/project/config/credentials.yml.enc');
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('No credentials file found');
+        });
+    });
+});

package/dist/commands/fix.js

@@ -1,5 +1,5 @@
 import { Command } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 import { applyFix, planFix } from '#services/fix_package.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 const Ansi = {

package/dist/commands/fix.spec.js

@@ -2,12 +2,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Fix from './fix.js';
 import * as fixService from '#services/fix_package.js';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 vi.mock('#services/fix_package.js', () => ({
     planFix: vi.fn(),
     applyFix: vi.fn()
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
 const basePlan = () => ({

package/dist/commands/update.js

@@ -1,5 +1,5 @@
 import { Command, Flags } from '@oclif/core';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
 import { getErrorMessage } from '#utils/error_utils.js';

package/dist/commands/update.spec.js

@@ -3,7 +3,7 @@ import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Update from './update.js';
 import { fetchLatestVersion, getGlobalInstalledVersion, getLocalInstalledVersion, updateGlobal, updateLocal, isOutdated } from '#services/npm_update_service.js';
 import { ensureClaudePlugin } from '#services/coding_agents.js';
-import { confirm } from '@inquirer/prompts';
+import { confirm } from '#utils/prompt.js';
 vi.mock('#services/npm_update_service.js', () => ({
     fetchLatestVersion: vi.fn(),
     getGlobalInstalledVersion: vi.fn(),
@@ -15,7 +15,7 @@ vi.mock('#services/npm_update_service.js', () => ({
 vi.mock('#services/coding_agents.js', () => ({
     ensureClaudePlugin: vi.fn()
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
 describe('update command', () => {

package/dist/commands/workflow/generate.js

@@ -4,6 +4,7 @@ import { buildWorkflow, buildWorkflowInteractiveLoop } from '#services/workflow_
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
+import { parseWorkflowDir } from '#utils/workflow_dir_parser.js';
 import path from 'node:path';
 import * as fsSync from 'node:fs';
 import { getErrorMessage } from '#utils/error_utils.js';
@@ -83,7 +84,8 @@ export default class Generate extends Command {
         this.displaySuccess(result);
     }
     displaySuccess(result) {
-        const message = getWorkflowGenerateSuccessMessage(result.workflowName, result.targetDir, result.filesCreated);
+        const dirInfo = parseWorkflowDir(result.targetDir);
+        const message = getWorkflowGenerateSuccessMessage(result.workflowName, dirInfo.workflowId ?? result.workflowName, dirInfo.scenarioNames[0], result.targetDir, result.filesCreated);
         this.log(message);
     }
 }

package/dist/commands/workflow/generate.spec.js

@@ -2,10 +2,13 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import Generate from './generate.js';
 import { generateWorkflow } from '#services/workflow_generator.js';
+import { parseWorkflowDir } from '#utils/workflow_dir_parser.js';
 import { InvalidNameError, WorkflowExistsError } from '#types/errors.js';
 vi.mock('../../services/workflow_generator.js');
+vi.mock('../../utils/workflow_dir_parser.js');
 describe('Generate Command', () => {
     let mockGenerateWorkflow;
+    let mockParseWorkflowDir;
     let logSpy;
     const createCommand = () => {
         const cmd = new Generate([], {});
@@ -20,6 +23,7 @@ describe('Generate Command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
         mockGenerateWorkflow = vi.mocked(generateWorkflow);
+        mockParseWorkflowDir = vi.mocked(parseWorkflowDir);
     });
     describe('successful workflow generation', () => {
         it('should generate workflow with skeleton flag', async () => {
@@ -38,6 +42,10 @@ describe('Generate Command', () => {
                 targetDir: '/tmp/test-workflow',
                 filesCreated: ['index.ts', 'steps.ts', 'types.ts']
             });
+            mockParseWorkflowDir.mockReturnValue({
+                workflowId: 'testWorkflow',
+                scenarioNames: ['test_input']
+            });
             await cmd.run();
             expect(mockGenerateWorkflow).toHaveBeenCalledWith({
                 name: 'test-workflow',
@@ -105,6 +113,10 @@ describe('Generate Command', () => {
                 targetDir: '/custom/path/my-workflow',
                 filesCreated: ['index.ts', 'steps.ts', 'types.ts']
             });
+            mockParseWorkflowDir.mockReturnValue({
+                workflowId: 'myWorkflow',
+                scenarioNames: ['test_input']
+            });
             await cmd.run();
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('SUCCESS!'));
             expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('my-workflow'));

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

@@ -6,6 +6,7 @@ interface WorkflowDisplay {
     inputs: string;
     outputs: string;
     scenarios: string;
+    aliases: string;
 }
 export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
 export default class WorkflowList extends Command {

package/dist/commands/workflow/list.js

@@ -17,7 +17,8 @@ export function parseWorkflowForDisplay(workflow) {
         description: parsed.description || 'No description',
         inputs: formatParameters(parsed.inputs),
         outputs: formatParameters(parsed.outputs),
-        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none'
+        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none',
+        aliases: workflow.aliases?.length ? workflow.aliases.join(', ') : 'none'
     };
 }
 function caseInsensitiveIncludes(str, filter) {
@@ -26,7 +27,10 @@ function caseInsensitiveIncludes(str, filter) {
 function matchName(filterString) {
     return workflow => {
         const name = workflow.name || '';
-        return caseInsensitiveIncludes(name, filterString);
+        if (caseInsensitiveIncludes(name, filterString)) {
+            return true;
+        }
+        return (workflow.aliases ?? []).some(alias => caseInsensitiveIncludes(alias, filterString));
     };
 }
 function sortWorkflowsByName(workflows) {
@@ -38,8 +42,8 @@ function sortWorkflowsByName(workflows) {
 }
 function createWorkflowTable(workflows, detailed) {
     const table = new Table({
-        head: ['Name', 'Description', 'Inputs', 'Outputs', 'Scenarios'],
-        colWidths: detailed ? [30, 42, 42, 42, 60] : [24, 30, 24, 24, 48],
+        head: ['Name', 'Description', 'Aliases', 'Inputs', 'Outputs', 'Scenarios'],
+        colWidths: detailed ? [28, 36, 36, 36, 36, 48] : [22, 26, 26, 22, 22, 36],
         wordWrap: true,
         style: {
             head: ['cyan']
@@ -49,13 +53,14 @@ function createWorkflowTable(workflows, detailed) {
     sortedWorkflows.forEach(workflow => {
         const display = parseWorkflowForDisplay(workflow);
         if (detailed) {
+            const aliases = workflow.aliases?.length ? workflow.aliases.join('\n') : 'none';
             const inputs = display.inputs.split(', ').join('\n');
             const outputs = display.outputs.split(', ').join('\n');
             const scenarios = display.scenarios.split(', ').join('\n');
-            table.push([display.name, display.description, inputs, outputs, scenarios]);
+            table.push([display.name, display.description, aliases, inputs, outputs, scenarios]);
         }
         else {
-            table.push([display.name, display.description, display.inputs, display.outputs, display.scenarios]);
+            table.push([display.name, display.description, display.aliases, display.inputs, display.outputs, display.scenarios]);
         }
     });
     return table.toString();
@@ -72,6 +77,7 @@ function formatWorkflowsAsJson(workflows) {
             return {
                 name: display.name,
                 description: display.description,
+                aliases: w.aliases ?? [],
                 inputs: display.inputs.split(', '),
                 outputs: display.outputs.split(', '),
                 scenarios: display.scenarios === 'none' ? [] : display.scenarios.split(', '),

package/dist/commands/workflow/list.spec.js

@@ -64,6 +64,27 @@ describe('workflow list parsing', () => {
         expect(parsed.inputs).toBe('none');
         expect(parsed.outputs).toBe('none');
         expect(parsed.scenarios).toBe('none');
+        expect(parsed.aliases).toBe('none');
+    });
+    it('should include aliases when present', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'aliased-workflow',
+            description: 'Has aliases',
+            aliases: ['old_name', 'legacy_name']
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.aliases).toBe('old_name, legacy_name');
+    });
+    it('should show none when aliases array is empty', async () => {
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'no-aliases',
+            description: 'Empty aliases',
+            aliases: []
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.aliases).toBe('none');
     });
     it('should include scenario names when scenarios exist', async () => {
         mockListScenarios.mockReturnValueOnce(['basic', 'advanced', 'stress_test']);

package/dist/commands/workflow/plan.js

@@ -1,5 +1,6 @@
 import { Command, Flags, ux } from '@oclif/core';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import { generatePlanName, updateAgentTemplates, writePlanFile } from '#services/workflow_planner.js';
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, PLAN_COMMAND_OPTIONS, replyToClaude } from '#services/claude_client.js';
@@ -45,6 +46,9 @@ export default class WorkflowPlan extends Command {
         this.log('=========');
         this.log(originalPlanContent);
         this.log('=========');
+        if (!isInteractive()) {
+            return originalPlanContent;
+        }
         const modifications = await input({
             message: ux.colorize('gray', `Reply or type ${acceptKey} to accept the plan as is: `),
             validate: (value) => value.length >= 10 || value === acceptKey

package/dist/commands/workflow/plan.spec.js

@@ -3,11 +3,12 @@ import WorkflowPlan from './plan.js';
 import { generatePlanName, writePlanFile, updateAgentTemplates } from '#services/workflow_planner.js';
 import { ensureOutputAISystem } from '#services/coding_agents.js';
 import { invokePlanWorkflow, replyToClaude, ClaudeInvocationError } from '#services/claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
 vi.mock('#services/workflow_planner.js');
 vi.mock('#services/coding_agents.js');
 vi.mock('#services/claude_client.js');
-vi.mock('@inquirer/prompts');
+vi.mock('#utils/prompt.js');
+vi.mock('#utils/interactive.js', () => ({ isInteractive: () => true }));
 describe('WorkflowPlan Command', () => {
     const createCommand = () => {
         const cmd = new WorkflowPlan([], {});

package/dist/commands/workflow/run.js

@@ -55,7 +55,8 @@ export default class WorkflowRun extends Command {
         }),
         'task-queue': Flags.string({
             char: 'q',
-            description: 'Task queue name for workflow execution'
+            description: 'Task queue name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
         }),
         format: Flags.string({
             char: 'f',

package/dist/commands/workflow/run.spec.js

@@ -13,6 +13,7 @@ vi.mock('#utils/sleep.js', () => ({
 describe('workflow run command', () => {
     beforeEach(async () => {
         vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
         const { resolveInput } = await import('#utils/resolve_input.js');
         const { sleep } = await import('#utils/sleep.js');
         vi.mocked(resolveInput).mockResolvedValue({});

package/dist/commands/workflow/start.js

@@ -28,7 +28,8 @@ export default class WorkflowStart extends Command {
         }),
         'task-queue': Flags.string({
             char: 'q',
-            description: 'Task queue name for workflow execution'
+            description: 'Task queue name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
         })
     };
     async run() {

package/dist/commands/workflow/start.spec.js

@@ -5,6 +5,7 @@ vi.mock('../../api/generated/api.js', () => ({
 describe('workflow start command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {

package/dist/components/command_footer.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export interface CommandHint {
+    key: string;
+    label: string;
+}
+export declare const CommandFooter: React.FC<{
+    hints: CommandHint[];
+}>;

package/dist/components/command_footer.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { Box, Text } from 'ink';
+export const CommandFooter = ({ hints }) => (_jsx(Box, { marginTop: 1, children: hints.map((hint, i) => (_jsxs(React.Fragment, { children: [i > 0 && _jsx(Text, { dimColor: true, children: ' | ' }), _jsx(Text, { dimColor: true, children: '(' }), _jsx(Text, { dimColor: true, bold: true, children: hint.key }), _jsx(Text, { dimColor: true, children: ')' }), _jsx(Text, { dimColor: true, children: ` ${hint.label}` })] }, hint.key))) }));

package/dist/components/status_icon.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+interface StatusDisplay {
+    icon: string;
+    color: string;
+}
+export declare const resolveStatus: (status: string) => StatusDisplay;
+export declare const statusColor: (status: string) => string;
+export declare const StatusIcon: React.FC<{
+    status: string;
+}>;
+export {};

package/dist/components/status_icon.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+const STATUS_MAP = {
+    // Docker service health
+    healthy: { icon: '●', color: 'green' },
+    unhealthy: { icon: '○', color: 'red' },
+    starting: { icon: '◐', color: 'yellow' },
+    none: { icon: '●', color: 'blue' },
+    exited: { icon: '✗', color: 'red' },
+    // Workflow run status
+    running: { icon: '●', color: 'blue' },
+    completed: { icon: '●', color: 'green' },
+    failed: { icon: '✗', color: 'red' },
+    canceled: { icon: '○', color: 'gray' },
+    terminated: { icon: '✗', color: 'red' },
+    timed_out: { icon: '✗', color: 'red' },
+    continued: { icon: '↻', color: 'blue' }
+};
+const DEFAULT_DISPLAY = { icon: '?', color: 'white' };
+export const resolveStatus = (status) => STATUS_MAP[status] ?? DEFAULT_DISPLAY;
+export const statusColor = (status) => resolveStatus(status).color;
+export const StatusIcon = ({ status }) => {
+    const { icon, color } = resolveStatus(status);
+    return _jsx(Text, { color: color, children: icon });
+};

package/dist/components/workflow_summary.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface WorkflowSummary {
+    running: number;
+    completed: number;
+    failed: number;
+    total: number;
+}
+export declare const WorkflowSummarySection: React.FC<{
+    summary: WorkflowSummary;
+}>;

package/dist/components/workflow_summary.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { statusColor } from '#components/status_icon.js';
+export const WorkflowSummarySection = ({ summary }) => (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "\uD83D\uDCCB Workflows" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: statusColor('running'), children: [summary.running, " running"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('failed'), children: [summary.failed, " failed"] }), _jsx(Text, { children: ", " }), _jsxs(Text, { color: statusColor('completed'), children: [summary.completed, " complete"] })] })] }));

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.12"
+    "framework": "0.1.13-dev.98dfd72.0"
 }

package/dist/hooks/init.js

@@ -1,6 +1,10 @@
 import { ux } from '@oclif/core';
 import { checkForUpdate } from '#services/version_check.js';
+import { setNonInteractive } from '#utils/interactive.js';
 const hook = async function () {
+    if (process.argv.includes('--yes') || process.argv.includes('--non-interactive') || !process.stdin.isTTY) {
+        setNonInteractive(true);
+    }
     try {
         const result = await checkForUpdate(this.config.version, this.config.cacheDir);
         if (!result.updateAvailable) {

package/dist/services/claude_client.js

@@ -105,7 +105,10 @@ function getTodoWriteMessage(message) {
     if (message.type !== 'assistant') {
         return null;
     }
-    const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
+    const todoWriteMessage = message.message.content.find((c) => {
+        const block = c;
+        return block.type === 'tool_use' && block.name === 'TodoWrite';
+    });
     return todoWriteMessage ?? null;
 }
 function applyInstructions(message, instructions) {

package/dist/services/coding_agents.js

@@ -7,7 +7,7 @@ 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 { confirm } from '#utils/prompt.js';
 import debugFactory from 'debug';
 import { getTemplateDir } from '#utils/paths.js';
 import { executeClaudeCommand } from '#utils/claude.js';