@output.ai/cli 0.8.1 → 0.8.3

package/dist/services/coding_agents.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { checkAgentConfigDirExists, checkAgentStructure, getAgentConfigDir, prepareTemplateVariables, initializeAgentConfig, ensureOutputAISystem } from './coding_agents.js';
+import { checkAgentStructure, prepareTemplateVariables, initializeAgentConfig, ensureOutputAISystem, ensureClaudePlugin } from './coding_agents.js';
 import { access } from 'node:fs/promises';
 import fs from 'node:fs/promises';
 vi.mock('node:fs/promises');
@@ -26,35 +26,17 @@ describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
-    describe('getAgentConfigDir', () => {
-        it('should return the correct path to .outputai directory', () => {
-            const result = getAgentConfigDir('/test/project');
-            expect(result).toBe('/test/project/.outputai');
-        });
-    });
-    describe('checkAgentConfigDirExists', () => {
-        it('should return true when .outputai directory exists', async () => {
-            vi.mocked(access).mockResolvedValue(undefined);
-            const result = await checkAgentConfigDirExists('/test/project');
-            expect(result).toBe(true);
-            expect(access).toHaveBeenCalledWith('/test/project/.outputai');
-        });
-        it('should return false when .outputai directory does not exist', async () => {
-            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
-            const result = await checkAgentConfigDirExists('/test/project');
-            expect(result).toBe(false);
-        });
-    });
     describe('checkAgentStructure', () => {
-        it('should return needsInit true when directory does not exist', async () => {
+        it('should return needsInit true when settings.json does not exist', async () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
             const result = await checkAgentStructure('/test/project');
             expect(result).toEqual({
                 isComplete: false,
                 needsInit: true
             });
         });
-        it('should return complete when all files exist with valid settings', async () => {
+        it('should return complete when settings and CLAUDE.md exist with valid configuration', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
             vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
                 extraKnownMarketplaces: {
@@ -113,19 +95,6 @@ describe('coding_agents service', () => {
             expect(result.isComplete).toBe(false);
             expect(result.needsInit).toBe(true);
         });
-        it('should return needsInit true when settings.json does not exist', async () => {
-            vi.mocked(access).mockImplementation(async (path) => {
-                const pathStr = path.toString();
-                if (pathStr.endsWith('.claude/settings.json')) {
-                    throw { code: 'ENOENT' };
-                }
-                return undefined;
-            });
-            vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
-            const result = await checkAgentStructure('/test/project');
-            expect(result.isComplete).toBe(false);
-            expect(result.needsInit).toBe(true);
-        });
     });
     describe('prepareTemplateVariables', () => {
         it('should return template variables with formatted date', () => {
@@ -141,19 +110,18 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
-        it('should create exactly 3 outputs: AGENTS.md, settings.json, and CLAUDE.md symlink', async () => {
+        it('should create exactly 2 outputs: settings.json and CLAUDE.md file', async () => {
             await initializeAgentConfig({
                 projectRoot: '/test/project',
                 force: false
             });
-            expect(fs.mkdir).toHaveBeenCalledTimes(2);
-            expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.outputai', expect.objectContaining({ recursive: true }));
+            expect(fs.mkdir).toHaveBeenCalledTimes(1);
             expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.claude', expect.objectContaining({ recursive: true }));
-            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.outputai/AGENTS.md', expect.any(String), 'utf-8');
             expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.claude/settings.json', expect.any(String), 'utf-8');
-            expect(fs.symlink).toHaveBeenCalledTimes(1);
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/CLAUDE.md', expect.any(String), 'utf-8');
+            // No symlink should be created - CLAUDE.md is now a real file
+            expect(fs.symlink).not.toHaveBeenCalled();
         });
         it('should skip existing files when force is false', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -162,7 +130,6 @@ describe('coding_agents service', () => {
                 force: false
             });
             expect(fs.writeFile).not.toHaveBeenCalled();
-            expect(fs.symlink).not.toHaveBeenCalled();
         });
         it('should overwrite existing files when force is true', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -173,15 +140,40 @@ describe('coding_agents service', () => {
             });
             expect(fs.writeFile).toHaveBeenCalled();
         });
-        it('should handle symlink errors by falling back to copy', async () => {
-            vi.mocked(fs.symlink).mockRejectedValue({ code: 'ENOTSUP' });
-            await initializeAgentConfig({
-                projectRoot: '/test/project',
-                force: false
-            });
-            const writeFileCalls = vi.mocked(fs.writeFile).mock.calls;
-            const claudeMdCalls = writeFileCalls.filter(call => call[0].toString().includes('CLAUDE.md'));
-            expect(claudeMdCalls.length).toBe(1);
+    });
+    describe('ensureClaudePlugin', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should call registerPluginMarketplace and installOutputAIPlugin', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            await ensureClaudePlugin('/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'add', 'growthxai/output-claude-plugins'], '/test/project', { ignoreFailure: true });
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'update', 'outputai'], '/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], '/test/project');
+        });
+        it('should show error and prompt user when plugin commands fail', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should allow user to proceed without plugin setup if they confirm', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValue(new Error('All plugin commands fail'));
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
         });
     });
     describe('ensureOutputAISystem', () => {
@@ -190,7 +182,6 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
         it('should return immediately when agent structure is complete', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
@@ -205,12 +196,6 @@ describe('coding_agents service', () => {
             await ensureOutputAISystem('/test/project');
             expect(fs.mkdir).not.toHaveBeenCalled();
         });
-        it('should auto-initialize when directory does not exist', async () => {
-            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
-            await ensureOutputAISystem('/test/project');
-            expect(fs.mkdir).toHaveBeenCalled();
-            expect(fs.writeFile).toHaveBeenCalled();
-        });
         it('should auto-initialize when settings.json is invalid', async () => {
             vi.mocked(access).mockResolvedValue(undefined);
             vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
@@ -231,7 +216,6 @@ describe('coding_agents service', () => {
             vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
             vi.mocked(fs.readFile).mockResolvedValue('template content');
             vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-            vi.mocked(fs.symlink).mockResolvedValue(undefined);
         });
         it('should show error and prompt user when registerPluginMarketplace fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');

package/dist/services/workflow_planner.d.ts

@@ -8,7 +8,7 @@ export declare function generatePlanName(description: string, date?: Date): Prom
  */
 export declare function writePlanFile(planName: string, content: string, projectRoot: string): Promise<string>;
 /**
- * Update agent templates by invoking agents init with force flag
+ * Update agent templates by reinitializing with force flag
  * This recreates all agent configuration files, overwriting existing ones
  * @param projectRoot - Root directory of the project
  */

package/dist/services/workflow_planner.js

@@ -36,7 +36,7 @@ export async function writePlanFile(planName, content, projectRoot) {
     return planFilePath;
 }
 /**
- * Update agent templates by invoking agents init with force flag
+ * Update agent templates by reinitializing with force flag
  * This recreates all agent configuration files, overwriting existing ones
  * @param projectRoot - Root directory of the project
  */

package/dist/services/workflow_planner.spec.js

@@ -98,7 +98,7 @@ describe('workflow-planner service', () => {
         });
     });
     describe('updateAgentTemplates', () => {
-        it('should invoke agents init with force flag', async () => {
+        it('should invoke initializeAgentConfig with force flag', async () => {
             vi.mocked(initializeAgentConfig).mockResolvedValue();
             await updateAgentTemplates('/test/project');
             expect(initializeAgentConfig).toHaveBeenCalledWith({
@@ -106,7 +106,7 @@ describe('workflow-planner service', () => {
                 force: true
             });
         });
-        it('should propagate errors from agents init', async () => {
+        it('should propagate errors from initializeAgentConfig', async () => {
             vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Failed to write templates'));
             await expect(updateAgentTemplates('/test/project'))
                 .rejects.toThrow('Failed to write templates');

package/dist/templates/agent_instructions/CLAUDE.md.template

@@ -0,0 +1,19 @@
+# CLAUDE.md
+
+This is an **Output.ai** project - a framework for building reliable, production-ready LLM workflows and agents.
+
+## Getting Started
+
+For full framework documentation, commands, and AI-assisted workflow development, install our Claude Code plugins:
+
+```bash
+claude plugin marketplace add growthxai/output-claude-plugins
+claude plugin install outputai@outputai --scope project
+```
+
+---
+
+## Project-Specific Instructions
+
+<!-- Add your project-specific instructions below -->
+

package/dist/test_helpers/mocks.d.ts

@@ -11,7 +11,7 @@ export declare const mockLLM: {
     generateText: import("vitest").Mock<(...args: any[]) => any>;
 };
 /**
- * Mock for child_process spawn (for agents init)
+ * Mock for child_process spawn (for agent commands)
  */
 export declare const mockSpawn: import("vitest").Mock<(...args: any[]) => any>;
 /**

package/dist/test_helpers/mocks.js

@@ -24,7 +24,7 @@ export const mockLLM = {
     })
 };
 /**
- * Mock for child_process spawn (for agents init)
+ * Mock for child_process spawn (for agent commands)
  */
 export const mockSpawn = vi.fn().mockImplementation(() => {
     const mockChild = {

package/dist/utils/process.js

@@ -1,20 +1,22 @@
 import { spawn } from 'node:child_process';
 import { ux } from '@oclif/core';
+import debugFactory from 'debug';
 import { getErrorMessage } from './error_utils.js';
+const debug = debugFactory('output-cli:process');
 export async function executeCommand(command, args, cwd) {
     const stderrLines = [];
     const proc = spawn(command, args, { cwd });
     const handleStdout = (data) => {
         const line = data.toString().trim();
         if (line) {
-            ux.stdout(line);
+            debug(line);
         }
     };
     const handleStderr = (data) => {
         const line = data.toString().trim();
         if (line) {
             stderrLines.push(line);
-            ux.stdout(line);
+            debug(line);
         }
     };
     proc.stdout.on('data', handleStdout);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -18,8 +18,7 @@
     "copy-assets": "./bin/copyassets.sh",
     "test": "vitest run",
     "generate:api": "orval --config ./orval.config.ts",
-    "update:versions": "node scripts/update_sdk_versions.js",
-    "prebuild": "npm run generate:api && npm run update:versions"
+    "prebuild": "npm run generate:api"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.1.71",

package/dist/commands/agents/init.js

@@ -1,43 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { initializeAgentConfig } from '#services/coding_agents.js';
-import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
-export default class Init extends Command {
-    static description = 'Initialize agent configuration files for Claude Code plugin integration';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --force'
-    ];
-    static args = {};
-    static flags = {
-        force: Flags.boolean({
-            char: 'f',
-            description: 'Overwrite existing files',
-            default: false
-        })
-    };
-    async run() {
-        const { flags } = await this.parse(Init);
-        this.log('Initializing agent configuration for Claude Code...');
-        try {
-            await initializeAgentConfig({
-                projectRoot: process.cwd(),
-                force: flags.force
-            });
-            this.log('Agent configuration initialized successfully!');
-            this.log('');
-            this.log('Configured:');
-            this.log('  - Registered marketplace: growthxai/output-claude-plugins');
-            this.log('  - Updated marketplace: outputai');
-            this.log('  - Installed plugin: outputai@outputai');
-            this.log('');
-            this.log('Claude Code will automatically use the OutputAI plugin.');
-        }
-        catch (error) {
-            if (getErrorCode(error) === 'EACCES') {
-                this.error('Permission denied. Please check file permissions and try again.');
-                return;
-            }
-            this.error(`Failed to initialize agent configuration: ${getErrorMessage(error)}`);
-        }
-    }
-}

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

@@ -1,109 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import Init from './init.js';
-import { initializeAgentConfig } from '#services/coding_agents.js';
-vi.mock('#services/coding_agents.js', () => ({
-    initializeAgentConfig: vi.fn(),
-    AGENT_CONFIGS: { 'claude-code': { id: 'claude-code' } }
-}));
-vi.mock('#config.js', () => ({
-    AGENT_CONFIG_DIR: '.outputai'
-}));
-describe('agents init', () => {
-    const createTestCommand = (args = []) => {
-        const cmd = new Init(args, {});
-        cmd.log = vi.fn();
-        cmd.warn = vi.fn();
-        cmd.error = vi.fn();
-        cmd.debug = vi.fn();
-        cmd.parse = vi.fn();
-        return cmd;
-    };
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.mocked(initializeAgentConfig).mockResolvedValue(undefined);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('command structure', () => {
-        it('should have correct description', () => {
-            expect(Init.description).toBeDefined();
-            expect(Init.description).toContain('agent configuration');
-        });
-        it('should have correct examples without agent-provider flag', () => {
-            expect(Init.examples).toBeDefined();
-            expect(Array.isArray(Init.examples)).toBe(true);
-            const examplesStr = Init.examples.join(' ');
-            expect(examplesStr).not.toContain('agent-provider');
-        });
-        it('should have no required arguments', () => {
-            expect(Init.args).toBeDefined();
-            expect(Object.keys(Init.args)).toHaveLength(0);
-        });
-        it('should only have force flag', () => {
-            expect(Init.flags).toBeDefined();
-            expect(Init.flags.force).toBeDefined();
-            expect(Object.keys(Init.flags)).toHaveLength(1);
-        });
-    });
-    describe('successful execution', () => {
-        it('should call initializeAgentConfig with correct options', async () => {
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(initializeAgentConfig).toHaveBeenCalledWith({
-                projectRoot: expect.any(String),
-                force: false
-            });
-        });
-        it('should pass force flag to initializeAgentConfig', async () => {
-            const cmd = createTestCommand(['--force']);
-            cmd.parse.mockResolvedValue({ flags: { force: true }, args: {} });
-            await cmd.run();
-            expect(initializeAgentConfig).toHaveBeenCalledWith({
-                projectRoot: expect.any(String),
-                force: true
-            });
-        });
-        it('should display success messages', async () => {
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('initialized successfully'));
-            expect(cmd.log).toHaveBeenCalledWith('Configured:');
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('OutputAI plugin'));
-        });
-        it('should display plugin configuration messages', async () => {
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('marketplace'));
-            expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('plugin'));
-        });
-    });
-    describe('error handling', () => {
-        it('should handle permission errors', async () => {
-            vi.mocked(initializeAgentConfig).mockRejectedValue({ code: 'EACCES' });
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Permission denied'));
-        });
-        it('should handle general errors with message', async () => {
-            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Something went wrong'));
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Failed to initialize agent configuration'));
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Something went wrong'));
-        });
-        it('should handle Claude CLI not found error', async () => {
-            vi.mocked(initializeAgentConfig).mockRejectedValue(new Error('Claude CLI not found. Please install Claude Code CLI and ensure \'claude\' is in your PATH.'));
-            const cmd = createTestCommand();
-            cmd.parse.mockResolvedValue({ flags: { force: false }, args: {} });
-            await cmd.run();
-            expect(cmd.error).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found'));
-        });
-    });
-});