@output.ai/cli 0.0.3 → 0.0.5

package/dist/commands/agents/init.d.ts

@@ -8,11 +8,4 @@ export default class Init extends Command {
         force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private prepareTemplateVariables;
-    private processMappings;
-    private ensureDirectoryExists;
-    private fileExists;
-    private createFromTemplate;
-    private createSymlink;
-    private copyFile;
 }

package/dist/commands/agents/init.js

@@ -1,52 +1,6 @@
 import { Command, Flags } from '@oclif/core';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getTemplateDir } from '../../utils/paths.js';
-import { processTemplate } from '../../utils/template.js';
-const AGENT_CONFIGS = {
-    outputai: {
-        id: 'outputai',
-        name: 'OutputAI Core Files',
-        mappings: [
-            {
-                type: 'template',
-                from: 'AGENTS.md.template',
-                to: '.outputai/AGENTS.md'
-            },
-            {
-                type: 'template',
-                from: 'agents/workflow_planner.md.template',
-                to: '.outputai/agents/workflow_planner.md'
-            },
-            {
-                type: 'template',
-                from: 'commands/plan_workflow.md.template',
-                to: '.outputai/commands/plan_workflow.md'
-            }
-        ]
-    },
-    'claude-code': {
-        id: 'claude-code',
-        name: 'Claude Code',
-        mappings: [
-            {
-                type: 'symlink',
-                from: '.outputai/AGENTS.md',
-                to: 'CLAUDE.md'
-            },
-            {
-                type: 'symlink',
-                from: '.outputai/agents/workflow_planner.md',
-                to: '.claude/agents/workflow_planner.md'
-            },
-            {
-                type: 'symlink',
-                from: '.outputai/commands/plan_workflow.md',
-                to: '.claude/commands/plan_workflow.md'
-            }
-        ]
-    }
-};
+import { AGENT_CONFIG_DIR } from '../../config.js';
+import { initializeAgentConfig, AGENT_CONFIGS } from '../../services/coding_agents.js';
 export default class Init extends Command {
     static description = 'Initialize agent configuration files for AI assistant integration';
     static examples = [
@@ -71,13 +25,15 @@ export default class Init extends Command {
         const { flags } = await this.parse(Init);
         this.log('Initializing agent configuration for Claude Code...');
         try {
-            const variables = this.prepareTemplateVariables();
-            await this.processMappings(AGENT_CONFIGS.outputai, variables, flags.force);
-            await this.processMappings(AGENT_CONFIGS[flags['agent-provider']], variables, flags.force);
+            await initializeAgentConfig({
+                projectRoot: process.cwd(),
+                force: flags.force,
+                agentProvider: flags['agent-provider']
+            });
             this.log('✅ Agent configuration initialized successfully!');
             this.log('');
             this.log('Created:');
-            this.log('  • .outputai/ directory with agent and command configurations');
+            this.log(`  • ${AGENT_CONFIG_DIR}/ directory with agent and command configurations`);
             this.log('  • .claude/ directory with symlinks for Claude Code integration');
             this.log('');
             this.log('Claude Code will automatically detect and use these configurations.');
@@ -89,87 +45,4 @@ export default class Init extends Command {
             this.error(`Failed to initialize agent configuration: ${error.message}`);
         }
     }
-    prepareTemplateVariables() {
-        return {
-            date: new Date().toLocaleDateString('en-US', {
-                year: 'numeric',
-                month: 'long',
-                day: 'numeric'
-            })
-        };
-    }
-    async processMappings(config, variables, force) {
-        for (const mapping of config.mappings) {
-            const dir = path.dirname(mapping.to);
-            await this.ensureDirectoryExists(dir);
-            if (!force && await this.fileExists(mapping.to)) {
-                this.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
-                continue;
-            }
-            switch (mapping.type) {
-                case 'template':
-                    await this.createFromTemplate(mapping.from, mapping.to, variables);
-                    break;
-                case 'symlink':
-                    await this.createSymlink(mapping.from, mapping.to);
-                    break;
-                case 'copy':
-                    await this.copyFile(mapping.from, mapping.to);
-                    break;
-            }
-        }
-    }
-    async ensureDirectoryExists(dir) {
-        try {
-            await fs.mkdir(dir, { recursive: true });
-            this.debug(`Created directory: ${dir}`);
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST') {
-                throw error;
-            }
-        }
-    }
-    async fileExists(filePath) {
-        try {
-            await fs.stat(filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async createFromTemplate(template, output, variables) {
-        const templateDir = getTemplateDir('agent_instructions');
-        const templatePath = path.join(templateDir, template);
-        const content = await fs.readFile(templatePath, 'utf-8');
-        const processed = processTemplate(content, variables);
-        await fs.writeFile(output, processed, 'utf-8');
-        this.debug(`Created from template: ${output}`);
-    }
-    async createSymlink(source, target) {
-        try {
-            if (await this.fileExists(target)) {
-                await fs.unlink(target);
-            }
-            const relativePath = path.relative(path.dirname(target), source);
-            await fs.symlink(relativePath, target);
-            this.debug(`Created symlink: ${target} -> ${source}`);
-        }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ENOTSUP' || code === 'EPERM') {
-                this.debug(`Symlinks not supported, creating copy: ${target}`);
-                const content = await fs.readFile(source, 'utf-8');
-                await fs.writeFile(target, content, 'utf-8');
-                return;
-            }
-            throw error;
-        }
-    }
-    async copyFile(source, target) {
-        const content = await fs.readFile(source, 'utf-8');
-        await fs.writeFile(target, content, 'utf-8');
-        this.debug(`Copied file: ${source} -> ${target}`);
-    }
 }

package/dist/commands/agents/init.spec.js

@@ -46,6 +46,7 @@ describe('agents init', () => {
         vi.mocked(fs.writeFile).mockResolvedValue(undefined);
         vi.mocked(fs.symlink).mockResolvedValue(undefined);
         vi.mocked(fs.stat).mockRejectedValue({ code: 'ENOENT' });
+        vi.mocked(fs.access).mockRejectedValue({ code: 'ENOENT' }); // Files don't exist by default
         vi.mocked(fs.unlink).mockResolvedValue(undefined);
         vi.mocked(fs.readFile).mockResolvedValue('Template content with {{date}}');
         mockGetTemplateDir = vi.mocked(getTemplateDir);
@@ -86,6 +87,7 @@ describe('agents init', () => {
             expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai'), expect.objectContaining({ recursive: true }));
             expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents'), expect.objectContaining({ recursive: true }));
             expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands'), expect.objectContaining({ recursive: true }));
+            expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining('.outputai/meta'), expect.objectContaining({ recursive: true }));
         });
         it('should create .claude directory structure', async () => {
             const mockMkdir = vi.mocked(fs.mkdir);
@@ -107,7 +109,7 @@ describe('agents init', () => {
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
             expect(mockReadFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md.template'), 'utf-8');
-            expect(mockWriteFile).toHaveBeenCalledWith('.outputai/AGENTS.md', expect.stringContaining('Agent instructions'), 'utf-8');
+            expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('Agent instructions'), 'utf-8');
         });
         it('should create all agent configuration files', async () => {
             const mockWriteFile = vi.mocked(fs.writeFile);
@@ -118,7 +120,7 @@ describe('agents init', () => {
                 '.outputai/agents/workflow_planner.md'
             ];
             for (const file of agentFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
             }
         });
         it('should create all command configuration files', async () => {
@@ -130,50 +132,65 @@ describe('agents init', () => {
                 '.outputai/commands/plan_workflow.md'
             ];
             for (const file of commandFiles) {
-                expect(mockWriteFile).toHaveBeenCalledWith(file, expect.any(String), 'utf-8');
+                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
+            }
+        });
+        it('should create all meta configuration files', async () => {
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            const metaFiles = [
+                '.outputai/meta/pre_flight.md',
+                '.outputai/meta/post_flight.md'
+            ];
+            for (const file of metaFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
             }
         });
     });
     describe('symlink creation', () => {
         it('should create symlink from CLAUDE.md to .outputai/AGENTS.md', async () => {
             const mockSymlink = vi.mocked(fs.symlink);
-            const mockStat = vi.mocked(fs.stat);
-            mockStat.mockImplementation(async (path) => {
-                if (typeof path === 'string' && path.startsWith('.outputai')) {
-                    return { isFile: () => true };
-                }
-                throw { code: 'ENOENT' };
-            });
             const cmd = createTestCommand();
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
-            expect(mockSymlink).toHaveBeenCalledWith('.outputai/AGENTS.md', 'CLAUDE.md');
+            // Symlink creates a relative link from target to source
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('CLAUDE.md'));
         });
         it('should create symlinks for all agent files', async () => {
             const mockSymlink = vi.mocked(fs.symlink);
             const cmd = createTestCommand();
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), '.claude/agents/workflow_planner.md');
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), expect.stringContaining('.claude/agents/workflow_planner.md'));
         });
         it('should create symlinks for all command files', async () => {
             const mockSymlink = vi.mocked(fs.symlink);
             const cmd = createTestCommand();
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
-            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), '.claude/commands/plan_workflow.md');
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), expect.stringContaining('.claude/commands/plan_workflow.md'));
         });
         it('should handle Windows by copying files when symlinks are not supported', async () => {
             const mockSymlink = vi.mocked(fs.symlink);
             const mockWriteFile = vi.mocked(fs.writeFile);
             const mockReadFile = vi.mocked(fs.readFile);
             mockSymlink.mockRejectedValue({ code: 'ENOTSUP' });
+            // readFile is called for both templates AND fallback copy
             mockReadFile.mockResolvedValue('File content');
             const cmd = createTestCommand();
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
-            expect(mockReadFile).toHaveBeenCalledWith('.outputai/AGENTS.md', 'utf-8');
-            expect(mockWriteFile).toHaveBeenCalledWith('CLAUDE.md', 'File content', 'utf-8');
+            // When symlinks fail, it falls back to copying the source files
+            // Source files are the .outputai files, targets are CLAUDE.md and .claude/ files
+            const writeCalls = mockWriteFile.mock.calls;
+            // Should have written template files + fallback copies
+            expect(writeCalls.length).toBeGreaterThan(3); // At least 3 templates + 3 symlink fallbacks
+            // Verify at least one fallback copy happened
+            const claudeFileCalls = writeCalls.filter(call => typeof call[0] === 'string' && (call[0].includes('CLAUDE.md') ||
+                call[0].includes('.claude/')));
+            expect(claudeFileCalls.length).toBeGreaterThan(0);
         });
     });
     describe('error handling', () => {
@@ -203,6 +220,44 @@ describe('agents init', () => {
             expect(cmd.error).not.toHaveBeenCalled();
         });
     });
+    describe('complete initialization', () => {
+        it('should create all required files and directories', async () => {
+            const mockMkdir = vi.mocked(fs.mkdir);
+            const mockWriteFile = vi.mocked(fs.writeFile);
+            const mockSymlink = vi.mocked(fs.symlink);
+            const cmd = createTestCommand();
+            cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
+            await cmd.run();
+            // Verify all expected directories are created
+            const expectedDirs = [
+                '.outputai',
+                '.outputai/agents',
+                '.outputai/commands',
+                '.outputai/meta',
+                '.claude',
+                '.claude/agents',
+                '.claude/commands'
+            ];
+            for (const dir of expectedDirs) {
+                expect(mockMkdir).toHaveBeenCalledWith(expect.stringContaining(dir), expect.objectContaining({ recursive: true }));
+            }
+            // Verify all expected template files are created
+            const expectedFiles = [
+                '.outputai/AGENTS.md',
+                '.outputai/agents/workflow_planner.md',
+                '.outputai/commands/plan_workflow.md',
+                '.outputai/meta/pre_flight.md',
+                '.outputai/meta/post_flight.md'
+            ];
+            for (const file of expectedFiles) {
+                expect(mockWriteFile).toHaveBeenCalledWith(expect.stringContaining(file), expect.any(String), 'utf-8');
+            }
+            // Verify symlinks are created
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/AGENTS.md'), expect.stringContaining('CLAUDE.md'));
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/agents/workflow_planner.md'), expect.stringContaining('.claude/agents/workflow_planner.md'));
+            expect(mockSymlink).toHaveBeenCalledWith(expect.stringContaining('.outputai/commands/plan_workflow.md'), expect.stringContaining('.claude/commands/plan_workflow.md'));
+        });
+    });
     describe('force flag', () => {
         it('should overwrite existing files when force flag is set', async () => {
             const mockWriteFile = vi.mocked(fs.writeFile);
@@ -215,13 +270,15 @@ describe('agents init', () => {
             expect(mockWriteFile).toHaveBeenCalled();
             expect(cmd.warn).not.toHaveBeenCalled();
         });
-        it('should warn about existing files without force flag', async () => {
-            const mockStat = vi.mocked(fs.stat);
-            mockStat.mockResolvedValue({ isFile: () => true });
+        it('should skip existing files without force flag', async () => {
+            const mockAccess = vi.mocked(fs.access);
+            mockAccess.mockResolvedValue(undefined);
             const cmd = createTestCommand();
             cmd.parse.mockResolvedValue({ flags: { 'agent-provider': 'claude-code', force: false }, args: {} });
             await cmd.run();
-            expect(cmd.warn).toHaveBeenCalledWith(expect.stringContaining('already exists'));
+            // Files exist, so they should be skipped
+            // The command should complete without errors
+            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('initialized successfully'));
         });
     });
 });

package/dist/commands/workflow/plan.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class WorkflowPlan extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'force-agent-file-write': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        description: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private planModificationLoop;
+    private planGenerationLoop;
+}

package/dist/commands/workflow/plan.js

@@ -0,0 +1,65 @@
+import { Command, Flags, ux } from '@oclif/core';
+import { input } from '@inquirer/prompts';
+import { ensureOutputAIStructure, generatePlanName, updateAgentTemplates, writePlanFile } from '../../services/workflow_planner.js';
+import { invokePlanWorkflow, replyToClaude } from '../../services/claude_client.js';
+export default class WorkflowPlan extends Command {
+    static description = 'Generate a workflow plan from a description';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --description "A workflow to take a question and answer it"',
+        '<%= config.bin %> <%= command.id %> --force-agent-file-write'
+    ];
+    static flags = {
+        'force-agent-file-write': Flags.boolean({
+            description: 'Force overwrite of agent template files',
+            default: false
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Workflow description',
+            required: false
+        })
+    };
+    async run() {
+        const { flags } = await this.parse(WorkflowPlan);
+        const projectRoot = process.cwd();
+        this.log('Checking .outputai directory structure...');
+        await ensureOutputAIStructure(projectRoot);
+        if (flags['force-agent-file-write']) {
+            this.log('Updating agent templates...');
+            await updateAgentTemplates(projectRoot);
+            this.log('Templates updated successfully\n');
+        }
+        const description = flags.description ?? await input({
+            message: 'Describe the workflow you want to create:',
+            validate: (value) => value.length >= 10
+        });
+        this.log('\nGenerating plan name...');
+        const planName = await generatePlanName(description);
+        this.log(`Plan name: ${planName}`);
+        await this.planGenerationLoop(description, planName, projectRoot);
+    }
+    async planModificationLoop(originalPlanContent) {
+        const acceptKey = 'ACCEPT';
+        this.log('=========');
+        this.log(originalPlanContent);
+        this.log('=========');
+        const modifications = await input({
+            message: ux.colorize('gray', `Reply or type ${acceptKey} to accept the plan as is: `),
+            validate: (value) => value.length >= 10 || value === acceptKey
+        });
+        if (modifications === acceptKey) {
+            return originalPlanContent;
+        }
+        const modifiedPlanContent = await replyToClaude(modifications);
+        return this.planModificationLoop(modifiedPlanContent);
+    }
+    async planGenerationLoop(promptDescription, planName, projectRoot) {
+        this.log('\nInvoking the /plan_workflow command...');
+        this.log('This may take a moment...\n');
+        const planContent = await invokePlanWorkflow(promptDescription);
+        const modifiedPlanContent = await this.planModificationLoop(planContent);
+        const modifiedSavedPath = await writePlanFile(planName, modifiedPlanContent, projectRoot);
+        this.log(`✅ Plan saved to: ${modifiedSavedPath}\n`);
+    }
+}

package/dist/commands/workflow/plan.spec.d.ts

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