@output.ai/cli 0.0.4 → 0.0.6

package/dist/services/claude_client.js

@@ -0,0 +1,155 @@
+/**
+ * Claude Agent SDK client for workflow planning
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { ux } from '@oclif/core';
+import * as cliProgress from 'cli-progress';
+const ADDITIONAL_INSTRUCTIONS = `
+! IMPORTANT !
+1. Use TodoWrite to track your progress through plan creation.
+
+2. Please response with only the final version of the plan.
+
+3. Response in a markdown format with these metadata headers:
+
+---
+title: <plan-title>
+description: <plan-description>
+date: <plan-date>
+---
+
+<plan-content>
+
+4. After you mark all todos as complete, you must respond with the final version of the plan.
+`;
+const PLAN_COMMAND = 'plan_workflow';
+const GLOBAL_CLAUDE_OPTIONS = {
+    settingSources: ['user', 'project', 'local'],
+    allowedTools: [
+        'Read',
+        'Grep',
+        'WebSearch',
+        'WebFetch',
+        'TodoWrite'
+    ]
+};
+export class ClaudeInvocationError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'ClaudeInvocationError';
+    }
+}
+function validateEnvironment() {
+    if (!process.env.ANTHROPIC_API_KEY) {
+        throw new Error('ANTHROPIC_API_KEY environment variable is required');
+    }
+}
+function validateSystem(systemMessage) {
+    const requiredCommands = [PLAN_COMMAND];
+    const availableCommands = systemMessage.slash_commands;
+    const missingCommands = requiredCommands.filter(command => !availableCommands.includes(command));
+    for (const command of missingCommands) {
+        ux.warn(`Missing required claude-code slash command: /${command}`);
+    }
+    if (missingCommands.length > 0) {
+        ux.warn('Your claude-code agent is missing key configurations, it may not behave as expected.');
+        ux.warn('Please run "output-cli agents init" to fix this.');
+    }
+}
+function applyDefaultOptions(options) {
+    return {
+        ...GLOBAL_CLAUDE_OPTIONS,
+        ...options
+    };
+}
+function getTodoWriteMessage(message) {
+    if (message.type !== 'assistant') {
+        return null;
+    }
+    const todoWriteMessage = message.message.content.find((c) => c?.type === 'tool_use' && c.name === 'TodoWrite');
+    return todoWriteMessage ?? null;
+}
+function applyInstructions(initialMessage) {
+    return `${initialMessage}\n\n${ADDITIONAL_INSTRUCTIONS}`;
+}
+function createProgressBar() {
+    return new cliProgress.SingleBar({
+        format: '{bar} | {message} ({percentage}%)',
+        barCompleteChar: '█',
+        barIncompleteChar: '░',
+        hideCursor: true,
+        barsize: 40,
+        fps: 10,
+        stopOnComplete: false
+    });
+}
+function calculateProgress(completedCount, totalCount) {
+    if (totalCount === 0) {
+        return 0;
+    }
+    const percentage = ((completedCount + 1) / (totalCount + 1)) * 100;
+    return Math.round(percentage * 10) / 10;
+}
+function getProgressUpdate(message) {
+    const todoWriteMessage = getTodoWriteMessage(message);
+    if (!todoWriteMessage) {
+        return null;
+    }
+    const allTodos = todoWriteMessage.input.todos;
+    const inProgressTodo = allTodos.find(t => t.status === 'in_progress');
+    if (!inProgressTodo?.content) {
+        return null;
+    }
+    const completedTodos = allTodos.filter(t => t.status === 'completed');
+    return {
+        message: `${inProgressTodo.content}...`,
+        completed: completedTodos.length,
+        total: allTodos.length
+    };
+}
+async function singleQuery(prompt, options = {}) {
+    validateEnvironment();
+    const progressBar = createProgressBar();
+    progressBar.start(100, 0, { message: 'Thinking...' });
+    try {
+        for await (const message of query({
+            prompt,
+            options: applyDefaultOptions(options)
+        })) {
+            if (message.type === 'system' && message.subtype === 'init') {
+                validateSystem(message);
+                progressBar.update(1, { message: 'Diving in...' });
+            }
+            const progressUpdate = getProgressUpdate(message);
+            if (progressUpdate) {
+                const percentage = calculateProgress(progressUpdate.completed, progressUpdate.total);
+                progressBar.update(percentage, { message: progressUpdate.message });
+            }
+            if (message.type === 'result' && message.subtype === 'success') {
+                progressBar.update(100, { message: 'Complete!' });
+                progressBar.stop();
+                return message.result;
+            }
+        }
+        throw new Error('No output received from claude-code');
+    }
+    catch (error) {
+        progressBar.stop();
+        throw new ClaudeInvocationError(`Failed to invoke claude-code: ${error.message}`, error);
+    }
+}
+export async function replyToClaude(message) {
+    return singleQuery(applyInstructions(message), { continue: true });
+}
+/**
+ * Invoke claude-code with /plan_workflow slash command
+ * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
+ * ensureOutputAIStructure() scaffolds the command files to that location.
+ * @param description - Workflow description
+ * @returns Plan output from claude-code
+ */
+export async function invokePlanWorkflow(description) {
+    return singleQuery(applyInstructions(`/${PLAN_COMMAND} ${description}`));
+}

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

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

package/dist/services/claude_client.spec.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { invokePlanWorkflow, ClaudeInvocationError } from './claude_client.js';
+// Mock Claude SDK
+vi.mock('@anthropic-ai/claude-agent-sdk', () => ({
+    query: vi.fn()
+}));
+describe('invokePlanWorkflow', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        // Clean up environment variables
+        delete process.env.ANTHROPIC_API_KEY;
+    });
+    it('should invoke /plan_workflow slash command with settingSources', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: '# Test Plan\n\nTest plan content' };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        await invokePlanWorkflow('Test workflow');
+        const calls = vi.mocked(query).mock.calls;
+        expect(calls[0]?.[0]?.prompt).toContain('/plan_workflow Test workflow');
+        expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
+        expect(calls[0]?.[0]?.options?.allowedTools).toEqual(['Read', 'Grep', 'WebSearch', 'WebFetch', 'TodoWrite']);
+    });
+    it('should pass workflow description to slash command', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: '# Plan\n\nContent' };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        const description = 'Build a user authentication system';
+        await invokePlanWorkflow(description);
+        const calls = vi.mocked(query).mock.calls;
+        expect(calls[0]?.[0]?.prompt).toContain(`/plan_workflow ${description}`);
+        expect(calls[0]?.[0]?.options?.settingSources).toEqual(['user', 'project', 'local']);
+    });
+    it('should return plan output from claude-code', async () => {
+        const { query } = await import('@anthropic-ai/claude-agent-sdk');
+        process.env.ANTHROPIC_API_KEY = 'test-key';
+        const expectedOutput = '# Workflow Plan\n\nDetailed plan content here';
+        async function* mockIterator() {
+            yield { type: 'result', subtype: 'success', result: expectedOutput };
+        }
+        vi.mocked(query).mockReturnValue(mockIterator());
+        const result = await invokePlanWorkflow('Test');
+        expect(result).toBe(expectedOutput);
+    });
+    it('should throw error if API key is missing', async () => {
+        delete process.env.ANTHROPIC_API_KEY;
+        await expect(invokePlanWorkflow('Test'))
+            .rejects.toThrow('ANTHROPIC_API_KEY');
+    });
+    describe('error handling', () => {
+        it('should throw ClaudeInvocationError on API failures', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const apiError = new Error('API connection failed');
+            vi.mocked(query).mockRejectedValue(apiError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should preserve original error in cause property', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const originalError = new Error('Network timeout');
+            // Mock async iterator that throws
+            async function* mockIterator() {
+                throw originalError;
+            }
+            vi.mocked(query).mockReturnValue(mockIterator());
+            try {
+                await invokePlanWorkflow('Test');
+                // If we get here, the test should fail
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ClaudeInvocationError);
+                expect(error.cause).toBe(originalError);
+            }
+        });
+        it('should handle rate limit errors', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            const rateLimitError = new Error('Rate limit exceeded');
+            rateLimitError.status = 429;
+            vi.mocked(query).mockRejectedValue(rateLimitError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should handle authentication errors', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'invalid-key';
+            const authError = new Error('Invalid API key');
+            authError.status = 401;
+            vi.mocked(query).mockRejectedValue(authError);
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+        it('should provide user-friendly error messages', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            vi.mocked(query).mockRejectedValue(new Error('API error'));
+            try {
+                await invokePlanWorkflow('Test');
+            }
+            catch (error) {
+                expect(error.message).toMatch(/Failed to invoke/i);
+            }
+        });
+        it('should throw error when no result received', async () => {
+            const { query } = await import('@anthropic-ai/claude-agent-sdk');
+            process.env.ANTHROPIC_API_KEY = 'test-key';
+            // Mock iterator that yields no result messages
+            async function* mockIterator() {
+                yield { type: 'assistant', message: { content: [] } };
+            }
+            vi.mocked(query).mockReturnValue(mockIterator());
+            await expect(invokePlanWorkflow('Test'))
+                .rejects.toThrow(ClaudeInvocationError);
+        });
+    });
+});
+describe('ClaudeInvocationError', () => {
+    it('should be instance of Error', () => {
+        const error = new ClaudeInvocationError('test message');
+        expect(error).toBeInstanceOf(Error);
+    });
+    it('should have correct name property', () => {
+        const error = new ClaudeInvocationError('test message');
+        expect(error.name).toBe('ClaudeInvocationError');
+    });
+    it('should store cause error', () => {
+        const causeError = new Error('original error');
+        const error = new ClaudeInvocationError('test message', causeError);
+        expect(error.cause).toBe(causeError);
+    });
+});

package/dist/services/coding_agents.d.ts

@@ -0,0 +1,43 @@
+export interface FileMapping {
+    from: string;
+    to: string;
+    type: 'template' | 'symlink' | 'copy';
+}
+export interface AgentSystemConfig {
+    id: string;
+    name: string;
+    mappings: FileMapping[];
+}
+export interface StructureCheckResult {
+    dirExists: boolean;
+    missingFiles: string[];
+    isComplete: boolean;
+}
+export interface InitOptions {
+    projectRoot: string;
+    force: boolean;
+    agentProvider: string;
+}
+/**
+ * Agent configuration mappings for different providers
+ */
+export declare const AGENT_CONFIGS: Record<string, AgentSystemConfig>;
+export declare function getRequiredFiles(): string[];
+/**
+ * Get the full path to the agent configuration directory
+ */
+export declare function getAgentConfigDir(projectRoot: string): string;
+/**
+ * Check if .outputai directory exists
+ */
+export declare function checkAgentConfigDirExists(projectRoot: string): Promise<boolean>;
+export declare function checkAgentStructure(projectRoot: string): Promise<StructureCheckResult>;
+/**
+ * Prepare template variables for file generation
+ */
+export declare function prepareTemplateVariables(): Record<string, string>;
+/**
+ * Initialize agent configuration files
+ * Main entry point for agent initialization logic
+ */
+export declare function initializeAgentConfig(options: InitOptions): Promise<void>;

package/dist/services/coding_agents.js

@@ -0,0 +1,230 @@
+/**
+ * Coding agent configuration service
+ * Handles initialization and validation of agent configuration files
+ */
+import fs from 'node:fs/promises';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { join } from 'node:path';
+import { ux } from '@oclif/core';
+import { AGENT_CONFIG_DIR } from '#config.js';
+import { getTemplateDir } from '#utils/paths.js';
+import { processTemplate } from '#utils/template.js';
+/**
+ * Agent configuration mappings for different providers
+ */
+export const AGENT_CONFIGS = {
+    outputai: {
+        id: 'outputai',
+        name: 'OutputAI Core Files',
+        mappings: [
+            {
+                type: 'template',
+                from: 'AGENTS.md.template',
+                to: `${AGENT_CONFIG_DIR}/AGENTS.md`
+            },
+            {
+                type: 'template',
+                from: 'agents/workflow_planner.md.template',
+                to: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`
+            },
+            {
+                type: 'template',
+                from: 'commands/plan_workflow.md.template',
+                to: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`
+            },
+            {
+                type: 'template',
+                from: 'meta/pre_flight.md.template',
+                to: '.outputai/meta/pre_flight.md'
+            },
+            {
+                type: 'template',
+                from: 'meta/post_flight.md.template',
+                to: '.outputai/meta/post_flight.md'
+            }
+        ]
+    },
+    'claude-code': {
+        id: 'claude-code',
+        name: 'Claude Code',
+        mappings: [
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/AGENTS.md`,
+                to: 'CLAUDE.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/agents/workflow_planner.md`,
+                to: '.claude/agents/workflow_planner.md'
+            },
+            {
+                type: 'symlink',
+                from: `${AGENT_CONFIG_DIR}/commands/plan_workflow.md`,
+                to: '.claude/commands/plan_workflow.md'
+            }
+        ]
+    }
+};
+export function getRequiredFiles() {
+    const outputaiFiles = AGENT_CONFIGS.outputai.mappings.map(m => m.to);
+    const claudeCodeFiles = AGENT_CONFIGS['claude-code'].mappings.map(m => m.to);
+    return [...outputaiFiles, ...claudeCodeFiles];
+}
+/**
+ * Get the full path to the agent configuration directory
+ */
+export function getAgentConfigDir(projectRoot) {
+    return join(projectRoot, AGENT_CONFIG_DIR);
+}
+/**
+ * Check if .outputai directory exists
+ */
+export async function checkAgentConfigDirExists(projectRoot) {
+    const agentConfigDir = getAgentConfigDir(projectRoot);
+    try {
+        await access(agentConfigDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkAgentStructure(projectRoot) {
+    const requiredFiles = getRequiredFiles();
+    const dirExists = await checkAgentConfigDirExists(projectRoot);
+    if (!dirExists) {
+        return {
+            dirExists: false,
+            missingFiles: requiredFiles,
+            isComplete: false
+        };
+    }
+    const missingChecks = await Promise.all(requiredFiles.map(async (file) => ({
+        file,
+        exists: await fileExists(join(projectRoot, file))
+    })));
+    const missingFiles = missingChecks
+        .filter(check => !check.exists)
+        .map(check => check.file);
+    return {
+        dirExists: true,
+        missingFiles,
+        isComplete: missingFiles.length === 0
+    };
+}
+/**
+ * Prepare template variables for file generation
+ */
+export function prepareTemplateVariables() {
+    return {
+        date: new Date().toLocaleDateString('en-US', {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric'
+        })
+    };
+}
+/**
+ * Ensure a directory exists, creating it if necessary
+ */
+async function ensureDirectoryExists(dir) {
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        ux.stdout(ux.colorize('gray', `Created directory: ${dir}`));
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST') {
+            throw error;
+        }
+    }
+}
+/**
+ * Create a file from a template
+ */
+async function 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');
+    ux.stdout(ux.colorize('gray', `Created from template: ${output}`));
+}
+/**
+ * Create a symlink, falling back to copying if symlinks are not supported
+ */
+async function createSymlink(source, target) {
+    try {
+        if (await fileExists(target)) {
+            await fs.unlink(target);
+        }
+        const relativePath = path.relative(path.dirname(target), source);
+        await fs.symlink(relativePath, target);
+        ux.stdout(ux.colorize('gray', `Created symlink: ${target} -> ${source}`));
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOTSUP' || code === 'EPERM') {
+            ux.stdout(ux.colorize('gray', `Symlinks not supported, creating copy: ${target}`));
+            const content = await fs.readFile(source, 'utf-8');
+            await fs.writeFile(target, content, 'utf-8');
+            return;
+        }
+        throw error;
+    }
+}
+/**
+ * Copy a file from source to target
+ */
+async function copyFile(source, target) {
+    const content = await fs.readFile(source, 'utf-8');
+    await fs.writeFile(target, content, 'utf-8');
+    ux.stdout(ux.colorize('gray', `Copied file: ${source} -> ${target}`));
+}
+/**
+ * Process file mappings for a specific agent configuration
+ */
+async function processMappings(config, variables, force, projectRoot) {
+    for (const mapping of config.mappings) {
+        const fullPath = path.isAbsolute(mapping.to) ?
+            mapping.to :
+            path.join(projectRoot, mapping.to);
+        const dir = path.dirname(fullPath);
+        await ensureDirectoryExists(dir);
+        if (!force && await fileExists(fullPath)) {
+            ux.warn(`File already exists: ${mapping.to} (use --force to overwrite)`);
+            continue;
+        }
+        switch (mapping.type) {
+            case 'template':
+                await createFromTemplate(mapping.from, fullPath, variables);
+                break;
+            case 'symlink':
+                await createSymlink(mapping.from, fullPath);
+                break;
+            case 'copy':
+                await copyFile(mapping.from, fullPath);
+                break;
+        }
+    }
+}
+/**
+ * Initialize agent configuration files
+ * Main entry point for agent initialization logic
+ */
+export async function initializeAgentConfig(options) {
+    const { projectRoot, force, agentProvider } = options;
+    const variables = prepareTemplateVariables();
+    await processMappings(AGENT_CONFIGS.outputai, variables, force, projectRoot);
+    await processMappings(AGENT_CONFIGS[agentProvider], variables, force, projectRoot);
+}

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

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