@outputai/cli 0.1.4 → 0.1.5

package/dist/services/version_check.js

@@ -0,0 +1,52 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fetchLatestVersion, isOutdated } from '#services/npm_update_service.js';
+const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const CACHE_FILENAME = 'version_check.json';
+async function readCache(cacheDir, currentVersion) {
+    try {
+        const raw = await readFile(join(cacheDir, CACHE_FILENAME), 'utf-8');
+        const cache = JSON.parse(raw);
+        if (Date.now() - cache.timestamp > CACHE_TTL_MS) {
+            return null;
+        }
+        if (cache.result.currentVersion !== currentVersion) {
+            return null;
+        }
+        return cache.result;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(cacheDir, result) {
+    try {
+        await mkdir(cacheDir, { recursive: true });
+        const cache = { timestamp: Date.now(), result };
+        await writeFile(join(cacheDir, CACHE_FILENAME), JSON.stringify(cache));
+    }
+    catch {
+        // Silently ignore cache write failures
+    }
+}
+export async function checkForUpdate(currentVersion, cacheDir) {
+    if (cacheDir) {
+        const cached = await readCache(cacheDir, currentVersion);
+        if (cached) {
+            return cached;
+        }
+    }
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+        return { updateAvailable: false, currentVersion, latestVersion: currentVersion };
+    }
+    const result = {
+        updateAvailable: isOutdated(currentVersion, latestVersion),
+        currentVersion,
+        latestVersion
+    };
+    if (cacheDir) {
+        await writeCache(cacheDir, result);
+    }
+    return result;
+}

package/dist/services/version_check.spec.d.ts

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

package/dist/services/version_check.spec.js

@@ -0,0 +1,106 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { checkForUpdate } from './version_check.js';
+import { fetchLatestVersion, isOutdated } from '#services/npm_update_service.js';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+vi.mock('#services/npm_update_service.js', () => ({
+    fetchLatestVersion: vi.fn(),
+    isOutdated: vi.fn()
+}));
+vi.mock('node:fs/promises', () => ({
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn()
+}));
+describe('version_check', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkForUpdate', () => {
+        it('should return updateAvailable true when outdated', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            const result = await checkForUpdate('0.8.4');
+            expect(result).toEqual({
+                updateAvailable: true,
+                currentVersion: '0.8.4',
+                latestVersion: '1.0.0'
+            });
+        });
+        it('should return updateAvailable false when up to date', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue('0.8.4');
+            vi.mocked(isOutdated).mockReturnValue(false);
+            const result = await checkForUpdate('0.8.4');
+            expect(result).toEqual({
+                updateAvailable: false,
+                currentVersion: '0.8.4',
+                latestVersion: '0.8.4'
+            });
+        });
+        it('should return updateAvailable false when fetch fails', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue(null);
+            const result = await checkForUpdate('0.8.4');
+            expect(result.updateAvailable).toBe(false);
+            expect(isOutdated).not.toHaveBeenCalled();
+        });
+    });
+    describe('caching', () => {
+        const cacheDir = '/tmp/test-cache';
+        it('should return cached result when cache is fresh', async () => {
+            const cached = {
+                timestamp: Date.now() - 1000,
+                result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '1.0.0' }
+            };
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
+            const result = await checkForUpdate('0.8.4', cacheDir);
+            expect(result).toEqual(cached.result);
+            expect(fetchLatestVersion).not.toHaveBeenCalled();
+        });
+        it('should fetch fresh result when cache is expired', async () => {
+            const cached = {
+                timestamp: Date.now() - (5 * 60 * 60 * 1000), // 5 hours ago
+                result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '0.9.0' }
+            };
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            const result = await checkForUpdate('0.8.4', cacheDir);
+            expect(fetchLatestVersion).toHaveBeenCalled();
+            expect(result.latestVersion).toBe('1.0.0');
+        });
+        it('should fetch fresh result when cached version differs from current', async () => {
+            const cached = {
+                timestamp: Date.now() - 1000,
+                result: { updateAvailable: true, currentVersion: '0.8.4', latestVersion: '1.0.0' }
+            };
+            vi.mocked(readFile).mockResolvedValue(JSON.stringify(cached));
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            const result = await checkForUpdate('0.9.0', cacheDir);
+            expect(fetchLatestVersion).toHaveBeenCalled();
+            expect(result.currentVersion).toBe('0.9.0');
+        });
+        it('should fetch fresh result when cache file is missing', async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            const result = await checkForUpdate('0.8.4', cacheDir);
+            expect(fetchLatestVersion).toHaveBeenCalled();
+            expect(result.latestVersion).toBe('1.0.0');
+        });
+        it('should write cache after fresh fetch', async () => {
+            vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            await checkForUpdate('0.8.4', cacheDir);
+            expect(mkdir).toHaveBeenCalledWith(cacheDir, { recursive: true });
+            expect(writeFile).toHaveBeenCalled();
+        });
+        it('should skip caching when no cacheDir provided', async () => {
+            vi.mocked(fetchLatestVersion).mockResolvedValue('1.0.0');
+            vi.mocked(isOutdated).mockReturnValue(true);
+            await checkForUpdate('0.8.4');
+            expect(readFile).not.toHaveBeenCalled();
+            expect(writeFile).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/services/workflow_builder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * @param planFilePath - Absolute path to the plan file
+ * @param workflowDir - Absolute path to the workflow directory
+ * @param workflowName - Name of the workflow
+ * @param additionalInstructions - Optional additional instructions
+ * @returns Implementation output from claude-code
+ */
+export declare function buildWorkflow(planFilePath: string, workflowDir: string, workflowName: string, additionalInstructions?: string): Promise<string>;
+/**
+ * Interactive loop for refining workflow implementation
+ * Similar to the plan modification loop pattern
+ * @param originalOutput - Initial implementation output from claude-code
+ * @returns Final accepted output
+ */
+export declare function buildWorkflowInteractiveLoop(originalOutput: string): Promise<string>;

package/dist/services/workflow_builder.js

@@ -0,0 +1,86 @@
+/**
+ * Workflow builder service for implementing workflows from plan files
+ */
+import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
+import { input } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getErrorMessage } from '#utils/error_utils.js';
+const ACCEPT_KEY = 'ACCEPT';
+const SEPARATOR_LINE = '─'.repeat(80);
+function displayImplementationOutput(output, message) {
+    ux.stdout('\n');
+    ux.stdout(ux.colorize('green', message));
+    ux.stdout('\n');
+    ux.stdout(ux.colorize('dim', SEPARATOR_LINE));
+    ux.stdout(output);
+    ux.stdout(ux.colorize('dim', SEPARATOR_LINE));
+    ux.stdout('\n');
+}
+async function promptForModification() {
+    return input({
+        message: `Review the implementation. Type "${ACCEPT_KEY}" to accept, or describe modifications:`,
+        default: ACCEPT_KEY
+    });
+}
+function isAcceptCommand(modification) {
+    return modification.trim().toUpperCase() === ACCEPT_KEY;
+}
+function isEmpty(modification) {
+    return modification.trim() === '';
+}
+/**
+ * Build a workflow from a plan file using the /outputai:build_workflow slash command
+ * @param planFilePath - Absolute path to the plan file
+ * @param workflowDir - Absolute path to the workflow directory
+ * @param workflowName - Name of the workflow
+ * @param additionalInstructions - Optional additional instructions
+ * @returns Implementation output from claude-code
+ */
+export async function buildWorkflow(planFilePath, workflowDir, workflowName, additionalInstructions) {
+    try {
+        await fs.access(planFilePath);
+    }
+    catch {
+        throw new Error(`Plan file not found: ${planFilePath}`);
+    }
+    await fs.mkdir(workflowDir, { recursive: true });
+    const absolutePlanPath = path.resolve(planFilePath);
+    const absoluteWorkflowDir = path.resolve(workflowDir);
+    return invokeBuildWorkflowFromClient(absolutePlanPath, absoluteWorkflowDir, workflowName, additionalInstructions);
+}
+async function processModification(modification, currentOutput) {
+    if (isEmpty(modification)) {
+        ux.stdout(ux.colorize('yellow', 'Please provide modification instructions or type ACCEPT to continue.'));
+        return currentOutput;
+    }
+    try {
+        const updatedOutput = await replyToClaude(modification, BUILD_COMMAND_OPTIONS);
+        displayImplementationOutput(updatedOutput, '✓ Implementation updated!');
+        return updatedOutput;
+    }
+    catch (error) {
+        ux.error(`Failed to apply modifications: ${getErrorMessage(error)}`);
+        ux.stdout('Continuing with previous version...\n');
+        return currentOutput;
+    }
+}
+async function interactiveRefinementLoop(currentOutput) {
+    const modification = await promptForModification();
+    if (isAcceptCommand(modification)) {
+        return currentOutput;
+    }
+    const updatedOutput = await processModification(modification, currentOutput);
+    return interactiveRefinementLoop(updatedOutput);
+}
+/**
+ * Interactive loop for refining workflow implementation
+ * Similar to the plan modification loop pattern
+ * @param originalOutput - Initial implementation output from claude-code
+ * @returns Final accepted output
+ */
+export async function buildWorkflowInteractiveLoop(originalOutput) {
+    displayImplementationOutput(originalOutput, '✓ Workflow implementation complete!');
+    return interactiveRefinementLoop(originalOutput);
+}

package/dist/services/workflow_builder.spec.d.ts

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

package/dist/services/workflow_builder.spec.js

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
+import { BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
+import { input } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import fs from 'node:fs/promises';
+vi.mock('./claude_client.js');
+vi.mock('@inquirer/prompts');
+vi.mock('@oclif/core', () => ({
+    ux: {
+        stdout: vi.fn(),
+        error: vi.fn(),
+        colorize: vi.fn((_color, text) => text)
+    }
+}));
+vi.mock('node:fs/promises');
+describe('workflow-builder service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('buildWorkflow', () => {
+        it('should build workflow from plan file', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Implementation complete!');
+            const result = await buildWorkflow('/path/to/plan.md', '/path/to/workflows/test_workflow', 'test_workflow');
+            expect(fs.access).toHaveBeenCalledWith('/path/to/plan.md');
+            expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('test_workflow'), { recursive: true });
+            expect(invokeBuildWorkflow).toHaveBeenCalledWith(expect.stringContaining('plan.md'), expect.stringContaining('test_workflow'), 'test_workflow', undefined);
+            expect(result).toBe('Implementation complete!');
+        });
+        it('should pass additional instructions to claude-code', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done!');
+            await buildWorkflow('/plan.md', '/workflows', 'test', 'Use TypeScript only');
+            expect(invokeBuildWorkflow).toHaveBeenCalledWith(expect.any(String), expect.any(String), 'test', 'Use TypeScript only');
+        });
+        it('should throw error if plan file does not exist', async () => {
+            vi.mocked(fs.access).mockRejectedValue(new Error('ENOENT'));
+            await expect(buildWorkflow('/nonexistent/plan.md', '/workflows', 'test')).rejects.toThrow('Plan file not found: /nonexistent/plan.md');
+            expect(fs.mkdir).not.toHaveBeenCalled();
+            expect(invokeBuildWorkflow).not.toHaveBeenCalled();
+        });
+        it('should create workflow directory if it does not exist', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done');
+            await buildWorkflow('/plan.md', '/new/workflows/test', 'test');
+            expect(fs.mkdir).toHaveBeenCalledWith(expect.stringContaining('test'), { recursive: true });
+        });
+        it('should resolve paths to absolute paths', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockResolvedValue('Done');
+            await buildWorkflow('relative/plan.md', 'relative/workflows', 'test');
+            // Should call with absolute paths
+            const calls = vi.mocked(invokeBuildWorkflow).mock.calls[0];
+            expect(calls[0]).toMatch(/^[/\\]/); // Absolute path starts with / or \
+            expect(calls[1]).toMatch(/^[/\\]/); // Absolute path starts with / or \
+        });
+        it('should propagate errors from claude-code invocation', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(invokeBuildWorkflow).mockRejectedValue(new Error('Claude API timeout'));
+            await expect(buildWorkflow('/plan.md', '/workflows', 'test')).rejects.toThrow('Claude API timeout');
+        });
+        it('should handle directory creation failures', async () => {
+            vi.mocked(fs.access).mockResolvedValue(undefined);
+            vi.mocked(fs.mkdir).mockRejectedValue(new Error('Permission denied'));
+            await expect(buildWorkflow('/plan.md', '/workflows', 'test')).rejects.toThrow('Permission denied');
+        });
+    });
+    describe('buildWorkflowInteractiveLoop', () => {
+        it('should accept implementation immediately when user types ACCEPT', async () => {
+            vi.mocked(input).mockResolvedValue('ACCEPT');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(input).toHaveBeenCalledOnce();
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should accept implementation when user types lowercase accept', async () => {
+            vi.mocked(input).mockResolvedValue('accept');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should accept implementation with extra whitespace', async () => {
+            vi.mocked(input).mockResolvedValue('  ACCEPT  ');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(replyToClaude).not.toHaveBeenCalled();
+        });
+        it('should apply modifications and return updated implementation', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Add error handling')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockResolvedValue('Updated implementation with error handling');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(replyToClaude).toHaveBeenCalledWith('Add error handling', BUILD_COMMAND_OPTIONS);
+            expect(result).toBe('Updated implementation with error handling');
+            expect(input).toHaveBeenCalledTimes(2);
+        });
+        it('should handle multiple modification rounds', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Add logging')
+                .mockResolvedValueOnce('Add validation')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude)
+                .mockResolvedValueOnce('Implementation with logging')
+                .mockResolvedValueOnce('Implementation with logging and validation');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(replyToClaude).toHaveBeenCalledTimes(2);
+            expect(replyToClaude).toHaveBeenNthCalledWith(1, 'Add logging', BUILD_COMMAND_OPTIONS);
+            expect(replyToClaude).toHaveBeenNthCalledWith(2, 'Add validation', BUILD_COMMAND_OPTIONS);
+            expect(result).toBe('Implementation with logging and validation');
+        });
+        it('should prompt again when user provides empty input', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('')
+                .mockResolvedValueOnce('  ')
+                .mockResolvedValueOnce('ACCEPT');
+            const result = await buildWorkflowInteractiveLoop('Initial implementation');
+            expect(result).toBe('Initial implementation');
+            expect(input).toHaveBeenCalledTimes(3);
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('provide modification instructions'));
+        });
+        it('should display implementation output to user', async () => {
+            vi.mocked(input).mockResolvedValue('ACCEPT');
+            await buildWorkflowInteractiveLoop('Implementation summary');
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Implementation summary'));
+        });
+        it('should display updated implementation after modifications', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Improve performance')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockResolvedValue('Optimized implementation');
+            await buildWorkflowInteractiveLoop('Initial');
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Optimized implementation'));
+        });
+        it('should handle errors from replyToClaude gracefully', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Invalid modification')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude).mockRejectedValue(new Error('API error'));
+            const result = await buildWorkflowInteractiveLoop('Original implementation');
+            // Should return original implementation after error
+            expect(result).toBe('Original implementation');
+            expect(ux.error).toHaveBeenCalledWith(expect.stringContaining('Failed to apply modifications'));
+            expect(ux.stdout).toHaveBeenCalledWith(expect.stringContaining('Continuing with previous version'));
+        });
+        it('should continue looping after handling error', async () => {
+            vi.mocked(input)
+                .mockResolvedValueOnce('Bad request')
+                .mockResolvedValueOnce('Good request')
+                .mockResolvedValueOnce('ACCEPT');
+            vi.mocked(replyToClaude)
+                .mockRejectedValueOnce(new Error('API error'))
+                .mockResolvedValueOnce('Fixed implementation');
+            const result = await buildWorkflowInteractiveLoop('Initial');
+            expect(result).toBe('Fixed implementation');
+            expect(replyToClaude).toHaveBeenCalledTimes(2);
+        });
+    });
+});

package/dist/services/workflow_generator.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowGenerationConfig, WorkflowGenerationResult } from '#types/generator.js';
+/**
+ * Generate a new workflow
+ */
+export declare function generateWorkflow(config: WorkflowGenerationConfig): Promise<WorkflowGenerationResult>;

package/dist/services/workflow_generator.js

@@ -0,0 +1,40 @@
+import * as fs from 'node:fs/promises';
+import { WorkflowExistsError } from '#types/errors.js';
+import { createTargetDir, getTemplateDir } from '#utils/paths.js';
+import { validateWorkflowName, validateOutputDirectory } from '#utils/validation.js';
+import { prepareTemplateVariables } from '#utils/template.js';
+import { getTemplateFiles, processAllTemplates } from './template_processor.js';
+/**
+ * Validate the generation configuration
+ */
+function validateConfig(config) {
+    validateWorkflowName(config.name);
+    validateOutputDirectory(config.outputDir);
+}
+/**
+ * Check if target directory exists and handle accordingly
+ */
+import * as fsSync from 'node:fs';
+async function checkTargetDirectory(targetDir, force) {
+    if (fsSync.existsSync(targetDir) && !force) {
+        throw new WorkflowExistsError('', targetDir);
+    }
+}
+/**
+ * Generate a new workflow
+ */
+export async function generateWorkflow(config) {
+    validateConfig(config);
+    const targetDir = createTargetDir(config.outputDir, config.name);
+    const templatesDir = getTemplateDir('workflow');
+    await checkTargetDirectory(targetDir, config.force);
+    await fs.mkdir(targetDir, { recursive: true });
+    const variables = prepareTemplateVariables(config.name, config.description || '');
+    const templateFiles = await getTemplateFiles(templatesDir);
+    const filesCreated = await processAllTemplates(templateFiles, targetDir, variables);
+    return {
+        workflowName: config.name,
+        targetDir,
+        filesCreated
+    };
+}

package/dist/services/workflow_generator.spec.d.ts

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

package/dist/services/workflow_generator.spec.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-restricted-syntax, init-declarations */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { generateWorkflow } from './workflow_generator.js';
+describe('Workflow Generator', () => {
+    let tempDir;
+    beforeEach(async () => {
+        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'workflow-gen-test-'));
+    });
+    afterEach(async () => {
+        await fs.rm(tempDir, { recursive: true, force: true });
+    });
+    describe('skeleton generation', () => {
+        it('should create prompts folder with prompt template', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const promptPath = path.join(result.targetDir, 'prompts', 'example@v1.prompt');
+            const promptExists = await fs.access(promptPath).then(() => true).catch(() => false);
+            expect(promptExists).toBe(true);
+            expect(result.filesCreated).toContain('prompts/example@v1.prompt');
+        });
+        it('should create scenarios folder with test_input.json', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const scenarioPath = path.join(result.targetDir, 'scenarios', 'test_input.json');
+            const scenarioExists = await fs.access(scenarioPath).then(() => true).catch(() => false);
+            expect(scenarioExists).toBe(true);
+            expect(result.filesCreated).toContain('scenarios/test_input.json');
+        });
+        it('should create valid JSON in scenario file', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const scenarioPath = path.join(result.targetDir, 'scenarios', 'test_input.json');
+            const content = await fs.readFile(scenarioPath, 'utf-8');
+            const parsed = JSON.parse(content);
+            expect(parsed).toHaveProperty('text');
+        });
+        it('should create all expected skeleton files', async () => {
+            const result = await generateWorkflow({
+                name: 'testWorkflow',
+                description: 'Test workflow',
+                outputDir: tempDir,
+                skeleton: true,
+                force: false
+            });
+            const expectedFiles = [
+                'workflow.ts',
+                'steps.ts',
+                'evaluators.ts',
+                'types.ts',
+                'README.md',
+                'prompts/example@v1.prompt',
+                'scenarios/test_input.json'
+            ];
+            for (const file of expectedFiles) {
+                expect(result.filesCreated).toContain(file);
+            }
+        });
+    });
+});

package/dist/services/workflow_planner.d.ts

@@ -0,0 +1,15 @@
+export declare function generatePlanName(description: string, date?: Date): Promise<string>;
+/**
+ * Write plan content to PLAN.md file in the plans directory
+ * @param planName - Name of the plan (e.g., "2025_10_06_customer_order_processing")
+ * @param content - Plan content to write
+ * @param projectRoot - Root directory of the project
+ * @returns Full path to the created PLAN.md file
+ */
+export declare function writePlanFile(planName: string, content: string, projectRoot: string): Promise<string>;
+/**
+ * Update agent templates by reinitializing with force flag
+ * This recreates all agent configuration files, overwriting existing ones
+ * @param projectRoot - Root directory of the project
+ */
+export declare function updateAgentTemplates(projectRoot: string): Promise<void>;

package/dist/services/workflow_planner.js

@@ -0,0 +1,48 @@
+import { initializeAgentConfig } from './coding_agents.js';
+import { generateText } from '@outputai/llm';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { config } from '#config.js';
+export async function generatePlanName(description, date = new Date()) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const datePrefix = `${year}_${month}_${day}`;
+    const { text: planNameSlug } = await generateText({
+        prompt: 'generate_plan_name@v1',
+        variables: { description }
+    });
+    const cleanedName = planNameSlug
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .slice(0, 50);
+    return `${datePrefix}_${cleanedName}`;
+}
+/**
+ * Write plan content to PLAN.md file in the plans directory
+ * @param planName - Name of the plan (e.g., "2025_10_06_customer_order_processing")
+ * @param content - Plan content to write
+ * @param projectRoot - Root directory of the project
+ * @returns Full path to the created PLAN.md file
+ */
+export async function writePlanFile(planName, content, projectRoot) {
+    const planDir = path.join(projectRoot, config.agentConfigDir, 'plans', planName);
+    const planFilePath = path.join(planDir, 'PLAN.md');
+    await fs.mkdir(planDir, { recursive: true });
+    await fs.writeFile(planFilePath, content, 'utf-8');
+    return planFilePath;
+}
+/**
+ * Update agent templates by reinitializing with force flag
+ * This recreates all agent configuration files, overwriting existing ones
+ * @param projectRoot - Root directory of the project
+ */
+export async function updateAgentTemplates(projectRoot) {
+    await initializeAgentConfig({
+        projectRoot,
+        force: true
+    });
+}

package/dist/services/workflow_planner.spec.d.ts

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