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

package/dist/services/datasets.test.js

@@ -0,0 +1,202 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import yaml from 'js-yaml';
+import { readDatasetFile, readAllDatasets, writeDataset, listDatasets } from './datasets.js';
+const ctx = { tmpDir: '' };
+beforeEach(async () => {
+    ctx.tmpDir = await mkdtemp(join(tmpdir(), 'output-datasets-test-'));
+});
+afterEach(async () => {
+    await rm(ctx.tmpDir, { recursive: true, force: true });
+});
+function writeYaml(filePath, obj) {
+    return writeFile(filePath, yaml.dump(obj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
+}
+// ---------------------------------------------------------------------------
+// readDatasetFile
+// ---------------------------------------------------------------------------
+describe('readDatasetFile', () => {
+    it('parses a multi-case file and returns all cases', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            case_a: { input: { query: 'foo' }, ground_truth: { expected: 1 } },
+            case_b: { input: { query: 'bar' } },
+            case_c: { input: { query: 'baz' }, ground_truth: { expected: 3 } }
+        });
+        const datasets = await readDatasetFile(filePath);
+        expect(datasets).toHaveLength(3);
+        expect(datasets.map(d => d.name)).toEqual(['case_a', 'case_b', 'case_c']);
+        expect(datasets[0].input).toEqual({ query: 'foo' });
+        expect(datasets[0].ground_truth).toEqual({ expected: 1 });
+    });
+    it('attaches _source with the absolute file path to each dataset', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            my_case: { input: { x: 1 } }
+        });
+        const [dataset] = await readDatasetFile(filePath);
+        expect(dataset._source).toBe(filePath);
+    });
+    it('throws when a case is missing input', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeYaml(filePath, {
+            good_case: { input: { x: 1 } },
+            bad_case: { ground_truth: { expected: 42 } }
+        });
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Dataset case "bad_case" in');
+    });
+    it('throws when file content is not an object', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeFile(filePath, 'just a string', 'utf-8');
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Invalid dataset file');
+    });
+    it('throws with clear message when file content is a YAML array', async () => {
+        const filePath = join(ctx.tmpDir, 'bad.yml');
+        await writeFile(filePath, '- foo\n- bar\n', 'utf-8');
+        await expect(readDatasetFile(filePath)).rejects.toThrow('Invalid dataset file');
+    });
+    it('preserves last_output and last_eval fields', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            cached_case: {
+                input: { q: 'hello' },
+                last_output: { output: { result: 42 }, executionTimeMs: 100, date: '2026-01-01T00:00:00.000Z' }
+            }
+        });
+        const [dataset] = await readDatasetFile(filePath);
+        expect(dataset.last_output?.output).toEqual({ result: 42 });
+        expect(dataset.last_output?.executionTimeMs).toBe(100);
+    });
+});
+// ---------------------------------------------------------------------------
+// readAllDatasets
+// ---------------------------------------------------------------------------
+describe('readAllDatasets', () => {
+    it('flattens cases from multiple files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), {
+            case_1: { input: { x: 1 } },
+            case_2: { input: { x: 2 } }
+        });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), {
+            case_3: { input: { x: 3 } }
+        });
+        const { datasets } = await readAllDatasets('my_workflow', undefined, ctx.tmpDir);
+        expect(datasets).toHaveLength(3);
+        expect(datasets.map(d => d.name).sort()).toEqual(['case_1', 'case_2', 'case_3']);
+    });
+    it('filters by case name across files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), {
+            case_1: { input: { x: 1 } },
+            case_2: { input: { x: 2 } }
+        });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), {
+            case_3: { input: { x: 3 } }
+        });
+        const { datasets } = await readAllDatasets('my_workflow', ['case_2', 'case_3'], ctx.tmpDir);
+        expect(datasets).toHaveLength(2);
+        expect(datasets.map(d => d.name).sort()).toEqual(['case_2', 'case_3']);
+    });
+    it('returns empty datasets and a default dir when workflow has no datasets dir', async () => {
+        const { datasets, dir } = await readAllDatasets('nonexistent_workflow', undefined, ctx.tmpDir);
+        expect(datasets).toHaveLength(0);
+        expect(dir).toContain('nonexistent_workflow');
+    });
+    it('throws when the same case name appears in two different files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'group_a.yml'), { case_1: { input: { x: 1 } } });
+        await writeYaml(join(datasetsDir, 'group_b.yml'), { case_1: { input: { x: 2 } } });
+        await expect(readAllDatasets('my_workflow', undefined, ctx.tmpDir)).rejects.toThrow('Duplicate dataset case name "case_1"');
+    });
+});
+// ---------------------------------------------------------------------------
+// writeDataset
+// ---------------------------------------------------------------------------
+describe('writeDataset', () => {
+    it('creates a new file with one case keyed by name', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        const dataset = { name: 'new_case', input: { q: 'hello' } };
+        await writeDataset(dataset, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('new_case');
+        expect(raw.new_case.input).toEqual({ q: 'hello' });
+        expect(raw.new_case).not.toHaveProperty('name');
+    });
+    it('does not write _source into the file', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        const dataset = { name: 'my_case', input: { q: 'x' }, _source: '/some/path.yml' };
+        await writeDataset(dataset, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw.my_case).not.toHaveProperty('_source');
+    });
+    it('updates only the target case, leaving other cases untouched', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            case_a: { input: { x: 1 }, ground_truth: { expected: 1 } },
+            case_b: { input: { x: 2 }, ground_truth: { expected: 2 } }
+        });
+        await writeDataset({ name: 'case_a', input: { x: 1 }, last_output: { output: { result: 1 }, date: '2026-01-01T00:00:00.000Z' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('case_b');
+        expect(raw.case_b.ground_truth).toEqual({ expected: 2 });
+    });
+    it('preserves existing fields when writing last_output then last_eval', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeYaml(filePath, {
+            my_case: { input: { q: 'hello' }, ground_truth: { expected: 42 } }
+        });
+        await writeDataset({ name: 'my_case', input: { q: 'hello' }, last_output: { output: { result: 42 }, executionTimeMs: 50, date: '2026-01-01T00:00:00.000Z' } }, filePath);
+        await writeDataset({
+            name: 'my_case', input: { q: 'hello' },
+            last_eval: { output: { datasetName: 'my_case', verdict: 'pass', evaluators: [] }, date: '2026-01-01T00:01:00.000Z' }
+        }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const caseObj = raw.my_case;
+        expect(caseObj).toHaveProperty('last_output');
+        expect(caseObj).toHaveProperty('last_eval');
+        expect(caseObj).toHaveProperty('ground_truth');
+    });
+    it('creates parent directories if they do not exist', async () => {
+        const filePath = join(ctx.tmpDir, 'deep', 'nested', 'cases.yml');
+        await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('my_case');
+    });
+    it('recovers gracefully when existing file contains non-object YAML', async () => {
+        const filePath = join(ctx.tmpDir, 'cases.yml');
+        await writeFile(filePath, 'just a string', 'utf-8');
+        await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
+        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        expect(raw).toHaveProperty('my_case');
+    });
+});
+// ---------------------------------------------------------------------------
+// listDatasets
+// ---------------------------------------------------------------------------
+describe('listDatasets', () => {
+    it('returns one DatasetInfo per case across all files', async () => {
+        const datasetsDir = join(ctx.tmpDir, 'src', 'workflows', 'my_workflow', 'tests', 'datasets');
+        await mkdir(datasetsDir, { recursive: true });
+        await writeYaml(join(datasetsDir, 'core.yml'), {
+            case_1: { input: { x: 1 }, last_output: { output: { r: 1 }, date: '2026-01-01T00:00:00.000Z' } },
+            case_2: { input: { x: 2 } }
+        });
+        const infos = await listDatasets('my_workflow', ctx.tmpDir);
+        expect(infos).toHaveLength(2);
+        const case1 = infos.find(i => i.name === 'case_1');
+        expect(case1.hasLastOutput).toBe(true);
+        expect(case1.path).toContain('core.yml');
+        const case2 = infos.find(i => i.name === 'case_2');
+        expect(case2.hasLastOutput).toBe(false);
+    });
+    it('returns empty array when no datasets directory exists', async () => {
+        const infos = await listDatasets('nonexistent_workflow', ctx.tmpDir);
+        expect(infos).toHaveLength(0);
+    });
+});

package/dist/services/env_configurator.js

@@ -1,4 +1,4 @@
-import { input, confirm, password } from '#utils/prompt.js';
+import { input, confirm, password } from '@inquirer/prompts';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ux } from '@oclif/core';

package/dist/services/env_configurator.spec.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { configureEnvironmentVariables } from './env_configurator.js';
 // Mock inquirer prompts
-vi.mock('#utils/prompt.js', () => ({
+vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
     confirm: vi.fn(),
     password: vi.fn()
@@ -45,7 +45,7 @@ describe('configureEnvironmentVariables', () => {
         expect(result).toBe(false);
     });
     it('should return false if user declines configuration', async () => {
-        const { confirm } = await import('#utils/prompt.js');
+        const { confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(false);
         await fs.writeFile(testState.envExamplePath, '# API key\nAPIKEY=');
         const result = await configureEnvironmentVariables(testState.tempDir, false);
@@ -53,14 +53,14 @@ describe('configureEnvironmentVariables', () => {
         expect(vi.mocked(confirm)).toHaveBeenCalled();
     });
     it('should return false if no empty variables exist', async () => {
-        const { confirm } = await import('#utils/prompt.js');
+        const { confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         await fs.writeFile(testState.envExamplePath, 'APIKEY=my-secret-key');
         const result = await configureEnvironmentVariables(testState.tempDir, false);
         expect(result).toBe(false);
     });
     it('should copy .env.example to .env when user confirms configuration', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -72,7 +72,7 @@ APIKEY=`;
         await expect(fs.access(testState.envPath)).resolves.toBeUndefined();
     });
     it('should write configured values to .env while leaving .env.example unchanged', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -88,7 +88,7 @@ APIKEY=`;
         expect(envExampleContent).toBe(originalContent);
     });
     it('should prompt for empty variables and update .env', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         vi.mocked(input).mockResolvedValueOnce('');
@@ -105,7 +105,7 @@ OPENAI_API_KEY=`);
         expect(content).toContain('OPENAI_API_KEY=');
     });
     it('should preserve comments in .env file', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('test-key');
         const originalContent = `# This is a comment
@@ -123,7 +123,7 @@ OTHER=value`;
         expect(content).toContain('OTHER=value');
     });
     it('should skip placeholder values and only prompt for truly empty variables', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `APIKEY=your_api_key_here
@@ -136,7 +136,7 @@ EMPTY_KEY=`);
         }));
     });
     it('should skip variables with existing values', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `EXISTING_KEY=existing-value
@@ -147,7 +147,7 @@ EMPTY_KEY=`);
         expect(vi.mocked(input)).toHaveBeenCalledTimes(1);
     });
     it('should handle case where .env already exists (overwrite with copy)', async () => {
-        const { input, confirm } = await import('#utils/prompt.js');
+        const { input, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-configured-value');
         // Create existing .env with old content
@@ -162,7 +162,7 @@ EMPTY_KEY=`);
         expect(envContent).not.toContain('OLD_KEY');
     });
     it('should return false if an error occurs during parsing', async () => {
-        const { confirm } = await import('#utils/prompt.js');
+        const { confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         await fs.writeFile(testState.envExamplePath, 'KEY=');
         // Delete the .env.example file after access check but before parsing would happen
@@ -178,7 +178,7 @@ EMPTY_KEY=`);
         vi.mocked(fs.copyFile).mockImplementation(originalCopyFile);
     });
     it('should prompt for SECRET marker values with password input', async () => {
-        const { password, confirm } = await import('#utils/prompt.js');
+        const { password, confirm } = await import('@inquirer/prompts');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(password).mockResolvedValueOnce('my-secret-api-key');
         await fs.writeFile(testState.envExamplePath, `# API Key

package/dist/services/project_scaffold.js

@@ -1,4 +1,4 @@
-import { input, confirm } from '#utils/prompt.js';
+import { input, confirm } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import { kebabCase, pascalCase } from 'change-case';
 import fs from 'node:fs/promises';
@@ -41,7 +41,7 @@ export async function checkDependencies() {
     try {
         const shouldProceed = await confirm({
             message: 'Would you like to proceed anyway?',
-            default: true
+            default: false
         });
         if (!shouldProceed) {
             throw new UserCancelledError();

package/dist/services/project_scaffold.spec.js

@@ -8,7 +8,7 @@ vi.mock('#utils/framework_version.js', () => ({
     })
 }));
 // Mock other dependencies
-vi.mock('#utils/prompt.js', () => ({
+vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
     confirm: vi.fn()
 }));
@@ -47,7 +47,7 @@ describe('project_scaffold', () => {
     });
     describe('getProjectConfig', () => {
         it('should skip all prompts when folderName is provided', async () => {
-            const { input } = await import('#utils/prompt.js');
+            const { input } = await import('@inquirer/prompts');
             const config = await getProjectConfig('my-project');
             expect(config.folderName).toBe('my-project');
             expect(config.projectName).toBe('my-project');
@@ -58,7 +58,7 @@ describe('project_scaffold', () => {
             expect(config.description).toBe('AI Agents & Workflows built with Output.ai for test-folder');
         });
         it('should prompt for project name and folder name when not provided', async () => {
-            const { input } = await import('#utils/prompt.js');
+            const { input } = await import('@inquirer/prompts');
             vi.mocked(input)
                 .mockResolvedValueOnce('Test Project')
                 .mockResolvedValueOnce('test-project');
@@ -73,7 +73,7 @@ describe('project_scaffold', () => {
         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('#utils/prompt.js');
+            const { confirm } = await import('@inquirer/prompts');
             vi.mocked(isDockerInstalled).mockReturnValue(true);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             await checkDependencies();
@@ -82,7 +82,7 @@ describe('project_scaffold', () => {
         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('#utils/prompt.js');
+            const { confirm } = await import('@inquirer/prompts');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(true);
@@ -94,7 +94,7 @@ describe('project_scaffold', () => {
         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('#utils/prompt.js');
+            const { confirm } = await import('@inquirer/prompts');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(false);

package/dist/services/workflow_builder.js

@@ -2,8 +2,7 @@
  * Workflow builder service for implementing workflows from plan files
  */
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
-import { input } from '#utils/prompt.js';
-import { isInteractive } from '#utils/interactive.js';
+import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -71,9 +70,6 @@ async function processModification(modification, currentOutput) {
     }
 }
 async function interactiveRefinementLoop(currentOutput) {
-    if (!isInteractive()) {
-        return currentOutput;
-    }
     const modification = await promptForModification();
     if (isAcceptCommand(modification)) {
         return currentOutput;

package/dist/services/workflow_builder.spec.js

@@ -1,12 +1,11 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
-import { input } from '#utils/prompt.js';
+import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 vi.mock('./claude_client.js');
-vi.mock('#utils/prompt.js');
-vi.mock('#utils/interactive.js', () => ({ isInteractive: () => true }));
+vi.mock('@inquirer/prompts');
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),

package/dist/utils/format_workflow_result.d.ts

@@ -1,5 +1,5 @@
-import type { GetWorkflowIdResult200, GetWorkflowIdResult200Status } from '../api/generated/api.js';
-type WorkflowResult = Pick<GetWorkflowIdResult200, 'workflowId' | 'output' | 'status' | 'error'>;
-export declare const ERROR_STATUSES: ReadonlySet<GetWorkflowIdResult200Status | undefined>;
+import type { WorkflowResultResponse, WorkflowResultResponseStatus } from '../api/generated/api.js';
+type WorkflowResult = Pick<WorkflowResultResponse, 'workflowId' | 'output' | 'status' | 'error'>;
+export declare const ERROR_STATUSES: ReadonlySet<WorkflowResultResponseStatus | undefined>;
 export declare function formatWorkflowResult(result: WorkflowResult): string;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.13-dev.98dfd72.0",
+  "version": "0.1.13-dev.e3e3291.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -34,11 +34,10 @@
     "ky": "1.14.3",
     "react": "19.2.4",
     "semver": "7.7.4",
-    "undici": "8.0.2",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.1.13-dev.98dfd72.0",
-    "@outputai/evals": "0.1.13-dev.98dfd72.0",
-    "@outputai/llm": "0.1.13-dev.98dfd72.0"
+    "@outputai/evals": "0.1.13-dev.e3e3291.0",
+    "@outputai/credentials": "0.1.13-dev.e3e3291.0",
+    "@outputai/llm": "0.1.13-dev.e3e3291.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",

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

@@ -1,14 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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.js

@@ -1,95 +0,0 @@
-/* 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/utils/interactive.d.ts

@@ -1,2 +0,0 @@
-export declare const setNonInteractive: (value: boolean) => void;
-export declare const isInteractive: () => boolean;

package/dist/utils/interactive.js

@@ -1,5 +0,0 @@
-const state = { nonInteractive: false };
-export const setNonInteractive = (value) => {
-    state.nonInteractive = value;
-};
-export const isInteractive = () => !state.nonInteractive && !!process.stdin.isTTY;

package/dist/utils/interactive.spec.d.ts

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