@outputai/cli 0.1.13-next.6e35f5c.0 → 0.1.13-next.91c5d78.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.6e35f5c.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.1.13-next.91c5d78.0}
     init: true
     networks:
       - main

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/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.1.13-next.6e35f5c.0"
+    "framework": "0.1.13-next.91c5d78.0"
 }

package/dist/services/claude_client.js

@@ -105,7 +105,7 @@ 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) => c.type === 'tool_use' && c.name === 'TodoWrite');
     return todoWriteMessage ?? null;
 }
 function applyInstructions(message, instructions) {

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/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');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.1.13-next.6e35f5c.0",
+  "version": "0.1.13-next.91c5d78.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -14,30 +14,30 @@
     "output": "./bin/run.js"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.85",
-    "@aws-sdk/client-s3": "3.1018.0",
+    "@anthropic-ai/claude-agent-sdk": "0.2.92",
+    "@aws-sdk/client-s3": "3.1024.0",
     "@hackylabs/deep-redact": "3.0.5",
     "@inquirer/prompts": "8.3.2",
-    "@oclif/core": "4.10.3",
-    "@oclif/plugin-help": "6.2.40",
+    "@oclif/core": "4.10.5",
+    "@oclif/plugin-help": "6.2.42",
     "change-case": "5.4.4",
     "cli-progress": "3.12.0",
     "cli-table3": "0.6.5",
     "date-fns": "4.1.0",
     "debug": "4.4.3",
-    "dotenv": "17.3.1",
+    "dotenv": "17.4.0",
     "handlebars": "4.7.9",
-    "js-yaml": "4.1.1",
     "ink": "6.8.0",
     "ink-spinner": "5.0.0",
-    "json-schema-library": "11.0.5",
+    "js-yaml": "4.1.1",
+    "json-schema-library": "11.1.0",
     "ky": "1.14.3",
     "react": "19.2.4",
     "semver": "7.7.4",
     "yaml": "^2.8.3",
-    "@outputai/evals": "0.1.13-next.6e35f5c.0",
-    "@outputai/credentials": "0.1.13-next.6e35f5c.0",
-    "@outputai/llm": "0.1.13-next.6e35f5c.0"
+    "@outputai/credentials": "0.1.13-next.91c5d78.0",
+    "@outputai/evals": "0.1.13-next.91c5d78.0",
+    "@outputai/llm": "0.1.13-next.91c5d78.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",