@outputai/cli 0.1.13-next.320acd1.0 → 0.1.13-next.455ac5e.0

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.13-next.320acd1.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-next.455ac5e.0}
     init: true
     networks:
       - main

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

@@ -0,0 +1,16 @@
+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>;
+        yes: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    private confirmOverwrite;
+    run(): Promise<void>;
+}

package/dist/commands/credentials/set.js

@@ -0,0 +1,125 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { confirm } from '@inquirer/prompts';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
+import { getErrorMessage } from '#utils/error_utils.js';
+import { decryptCredentials, credentialsExist, writeEncrypted, resolveCredentialsPath } from '#services/credentials_service.js';
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const detectPathConflict = (obj, dotPath) => {
+    const parts = dotPath.split('.');
+    const intermediateKeys = parts.slice(0, -1);
+    const leafKey = parts[parts.length - 1];
+    const walked = intermediateKeys.reduce((state, key, i) => {
+        if (state.done) {
+            return state;
+        }
+        const next = state.cursor[key];
+        if (next === undefined) {
+            return { done: true, conflict: null };
+        }
+        if (!isPlainObject(next)) {
+            return {
+                done: true,
+                conflict: {
+                    kind: 'primitive_to_object',
+                    atPath: parts.slice(0, i + 1).join('.'),
+                    existingValue: next
+                }
+            };
+        }
+        return { done: false, cursor: next };
+    }, { done: false, cursor: obj });
+    if (walked.done) {
+        return walked.conflict;
+    }
+    const leaf = walked.cursor[leafKey];
+    if (leaf !== undefined && (isPlainObject(leaf) || Array.isArray(leaf))) {
+        return { kind: 'object_to_primitive', atPath: dotPath, existingValue: leaf };
+    }
+    return null;
+};
+const setNestedValue = (obj, dotPath, value) => {
+    const parts = dotPath.split('.');
+    const parent = parts.slice(0, -1).reduce((current, key) => {
+        if (!isPlainObject(current[key])) {
+            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'
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip confirmation prompts when overwriting a value of a different shape',
+            default: false
+        })
+    };
+    async confirmOverwrite(conflict, newPath) {
+        if (conflict.kind === 'primitive_to_object') {
+            this.warn(`Writing to "${newPath}" will convert "${conflict.atPath}" from a value into an object, ` +
+                `discarding its current value (${JSON.stringify(conflict.existingValue)}).`);
+        }
+        else {
+            this.warn(`Writing to "${newPath}" will replace the existing object at that path ` +
+                `(${JSON.stringify(conflict.existingValue)}) with a string value.`);
+        }
+        return confirm({ message: 'Continue?', default: false });
+    }
+    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.`);
+        }
+        try {
+            const plaintext = decryptCredentials(environment, workflow);
+            const data = (parseYaml(plaintext) || {});
+            const conflict = detectPathConflict(data, args.path);
+            if (conflict && !flags.yes) {
+                const shouldContinue = await this.confirmOverwrite(conflict, args.path);
+                if (!shouldContinue) {
+                    this.log('Aborted.');
+                    return;
+                }
+            }
+            setNestedValue(data, args.path, args.value);
+            writeEncrypted(environment, stringifyYaml(data), workflow);
+        }
+        catch (error) {
+            if (error instanceof Error && error.constructor.name === 'ExitPromptError') {
+                return;
+            }
+            this.error(`Failed to update credentials: ${getErrorMessage(error)}`);
+        }
+        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,160 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { confirm } from '@inquirer/prompts';
+import * as credentialsService from '#services/credentials_service.js';
+import CredentialsSet from './set.js';
+vi.mock('#services/credentials_service.js');
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn()
+}));
+vi.mock('js-yaml', () => ({
+    load: vi.fn((yaml) => {
+        if (yaml.includes('__PRIMITIVE_AT_X_Y__')) {
+            return { x: { y: 'FOO' } };
+        }
+        if (yaml.includes('__OBJECT_AT_X_Y__')) {
+            return { x: { y: { z: 'FOO' } } };
+        }
+        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(() => { });
+        vi.mocked(confirm).mockResolvedValue(true);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    const createTestCommand = (parsedArgs = {}, flags = {}) => {
+        const cmd = new CredentialsSet([], {});
+        cmd.log = vi.fn();
+        cmd.warn = 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, yes: false, ...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, workflow, and yes flags', () => {
+            expect(CredentialsSet.flags.environment).toBeDefined();
+            expect(CredentialsSet.flags.workflow).toBeDefined();
+            expect(CredentialsSet.flags.yes).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(confirm).not.toHaveBeenCalled();
+            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(confirm).not.toHaveBeenCalled();
+            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');
+        });
+        it('should surface a friendly error when decryption fails', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockImplementation(() => {
+                throw new Error('Invalid key');
+            });
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('Failed to update credentials: Invalid key');
+        });
+        it('should surface a friendly error when encryption fails', async () => {
+            vi.mocked(credentialsService.writeEncrypted).mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+            const cmd = createTestCommand();
+            await expect(cmd.run()).rejects.toThrow('Failed to update credentials: Permission denied');
+        });
+    });
+    describe('shape-change confirmation', () => {
+        it('should prompt before converting a primitive value into an object', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('convert "x.y" from a value into an object'));
+            expect(confirm).toHaveBeenCalledTimes(1);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set x.y.z');
+        });
+        it('should prompt before replacing an object with a primitive value', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__OBJECT_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y', value: 'BAR' });
+            await cmd.run();
+            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('replace the existing object'));
+            expect(confirm).toHaveBeenCalledTimes(1);
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+        });
+        it('should abort without writing when the user declines the prompt', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            vi.mocked(confirm).mockResolvedValue(false);
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' });
+            await cmd.run();
+            expect(credentialsService.writeEncrypted).not.toHaveBeenCalled();
+            expect(cmd.log).toHaveBeenCalledWith('Aborted.');
+            expect(cmd.log).not.toHaveBeenCalledWith('Set x.y.z');
+        });
+        it('should skip the prompt when --yes is passed', async () => {
+            vi.mocked(credentialsService.decryptCredentials).mockReturnValue('__PRIMITIVE_AT_X_Y__');
+            const cmd = createTestCommand({ path: 'x.y.z', value: 'BAR' }, { yes: true });
+            await cmd.run();
+            expect(confirm).not.toHaveBeenCalled();
+            expect(credentialsService.writeEncrypted).toHaveBeenCalledTimes(1);
+            expect(cmd.log).toHaveBeenCalledWith('Set x.y.z');
+        });
+    });
+});

package/dist/commands/workflow/plan.js

@@ -56,7 +56,7 @@ export default class WorkflowPlan extends Command {
         return this.planModificationLoop(modifiedPlanContent);
     }
     async planGenerationLoop(promptDescription, planName, projectRoot) {
-        this.log('\nInvoking the /outputai:plan_workflow command...');
+        this.log('\nInvoking the /output-plan-workflow command...');
         this.log('This may take a moment...\n');
         const planContent = await invokePlanWorkflow(promptDescription);
         const modifiedPlanContent = await this.planModificationLoop(planContent);

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.13-next.320acd1.0"
+    "framework": "0.1.13-next.455ac5e.0"
 }

package/dist/services/claude_client.d.ts

@@ -20,7 +20,7 @@ export declare class ClaudeInvocationError extends Error {
 }
 export declare function replyToClaude(message: string, { anthropicOpts, applyAdditionalInstructions }?: ReplyToClaudeOptions): Promise<string>;
 /**
- * Invoke claude-code with /outputai:plan_workflow slash command
+ * Invoke claude-code with /output-plan-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param description - Workflow description
@@ -28,7 +28,7 @@ export declare function replyToClaude(message: string, { anthropicOpts, applyAdd
  */
 export declare function invokePlanWorkflow(description: string): Promise<string>;
 /**
- * Invoke claude-code with /outputai:build_workflow slash command
+ * Invoke claude-code with /output-build-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param planFilePath - Absolute path to the plan file

package/dist/services/claude_client.integration.test.js

@@ -15,7 +15,7 @@ describe('invokePlanWorkflow - Integration Tests', () => {
         const messages = [];
         try {
             for await (const message of query({
-                prompt: `/outputai:plan_workflow ${description}`,
+                prompt: `/output-plan-workflow ${description}`,
                 options: { maxTurns: 1 }
             })) {
                 console.log('\nReceived message:', JSON.stringify(message, null, 2));
@@ -31,7 +31,7 @@ describe('invokePlanWorkflow - Integration Tests', () => {
         // This test is just for debugging - we expect messages
         expect(messages.length).toBeGreaterThan(0);
     }, 60000); // 60 second timeout
-    it('should successfully invoke /outputai:plan_workflow slash command and return content', async () => {
+    it('should successfully invoke /output-plan-workflow slash command and return content', async () => {
         const description = 'Simple workflow that takes a number and doubles it';
         const result = await invokePlanWorkflow(description);
         console.log('\n===== PLAN RESULT =====');

package/dist/services/claude_client.js

@@ -53,10 +53,9 @@ date: <plan-date>
 `
 };
 // Slash-command naming convention used by the outputai plugin:
-// - `outputai:<name>` — plugin commands under coding_assistants/.../commands/
-// - `output-<kebab-name>` — skills under coding_assistants/.../skills/, which surface as top-level slash commands without the plugin prefix.
-const PLAN_COMMAND = 'outputai:plan_workflow';
-const BUILD_COMMAND = 'outputai:build_workflow';
+// `output-<kebab-name>` — skills under coding_assistants/.../skills/, which surface as top-level slash commands without the plugin prefix.
+const PLAN_COMMAND = 'output-plan-workflow';
+const BUILD_COMMAND = 'output-build-workflow';
 const MIGRATE_COMMAND = 'output-migrate';
 const GLOBAL_CLAUDE_OPTIONS = {
     settingSources: ['user', 'project', 'local']
@@ -212,7 +211,7 @@ export async function replyToClaude(message, { anthropicOpts, applyAdditionalIns
     return singleQuery(applyInstructions(message, applyAdditionalInstructions), { continue: true, ...anthropicOpts });
 }
 /**
- * Invoke claude-code with /outputai:plan_workflow slash command
+ * Invoke claude-code with /output-plan-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param description - Workflow description
@@ -222,7 +221,7 @@ export async function invokePlanWorkflow(description) {
     return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`, ADDITIONAL_INSTRUCTIONS.PLAN), PLAN_COMMAND_OPTIONS);
 }
 /**
- * Invoke claude-code with /outputai:build_workflow slash command
+ * Invoke claude-code with /output-build-workflow slash command
  * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
  * ensureOutputAISystem() scaffolds the command files to that location.
  * @param planFilePath - Absolute path to the plan file

package/dist/services/claude_client.spec.js

@@ -13,7 +13,7 @@ describe('invokePlanWorkflow', () => {
         // Clean up environment variables
         delete process.env.ANTHROPIC_API_KEY;
     });
-    it('should invoke /outputai:plan_workflow slash command with settingSources', async () => {
+    it('should invoke /output-plan-workflow slash command with settingSources', async () => {
         const { query } = await import('@anthropic-ai/claude-agent-sdk');
         process.env.ANTHROPIC_API_KEY = 'test-key';
         async function* mockIterator() {
@@ -22,7 +22,7 @@ describe('invokePlanWorkflow', () => {
         vi.mocked(query).mockReturnValue(mockIterator());
         await invokePlanWorkflow('Test workflow');
         const calls = vi.mocked(query).mock.calls;
-        expect(calls[0]?.[0]?.prompt).toContain('/outputai:plan_workflow Test workflow');
+        expect(calls[0]?.[0]?.prompt).toContain('/output-plan-workflow Test workflow');
         expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
         expect(calls[0]?.[0]?.options?.allowedTools).toEqual(['Read', 'Grep', 'WebSearch', 'WebFetch', 'TodoWrite']);
     });
@@ -36,7 +36,7 @@ describe('invokePlanWorkflow', () => {
         const description = 'Build a user authentication system';
         await invokePlanWorkflow(description);
         const calls = vi.mocked(query).mock.calls;
-        expect(calls[0]?.[0]?.prompt).toContain(`/outputai:plan_workflow ${description}`);
+        expect(calls[0]?.[0]?.prompt).toContain(`/output-plan-workflow ${description}`);
         expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
     });
     it('should return plan output from claude-code', async () => {

package/dist/services/workflow_builder.d.ts

@@ -1,5 +1,5 @@
 /**
- * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * Build a workflow from a plan file using the /output-build-workflow slash command
  * @param planFilePath - Absolute path to the plan file
  * @param workflowDir - Absolute path to the workflow directory
  * @param workflowName - Name of the workflow

package/dist/services/workflow_builder.js

@@ -31,7 +31,7 @@ function isEmpty(modification) {
     return modification.trim() === '';
 }
 /**
- * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * Build a workflow from a plan file using the /output-build-workflow slash command
  * @param planFilePath - Absolute path to the plan file
  * @param workflowDir - Absolute path to the workflow directory
  * @param workflowName - Name of the workflow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.13-next.320acd1.0",
+  "version": "0.1.13-next.455ac5e.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -35,9 +35,9 @@
     "react": "19.2.5",
     "semver": "7.7.4",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.1.13-next.320acd1.0",
-    "@outputai/llm": "0.1.13-next.320acd1.0",
-    "@outputai/evals": "0.1.13-next.320acd1.0"
+    "@outputai/credentials": "0.1.13-next.455ac5e.0",
+    "@outputai/evals": "0.1.13-next.455ac5e.0",
+    "@outputai/llm": "0.1.13-next.455ac5e.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",