@outputai/cli 0.1.12-next.ecd4dda.0 → 0.1.13-dev.01b8dea.0

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

@@ -3,10 +3,9 @@
     "allow": [
       "WebFetch",
       "Bash(npx output:*)",
-      "Bash(npm run dev)",
       "Bash(npm run output:*)",
-      "Skills(output*)",
-      "Skills(flow*)"
+      "Skill(output*)",
+      "Skill(outputai:*)"
     ]
   },
   "enabledPlugins": {

package/dist/templates/project/README.md.template

@@ -72,7 +72,7 @@ Add your keys in the editor:
 ### 3. Start Output Services
 
 ```bash
-npm run dev
+npm run output:dev
 ```
 
 This starts:
@@ -91,7 +91,7 @@ npx output workflow run blog_evaluator paulgraham_hwh
 
 ### 5. Stop Services
 
-Press `Ctrl+C` in the terminal running `npm run dev` to stop all services gracefully.
+Press `Ctrl+C` in the terminal running `npm run output:dev` to stop all services gracefully.
 
 ### 6. View Logs
 

package/dist/templates/project/package.json.template

@@ -6,18 +6,19 @@
   "main": "dist/worker.js",
   "scripts": {
     "output:worker:install": "npm install",
-    "output:worker:build": "rm -rf dist/* && tsc -p ./ && copyfiles './src/**/*.prompt' './src/**/*.yml.enc' './src/**/*.key' dist -u 1",
+    "output:worker:build": "rm -rf dist/* && tsc -p ./ && output-copy-assets",
     "output:worker:start": "output-worker",
-    "dev": "output dev"
+    "output:worker": "npm run output:worker:install && npm run output:worker:build && npm run output:worker:start",
+    "output:worker:watch": "npx nodemon --watch src --watch package.json --ext ts,js,json,prompt,md --ignore 'dist/**' --ignore '**/*.spec.*' --ignore '**/*.test.*' --exec 'npm run output:worker'",
+    "output:dev": "output dev"
   },
   "dependencies": {
-    "@outputai/output": "^{{frameworkVersion}}"
+    "@outputai/output": "{{frameworkVersion}}"
   },
   "devDependencies": {
-    "@types/node": "^24.0.0",
-    "native-copyfiles": "2.0.1",
-    "nodemon": "3.1.0",
-    "typescript": "^5.7.0"
+    "@types/node": "24.5.2",
+    "nodemon": "3.1.14",
+    "typescript": "5.9.3"
   },
   "engines": {
     "node": ">=24.3.0"

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/interactive.d.ts

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

package/dist/utils/interactive.js

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

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

package/dist/utils/interactive.spec.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+describe('interactive', () => {
+    beforeEach(async () => {
+        // Re-import to reset singleton state
+        const mod = await import('./interactive.js');
+        mod.setNonInteractive(false);
+    });
+    it('isInteractive returns true by default when TTY is available', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false when no TTY', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: undefined, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false after setNonInteractive(true)', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('setNonInteractive(false) restores interactive mode', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        setNonInteractive(false);
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+});

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/prompt.d.ts

@@ -0,0 +1,17 @@
+type ConfirmOptions = {
+    message: string;
+    default?: boolean;
+};
+type InputOptions = {
+    message: string;
+    default?: string;
+    validate?: (value: string) => boolean | string;
+};
+type PasswordOptions = {
+    message: string;
+    mask?: boolean;
+};
+export declare const confirm: (options: ConfirmOptions) => Promise<boolean>;
+export declare const input: (options: InputOptions) => Promise<string>;
+export declare const password: (options: PasswordOptions) => Promise<string>;
+export {};

package/dist/utils/prompt.js

@@ -0,0 +1,20 @@
+import { confirm as inquirerConfirm, input as inquirerInput, password as inquirerPassword } from '@inquirer/prompts';
+import { isInteractive } from './interactive.js';
+export const confirm = async (options) => {
+    if (!isInteractive()) {
+        return options.default ?? true;
+    }
+    return inquirerConfirm(options);
+};
+export const input = async (options) => {
+    if (!isInteractive()) {
+        return options.default ?? '';
+    }
+    return inquirerInput(options);
+};
+export const password = async (options) => {
+    if (!isInteractive()) {
+        return '';
+    }
+    return inquirerPassword(options);
+};

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

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

package/dist/utils/prompt.spec.js

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { confirm as inquirerConfirm, input as inquirerInput, password as inquirerPassword } from '@inquirer/prompts';
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn(),
+    input: vi.fn(),
+    password: vi.fn()
+}));
+vi.mock('./interactive.js', () => ({
+    isInteractive: vi.fn()
+}));
+describe('prompt wrapper', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('when interactive', () => {
+        beforeEach(async () => {
+            const { isInteractive } = await import('./interactive.js');
+            vi.mocked(isInteractive).mockReturnValue(true);
+        });
+        it('confirm delegates to inquirer', async () => {
+            vi.mocked(inquirerConfirm).mockResolvedValue(false);
+            const { confirm } = await import('./prompt.js');
+            const result = await confirm({ message: 'Continue?', default: true });
+            expect(inquirerConfirm).toHaveBeenCalledWith({ message: 'Continue?', default: true });
+            expect(result).toBe(false);
+        });
+        it('input delegates to inquirer', async () => {
+            vi.mocked(inquirerInput).mockResolvedValue('user input');
+            const { input } = await import('./prompt.js');
+            const result = await input({ message: 'Name?', default: 'default' });
+            expect(inquirerInput).toHaveBeenCalledWith({ message: 'Name?', default: 'default' });
+            expect(result).toBe('user input');
+        });
+        it('password delegates to inquirer', async () => {
+            vi.mocked(inquirerPassword).mockResolvedValue('secret');
+            const { password } = await import('./prompt.js');
+            const result = await password({ message: 'Token?' });
+            expect(inquirerPassword).toHaveBeenCalledWith({ message: 'Token?' });
+            expect(result).toBe('secret');
+        });
+    });
+    describe('when non-interactive', () => {
+        beforeEach(async () => {
+            const { isInteractive } = await import('./interactive.js');
+            vi.mocked(isInteractive).mockReturnValue(false);
+        });
+        it('confirm returns default value', async () => {
+            const { confirm } = await import('./prompt.js');
+            expect(await confirm({ message: 'Continue?', default: false })).toBe(false);
+            expect(await confirm({ message: 'Continue?', default: true })).toBe(true);
+            expect(inquirerConfirm).not.toHaveBeenCalled();
+        });
+        it('confirm defaults to true when no default specified', async () => {
+            const { confirm } = await import('./prompt.js');
+            expect(await confirm({ message: 'Continue?' })).toBe(true);
+            expect(inquirerConfirm).not.toHaveBeenCalled();
+        });
+        it('input returns default value', async () => {
+            const { input } = await import('./prompt.js');
+            expect(await input({ message: 'Name?', default: 'fallback' })).toBe('fallback');
+            expect(inquirerInput).not.toHaveBeenCalled();
+        });
+        it('input returns empty string when no default', async () => {
+            const { input } = await import('./prompt.js');
+            expect(await input({ message: 'Name?' })).toBe('');
+            expect(inquirerInput).not.toHaveBeenCalled();
+        });
+        it('password returns empty string', async () => {
+            const { password } = await import('./prompt.js');
+            expect(await password({ message: 'Token?' })).toBe('');
+            expect(inquirerPassword).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/utils/proxy.d.ts

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

package/dist/utils/proxy.js

@@ -0,0 +1,9 @@
+import { EnvHttpProxyAgent, setGlobalDispatcher } from 'undici';
+export const bootstrapProxy = () => {
+    const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy ||
+        process.env.HTTP_PROXY || process.env.http_proxy;
+    if (!proxyUrl) {
+        return;
+    }
+    setGlobalDispatcher(new EnvHttpProxyAgent());
+};

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

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

package/dist/utils/proxy.spec.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+const mockSetGlobalDispatcher = vi.fn();
+const MockEnvHttpProxyAgent = vi.fn();
+vi.mock('undici', () => ({
+    EnvHttpProxyAgent: MockEnvHttpProxyAgent,
+    setGlobalDispatcher: mockSetGlobalDispatcher
+}));
+describe('proxy bootstrap', () => {
+    const originalEnv = { ...process.env };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.HTTPS_PROXY;
+        delete process.env.https_proxy;
+        delete process.env.HTTP_PROXY;
+        delete process.env.http_proxy;
+    });
+    afterEach(() => {
+        process.env = { ...originalEnv };
+    });
+    it('does nothing when no proxy env vars are set', async () => {
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(mockSetGlobalDispatcher).not.toHaveBeenCalled();
+    });
+    it('sets global dispatcher when HTTPS_PROXY is set', async () => {
+        process.env.HTTPS_PROXY = 'http://proxy:8080';
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
+        expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
+    });
+    it('sets global dispatcher when HTTP_PROXY is set', async () => {
+        process.env.HTTP_PROXY = 'http://proxy:8080';
+        const { bootstrapProxy } = await import('./proxy.js');
+        bootstrapProxy();
+        expect(MockEnvHttpProxyAgent).toHaveBeenCalled();
+        expect(mockSetGlobalDispatcher).toHaveBeenCalledTimes(1);
+    });
+});

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