@outputai/cli 0.1.12 → 0.1.13-dev.2f0a972.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/docker.d.ts

@@ -21,8 +21,6 @@ export declare class DockerComposeConfigNotFoundError extends Error {
     constructor(dockerComposePath: string);
 }
 declare const isDockerInstalled: () => boolean;
-declare const isDockerComposeAvailable: () => boolean;
-declare const isDockerDaemonRunning: () => boolean;
 export declare function validateDockerEnvironment(): void;
 export declare function getDefaultDockerComposePath(): string;
 export declare function parseServiceStatus(jsonOutput: string): ServiceStatus[];
@@ -37,4 +35,4 @@ export type PullPolicy = 'always' | 'missing' | 'never';
 export declare function startDockerCompose(dockerComposePath: string, pullPolicy?: PullPolicy): Promise<DockerComposeProcess>;
 export declare function startDockerComposeDetached(dockerComposePath: string, pullPolicy?: PullPolicy): void;
 export declare function stopDockerCompose(dockerComposePath: string): Promise<void>;
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };
+export { isDockerInstalled, DockerValidationError };

package/dist/services/docker.js

@@ -2,6 +2,7 @@ import { execFileSync, execSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ux } from '@oclif/core';
+import semver from 'semver';
 const DEFAULT_COMPOSE_PATH = '../assets/docker/docker-compose-dev.yml';
 export const SERVICE_HEALTH = {
     HEALTHY: 'healthy',
@@ -30,27 +31,51 @@ const checkDockerCommand = (command) => {
         return false;
     }
 };
+const getCommandVersion = (command, pattern = /(\d+\.\d+\.\d+)/) => {
+    try {
+        const output = execSync(command, { stdio: 'pipe', encoding: 'utf-8' }).trim();
+        const match = output.match(pattern);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+};
 const isDockerInstalled = () => checkDockerCommand('docker --version');
-const isDockerComposeAvailable = () => checkDockerCommand('docker compose version');
-const isDockerDaemonRunning = () => checkDockerCommand('docker ps');
-const DOCKER_VALIDATIONS = [
+const PREREQUISITES = [
     {
-        check: isDockerInstalled,
-        error: 'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/'
+        name: 'Docker',
+        semverRange: '>=20.0.0',
+        getVersion: () => getCommandVersion('docker --version'),
+        errorMessage: (current, required) => current === null ?
+            'Docker is not installed. Please install Docker to use the dev command.\nVisit: https://docs.docker.com/get-docker/' :
+            `Docker version ${required} is required (found v${current}).\nVisit: https://docs.docker.com/get-docker/`
     },
     {
-        check: isDockerComposeAvailable,
-        error: 'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/'
+        name: 'Docker Compose',
+        semverRange: '>=2.24.0',
+        getVersion: () => getCommandVersion('docker compose version --short'),
+        errorMessage: (current, required) => current === null ?
+            'Docker Compose is not installed. Please install Docker Compose to use the dev command.\nVisit: https://docs.docker.com/compose/install/' :
+            `Docker Compose ${required} is required (found v${current}).\nPlease update Docker Compose: https://docs.docker.com/compose/install/`
     },
     {
-        check: isDockerDaemonRunning,
-        error: 'Docker daemon is not running. Please start Docker and try again.'
+        name: 'Docker Daemon',
+        semverRange: '*',
+        getVersion: () => checkDockerCommand('docker ps') ? '0.0.0' : null,
+        errorMessage: () => 'Docker daemon is not running. Please start Docker and try again.'
     }
 ];
 export function validateDockerEnvironment() {
-    const failedValidation = DOCKER_VALIDATIONS.find(v => !v.check());
-    if (failedValidation) {
-        throw new DockerValidationError(failedValidation.error);
+    for (const prereq of PREREQUISITES) {
+        const raw = prereq.getVersion();
+        const version = raw ? semver.valid(semver.coerce(raw)) : null;
+        if (!version) {
+            throw new DockerValidationError(prereq.errorMessage(null, prereq.semverRange));
+        }
+        if (!semver.satisfies(version, prereq.semverRange)) {
+            throw new DockerValidationError(prereq.errorMessage(version, prereq.semverRange));
+        }
     }
 }
 export function getDefaultDockerComposePath() {
@@ -129,4 +154,4 @@ export async function stopDockerCompose(dockerComposePath) {
     ux.stdout('⏹️  Stopping services...\n');
     execFileSync('docker', ['compose', '-f', dockerComposePath, 'down'], { stdio: 'inherit', cwd: process.cwd() });
 }
-export { isDockerInstalled, isDockerComposeAvailable, isDockerDaemonRunning, DockerValidationError };
+export { isDockerInstalled, DockerValidationError };

package/dist/services/messages.d.ts

@@ -3,4 +3,4 @@
  */
 export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
 export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, credentialsConfigured?: boolean) => string;
-export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;
+export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, workflowId: string, scenarioName: string | undefined, targetDir: string, filesCreated: string[]) => string;

package/dist/services/messages.js

@@ -234,7 +234,7 @@ ${ux.colorize('dim', '         to manage your project secrets.')}
 ${ux.colorize('green', ux.colorize('bold', 'Happy building with Output! 🚀'))}
 `;
 };
-export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, filesCreated) => {
+export const getWorkflowGenerateSuccessMessage = (workflowName, workflowId, scenarioName, targetDir, filesCreated) => {
     const divider = ux.colorize('dim', '─'.repeat(80));
     const bulletPoint = ux.colorize('green', '▸');
     const formattedFiles = filesCreated.map(file => {
@@ -256,7 +256,7 @@ export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, files
         },
         {
             step: 'Test your workflow',
-            command: `npx output workflow run ${workflowName} test_input`,
+            command: `npx output workflow run ${workflowId}${scenarioName ? ` ${scenarioName}` : ''}`,
             note: 'Run after starting services with "npx output dev"'
         }
     ];

package/dist/templates/agent_instructions/CLAUDE.md.template

@@ -4,16 +4,50 @@ This is an **Output.ai** project - a framework for building reliable, production
 
 ## Getting Started
 
-For full framework documentation, commands, and AI-assisted workflow development, install our Claude Code plugins:
+Install Claude Code plugins for full framework documentation and AI-assisted development:
 
 ```bash
 claude plugin marketplace add growthxai/output
 claude plugin install outputai@outputai --scope project
 ```
 
+## Commands
+
+```bash
+npm run output:dev           # Start dev environment (worker + Temporal)
+npm run output:worker:build  # Build TypeScript to dist/
+npm run output:worker:watch  # Build + restart on file changes
+npm run output:worker        # Install, build, and start worker
+```
+
+## Project Structure
+
+```
+src/
+  workflows/         # Each subfolder is one workflow
+    <name>/
+      workflow.ts    # Workflow orchestration (must be deterministic - no I/O)
+      steps.ts       # Step functions (all I/O: HTTP, LLM, DB)
+      evaluators.ts  # Evaluator functions (LLM-based quality assessment)
+      types.ts       # Zod schemas and TypeScript types
+      prompts/       # .prompt files (Liquid.js templates with YAML frontmatter)
+      scenarios/     # Test scenario JSON files
+  clients/           # Shared HTTP clients (use @outputai/http, not fetch/axios)
+  shared/            # Shared utilities across workflows
+config/
+  costs.yml              # Token/API pricing overrides
+  credentials.yml.enc    # Encrypted secrets (edit via: output credentials edit)
+  credentials.yml.template  # Credential structure reference
+```
+
+## Key Conventions
+
+- **Workflows are deterministic**: No I/O, no `Date.now()`, no `Math.random()` in `workflow.ts`. All side effects go in steps or evaluators.
+- **HTTP clients**: Always use `httpClient` from `@outputai/http` -- never raw `fetch` or `axios`. This enables automatic tracing and cost tracking.
+- **LLM calls**: Use `generateText` from `@outputai/llm` with `.prompt` files. Never call LLM APIs directly.
+
 ---
 
 ## Project-Specific Instructions
 
 <!-- Add your project-specific instructions below -->
-

package/dist/templates/agent_instructions/dotclaude/settings.json.template

@@ -4,8 +4,8 @@
       "WebFetch",
       "Bash(npx output:*)",
       "Bash(npm run output:*)",
-      "Skills(output*)",
-      "Skills(flow*)"
+      "Skill(output*)",
+      "Skill(outputai:*)"
     ]
   },
   "enabledPlugins": {

package/dist/utils/date_formatter.d.ts

@@ -14,7 +14,17 @@ export declare function formatDuration(ms: number): string;
  */
 export declare function formatDate(isoString: string | null | undefined): string;
 /**
- * Format a duration between two ISO timestamps
+ * Calculate elapsed milliseconds between two ISO timestamps.
+ * If completedAt is null/undefined, uses current time (for in-progress durations).
+ */
+export declare function elapsedMs(startedAt: string, completedAt?: string | null): number;
+/**
+ * Format a duration in milliseconds to a compact string that fits in narrow columns.
+ * Always returns a short single-token string (e.g., "150ms", "7.56s", "24.2m", "1.3h").
+ */
+export declare function formatDurationCompact(ms: number): string;
+/**
+ * Format a duration between two ISO timestamps.
  *
  * @param startedAt - ISO 8601 start timestamp
  * @param completedAt - ISO 8601 end timestamp (or null if still running)

package/dist/utils/date_formatter.js

@@ -33,7 +33,32 @@ export function formatDate(isoString) {
     return format(parseISO(isoString), 'MMM d, yyyy h:mm a');
 }
 /**
- * Format a duration between two ISO timestamps
+ * Calculate elapsed milliseconds between two ISO timestamps.
+ * If completedAt is null/undefined, uses current time (for in-progress durations).
+ */
+export function elapsedMs(startedAt, completedAt) {
+    const start = parseISO(startedAt).getTime();
+    const end = completedAt ? parseISO(completedAt).getTime() : Date.now();
+    return end - start;
+}
+/**
+ * Format a duration in milliseconds to a compact string that fits in narrow columns.
+ * Always returns a short single-token string (e.g., "150ms", "7.56s", "24.2m", "1.3h").
+ */
+export function formatDurationCompact(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    if (ms < 60_000) {
+        return `${(ms / 1000).toFixed(2)}s`;
+    }
+    if (ms < 3_600_000) {
+        return `${(ms / 60_000).toFixed(1)}m`;
+    }
+    return `${(ms / 3_600_000).toFixed(1)}h`;
+}
+/**
+ * Format a duration between two ISO timestamps.
  *
  * @param startedAt - ISO 8601 start timestamp
  * @param completedAt - ISO 8601 end timestamp (or null if still running)

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/dist/utils/open_url.d.ts

@@ -0,0 +1 @@
+export declare const openUrl: (url: string) => void;

package/dist/utils/open_url.js

@@ -0,0 +1,12 @@
+import { execFile } from 'node:child_process';
+export const openUrl = (url) => {
+    if (process.platform === 'darwin') {
+        execFile('open', [url]);
+    }
+    else if (process.platform === 'win32') {
+        execFile('cmd', ['/c', 'start', url]);
+    }
+    else {
+        execFile('xdg-open', [url]);
+    }
+};

package/dist/utils/workflow_dir_parser.d.ts

@@ -0,0 +1,5 @@
+export interface WorkflowDirInfo {
+    workflowId: string | undefined;
+    scenarioNames: string[];
+}
+export declare function parseWorkflowDir(targetDir: string): WorkflowDirInfo;

package/dist/utils/workflow_dir_parser.js

@@ -0,0 +1,39 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+const WORKFLOW_FILE_NAMES = ['workflow.ts', 'workflow.js'];
+const SCENARIOS_DIR = 'scenarios';
+const WORKFLOW_NAME_PATTERN = /name:\s*['"]([^'"]+)['"]/;
+function safeReadFile(filePath) {
+    try {
+        return readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function safeReadDir(dirPath) {
+    try {
+        return readdirSync(dirPath);
+    }
+    catch {
+        return [];
+    }
+}
+function parseWorkflowId(targetDir) {
+    const workflowFile = WORKFLOW_FILE_NAMES
+        .map(name => join(targetDir, name))
+        .find(existsSync);
+    const content = workflowFile ? safeReadFile(workflowFile) : '';
+    return WORKFLOW_NAME_PATTERN.exec(content)?.[1];
+}
+function listScenarioNames(targetDir) {
+    return safeReadDir(join(targetDir, SCENARIOS_DIR))
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace(/\.json$/, ''));
+}
+export function parseWorkflowDir(targetDir) {
+    return {
+        workflowId: parseWorkflowId(targetDir),
+        scenarioNames: listScenarioNames(targetDir)
+    };
+}

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

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

package/dist/utils/workflow_dir_parser.spec.js

@@ -0,0 +1,74 @@
+/* eslint-disable no-restricted-syntax, init-declarations */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { parseWorkflowDir } from './workflow_dir_parser.js';
+describe('parseWorkflowDir', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), 'workflow-dir-parser-'));
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('should extract workflow ID from workflow.ts', () => {
+        writeFileSync(join(tempDir, 'workflow.ts'), 'export default workflow( { name: \'myWorkflow\', description: \'test\' } );');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBe('myWorkflow');
+    });
+    it('should extract workflow ID from workflow.js', () => {
+        writeFileSync(join(tempDir, 'workflow.js'), 'export default workflow( { name: "blogGenerator", description: "test" } );');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBe('blogGenerator');
+    });
+    it('should prefer workflow.ts over workflow.js', () => {
+        writeFileSync(join(tempDir, 'workflow.ts'), 'export default workflow( { name: \'fromTs\' } );');
+        writeFileSync(join(tempDir, 'workflow.js'), 'export default workflow( { name: \'fromJs\' } );');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBe('fromTs');
+    });
+    it('should return undefined workflowId when no workflow file exists', () => {
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBeUndefined();
+    });
+    it('should return undefined workflowId when workflow file has no name property', () => {
+        writeFileSync(join(tempDir, 'workflow.ts'), 'export default workflow( { description: \'no name here\' } );');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBeUndefined();
+    });
+    it('should list scenario names from scenarios directory', () => {
+        const scenariosDir = join(tempDir, 'scenarios');
+        mkdirSync(scenariosDir);
+        writeFileSync(join(scenariosDir, 'test_input.json'), '{}');
+        writeFileSync(join(scenariosDir, 'edge_case.json'), '{}');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.scenarioNames).toEqual(expect.arrayContaining(['test_input', 'edge_case']));
+        expect(result.scenarioNames).toHaveLength(2);
+    });
+    it('should return empty scenarioNames when no scenarios directory exists', () => {
+        const result = parseWorkflowDir(tempDir);
+        expect(result.scenarioNames).toEqual([]);
+    });
+    it('should ignore non-json files in scenarios directory', () => {
+        const scenariosDir = join(tempDir, 'scenarios');
+        mkdirSync(scenariosDir);
+        writeFileSync(join(scenariosDir, 'test_input.json'), '{}');
+        writeFileSync(join(scenariosDir, 'README.md'), '# Scenarios');
+        const result = parseWorkflowDir(tempDir);
+        expect(result.scenarioNames).toEqual(['test_input']);
+    });
+    it('should handle multiline workflow files', () => {
+        writeFileSync(join(tempDir, 'workflow.ts'), `import { workflow } from '@outputai/core';
+
+export default workflow( {
+  name: 'complexWorkflow',
+  description: 'A complex workflow',
+  fn: async ( input ) => {
+    return input;
+  }
+} );`);
+        const result = parseWorkflowDir(tempDir);
+        expect(result.workflowId).toBe('complexWorkflow');
+    });
+});