@output.ai/cli 0.0.4 → 0.0.5

package/dist/services/generate_plan_name@v1.prompt

@@ -0,0 +1,24 @@
+---
+provider: anthropic
+model: claude-sonnet-4-20250514
+temperature: 0.3
+---
+
+<assistant>
+You are a semantic naming assistant. Generate concise, descriptive slugs for workflow plans.
+</assistant>
+
+<user>
+Convert this workflow description into a short, semantic slug (2-6 words max):
+
+"{{ description }}"
+
+Requirements:
+- Use snake_case format
+- Be descriptive but concise
+- Focus on the core action/purpose
+- Use common technical terms
+- Maximum 50 characters
+
+Return ONLY the slug, no quotes, no explanation.
+</user>

package/dist/services/workflow_planner.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Ensure .outputai directory structure exists by invoking agents init if needed
+ * @throws Error if user declines to initialize or if initialization fails
+ */
+export declare function ensureOutputAIStructure(projectRoot: string): Promise<void>;
+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 invoking agents init 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,83 @@
+import { checkAgentStructure, initializeAgentConfig } from './coding_agents.js';
+import { confirm } from '@inquirer/prompts';
+import { generateText } from 'local_llm';
+import { loadPrompt } from 'local_prompt';
+import { format } from 'date-fns';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ux } from '@oclif/core';
+import { AGENT_CONFIG_DIR } from '../config.js';
+/**
+ * Invoke agents init programmatically
+ */
+async function invokeAgentsInit(projectRoot, force) {
+    await initializeAgentConfig({
+        projectRoot,
+        force,
+        agentProvider: 'claude-code'
+    });
+}
+/**
+ * Ensure .outputai directory structure exists by invoking agents init if needed
+ * @throws Error if user declines to initialize or if initialization fails
+ */
+export async function ensureOutputAIStructure(projectRoot) {
+    const structureCheck = await checkAgentStructure(projectRoot);
+    if (structureCheck.isComplete) {
+        return;
+    }
+    if (!structureCheck.dirExists) {
+        await invokeAgentsInit(projectRoot, false);
+        return;
+    }
+    const missingList = structureCheck.missingFiles.map(f => `  • ${f}`).join('\n');
+    ux.warn(`\n⚠️  Agent configuration is incomplete. Missing files:\n${missingList}\n`);
+    const shouldReinit = await confirm({
+        message: 'Would you like to run "agents init --force" to recreate missing files?',
+        default: true
+    });
+    if (!shouldReinit) {
+        throw new Error(`Agent configuration incomplete. Missing files:\n${structureCheck.missingFiles.join('\n')}\n\n` +
+            'Run "output-cli agents init --force" to recreate them.');
+    }
+    await invokeAgentsInit(projectRoot, true);
+}
+export async function generatePlanName(description, date = new Date()) {
+    const datePrefix = format(date, 'yyyy_MM_dd');
+    const prompt = loadPrompt('generate_plan_name@v1', { description });
+    const planNameSlug = await generateText({ prompt });
+    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, AGENT_CONFIG_DIR, '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 invoking agents init 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,
+        agentProvider: 'claude-code'
+    });
+}

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

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

package/dist/services/workflow_planner.spec.js

@@ -0,0 +1,208 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ensureOutputAIStructure, generatePlanName, writePlanFile, updateAgentTemplates } from './workflow_planner.js';
+import { checkAgentStructure, initializeAgentConfig } from './coding_agents.js';
+import { generateText } from 'local_llm';
+import { loadPrompt } from 'local_prompt';
+import { confirm } from '@inquirer/prompts';
+import fs from 'node:fs/promises';
+vi.mock('./coding_agents.js');
+vi.mock('local_llm');
+vi.mock('local_prompt');
+vi.mock('@inquirer/prompts');
+vi.mock('node:fs/promises');
+describe('workflow-planner service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('ensureOutputAIStructure', () => {
+        it('should call agents init when .outputai does not exist', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: false,
+                missingFiles: [
+                    '.outputai/AGENTS.md',
+                    '.outputai/agents/workflow_planner.md',
+                    '.outputai/commands/plan_workflow.md',
+                    'CLAUDE.md',
+                    '.claude/agents/workflow_planner.md',
+                    '.claude/commands/plan_workflow.md'
+                ],
+                isComplete: false
+            });
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await ensureOutputAIStructure('/test/project');
+            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: expect.any(String),
+                force: false,
+                agentProvider: 'claude-code'
+            }));
+        });
+        it('should skip initialization if .outputai exists', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: [],
+                isComplete: true
+            });
+            await ensureOutputAIStructure('/test/project');
+            expect(checkAgentStructure).toHaveBeenCalledWith('/test/project');
+            expect(initializeAgentConfig).not.toHaveBeenCalled();
+        });
+        it('should throw error if agents init fails', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: false,
+                missingFiles: [
+                    '.outputai/AGENTS.md',
+                    '.outputai/agents/workflow_planner.md',
+                    '.outputai/commands/plan_workflow.md',
+                    'CLAUDE.md',
+                    '.claude/agents/workflow_planner.md',
+                    '.claude/commands/plan_workflow.md'
+                ],
+                isComplete: false
+            });
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Init command failed'));
+            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Init command failed');
+        });
+        it('should prompt user when some files are missing', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: ['.outputai/agents/workflow_planner.md'],
+                isComplete: false
+            });
+            vi.mocked(confirm).mockResolvedValue(true);
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await ensureOutputAIStructure('/test/project');
+            expect(confirm).toHaveBeenCalled();
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                force: true
+            }));
+        });
+        it('should throw error when user declines partial init', async () => {
+            vi.mocked(checkAgentStructure).mockResolvedValue({
+                dirExists: true,
+                missingFiles: ['.outputai/agents/workflow_planner.md'],
+                isComplete: false
+            });
+            vi.mocked(confirm).mockResolvedValue(false);
+            await expect(ensureOutputAIStructure('/test/project')).rejects.toThrow('Agent configuration incomplete');
+        });
+    });
+    describe('generatePlanName', () => {
+        it('should generate plan name with date prefix using LLM', async () => {
+            const mockPrompt = {
+                config: { model: 'claude-sonnet-4-20250514', provider: 'anthropic' },
+                messages: [
+                    { role: 'system', content: 'You are a technical writing assistant...' },
+                    { role: 'user', content: 'Generate a snake_case plan name...' }
+                ]
+            };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('customer_order_processing');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('A workflow that processes customer orders', testDate);
+            expect(planName).toMatch(/^2025_10_06_/);
+            expect(planName).toBe('2025_10_06_customer_order_processing');
+            expect(loadPrompt).toHaveBeenCalledWith('generate_plan_name@v1', { description: 'A workflow that processes customer orders' });
+            expect(generateText).toHaveBeenCalledWith({ prompt: mockPrompt });
+        });
+        it('should clean and validate LLM response', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('  User-Auth & Security!@#  ');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('User authentication workflow', testDate);
+            expect(planName).toBe('2025_10_06_user_auth_security');
+            expect(planName).toMatch(/^[0-9_a-z]+$/);
+        });
+        it('should handle LLM errors gracefully', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockRejectedValue(new Error('API rate limit exceeded'));
+            await expect(generatePlanName('Test workflow')).rejects.toThrow('API rate limit exceeded');
+        });
+        it('should limit plan name length to 50 characters', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('this_is_an_extremely_long_plan_name_that_exceeds_the_maximum_allowed_length_for_file_names');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('Long workflow description', testDate);
+            const namePart = planName.replace(/^2025_10_06_/, '');
+            expect(namePart.length).toBeLessThanOrEqual(50);
+        });
+        it('should handle multiple underscores correctly', async () => {
+            const mockPrompt = { config: { provider: 'anthropic', model: 'claude-sonnet-4-20250514' }, messages: [] };
+            vi.mocked(loadPrompt).mockReturnValue(mockPrompt);
+            vi.mocked(generateText).mockResolvedValue('user___auth___workflow');
+            const testDate = new Date(2025, 9, 6);
+            const planName = await generatePlanName('Test', testDate);
+            expect(planName).toBe('2025_10_06_user_auth_workflow');
+            expect(planName).not.toContain('__');
+        });
+    });
+    describe('writePlanFile', () => {
+        it('should create plan directory and write PLAN.md', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const planName = '2025_10_06_test_plan';
+            const content = '# Test Plan\n\nThis is a test plan.';
+            const projectRoot = '/test/project';
+            const planPath = await writePlanFile(planName, content, projectRoot);
+            expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.outputai/plans/2025_10_06_test_plan', { recursive: true });
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.outputai/plans/2025_10_06_test_plan/PLAN.md', content, 'utf-8');
+            expect(planPath).toBe('/test/project/.outputai/plans/2025_10_06_test_plan/PLAN.md');
+        });
+        it('should return the plan file path', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const planPath = await writePlanFile('test_plan', 'content', '/root');
+            expect(planPath).toBe('/root/.outputai/plans/test_plan/PLAN.md');
+        });
+        it('should handle nested directory creation', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            await writePlanFile('2025_10_06_nested_plan', 'content', '/deep/nested/path');
+            expect(fs.mkdir).toHaveBeenCalledWith('/deep/nested/path/.outputai/plans/2025_10_06_nested_plan', { recursive: true });
+        });
+        it('should handle UTF-8 content with special characters', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+            const content = '# Plan 🎯\n\n中文 • Español • العربية\n\n"Smart quotes" and—dashes';
+            await writePlanFile('unicode_test', content, '/test');
+            expect(fs.writeFile).toHaveBeenCalledWith(expect.any(String), content, 'utf-8');
+        });
+        it('should throw error when directory creation fails', async () => {
+            vi.mocked(fs.mkdir).mockRejectedValue(new Error('Permission denied'));
+            await expect(writePlanFile('test', 'content', '/root'))
+                .rejects.toThrow('Permission denied');
+        });
+        it('should throw error when file writing fails', async () => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(fs.writeFile).mockRejectedValue(new Error('Disk full'));
+            await expect(writePlanFile('test', 'content', '/root'))
+                .rejects.toThrow('Disk full');
+        });
+    });
+    describe('updateAgentTemplates', () => {
+        it('should invoke agents init with force flag', async () => {
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await updateAgentTemplates('/test/project');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: '/test/project',
+                force: true,
+                agentProvider: 'claude-code'
+            }));
+        });
+        it('should propagate errors from agents init', async () => {
+            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Failed to write templates'));
+            await expect(updateAgentTemplates('/test/project'))
+                .rejects.toThrow('Failed to write templates');
+        });
+        it('should work with different project roots', async () => {
+            vi.mocked(initializeAgentConfig).mockResolvedValue();
+            await updateAgentTemplates('/different/path');
+            expect(initializeAgentConfig).toHaveBeenCalledWith(expect.objectContaining({
+                projectRoot: '/different/path'
+            }));
+        });
+    });
+});