@outputai/cli 0.1.4 → 0.1.5

package/dist/services/claude_client.js

@@ -0,0 +1,215 @@
+/**
+ * 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';
+import { getErrorMessage, toError } from '#utils/error_utils.js';
+import { config } from '#config.js';
+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 ADDITIONAL_INSTRUCTIONS_BUILD = `
+! IMPORTANT !
+1. Use TodoWrite to track your progress through workflow implementation.
+
+2. Follow the implementation plan exactly as specified in the plan file.
+
+3. Implement all workflow files following Output.ai patterns and best practices.
+
+4. After you mark all todos as complete, provide a summary of what was implemented.
+`;
+const PLAN_COMMAND = 'outputai:plan_workflow';
+const BUILD_COMMAND = 'outputai:build_workflow';
+const GLOBAL_CLAUDE_OPTIONS = {
+    settingSources: ['user', 'project', 'local']
+};
+export const PLAN_COMMAND_OPTIONS = {
+    allowedTools: ['Read', 'Grep', 'WebSearch', 'WebFetch', 'TodoWrite']
+};
+export const BUILD_COMMAND_OPTIONS = {
+    permissionMode: 'bypassPermissions'
+};
+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.\n' +
+            '\n' +
+            'Please set it using one of these methods:\n' +
+            '1. Add it to a .env file in your project root:\n' +
+            '   ANTHROPIC_API_KEY=your-api-key\n' +
+            '\n' +
+            '2. Export it in your shell:\n' +
+            '   export ANTHROPIC_API_KEY=your-api-key\n' +
+            '\n' +
+            '3. Set it when running the command:\n' +
+            '   ANTHROPIC_API_KEY=your-api-key output workflow plan\n' +
+            '\n' +
+            'Get your API key from: https://console.anthropic.com/');
+    }
+}
+function validateSystem(systemMessage) {
+    const requiredCommands = [PLAN_COMMAND, BUILD_COMMAND];
+    const availableCommands = systemMessage.slash_commands;
+    const missingCommands = requiredCommands.filter(command => !availableCommands.includes(command));
+    return {
+        missingCommands,
+        hasIssues: missingCommands.length > 0
+    };
+}
+function displaySystemValidationWarnings(validation) {
+    if (!validation.hasIssues) {
+        return;
+    }
+    validation.missingCommands.forEach(command => {
+        ux.warn(`Missing required claude-code slash command: /${command}`);
+    });
+    ux.warn('Your claude-code agent is missing key configurations, it may not behave as expected.');
+    ux.warn('Please run "npx output update --agents" 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, instructionsType = 'plan') {
+    const instructions = instructionsType === 'build' ?
+        ADDITIONAL_INSTRUCTIONS_BUILD :
+        ADDITIONAL_INSTRUCTIONS;
+    return `${initialMessage}\n\n${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
+    };
+}
+function debugMessage(message) {
+    if (!config.debugMode) {
+        return;
+    }
+    ux.stdout(ux.colorize('teal', `[Message]: ${message.type}`));
+    ux.stdout(ux.colorize('teal', `[JSON]: ${JSON.stringify(message, null, 2)}`));
+}
+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)
+        })) {
+            debugMessage(message);
+            if (message.type === 'system' && message.subtype === 'init') {
+                const validation = validateSystem(message);
+                displaySystemValidationWarnings(validation);
+                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: ${getErrorMessage(error)}`, toError(error));
+    }
+}
+export async function replyToClaude(message, options = {}) {
+    return singleQuery(applyInstructions(message), { continue: true, ...options });
+}
+/**
+ * Invoke claude-code with /outputai:plan_workflow slash command
+ * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
+ * ensureOutputAISystem() 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}`), PLAN_COMMAND_OPTIONS);
+}
+/**
+ * Invoke claude-code with /outputai:build_workflow slash command
+ * The SDK loads custom commands from .claude/commands/ when settingSources includes 'project'.
+ * ensureOutputAISystem() scaffolds the command files to that location.
+ * @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 invokeBuildWorkflow(planFilePath, workflowDir, workflowName, additionalInstructions) {
+    const commandArgs = `${planFilePath} ${workflowName} ${workflowDir}`;
+    const fullCommand = additionalInstructions ?
+        `/${BUILD_COMMAND} ${commandArgs} ${additionalInstructions}` :
+        `/${BUILD_COMMAND} ${commandArgs}`;
+    return singleQuery(applyInstructions(fullCommand, 'build'), BUILD_COMMAND_OPTIONS);
+}

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

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

package/dist/services/claude_client.spec.js

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { invokePlanWorkflow, ClaudeInvocationError } from './claude_client.js';
+import { isError } from '#utils/error_utils.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 /outputai: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('/outputai: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(`/outputai: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(isError(error)).toBe(true);
+                if (isError(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,36 @@
+export interface StructureCheckResult {
+    isComplete: boolean;
+    needsInit: boolean;
+}
+export interface InitOptions {
+    projectRoot: string;
+    force: boolean;
+}
+interface EnsureClaudePluginOptions {
+    silent?: boolean;
+}
+export declare function checkAgentStructure(projectRoot: string): Promise<StructureCheckResult>;
+/**
+ * Prepare template variables for file generation
+ */
+export declare function prepareTemplateVariables(): Record<string, string>;
+/**
+ * Ensure Claude Code plugin is configured
+ * Registers marketplace, updates it, and installs the plugin
+ */
+export declare function ensureClaudePlugin(projectRoot: string, options?: EnsureClaudePluginOptions): Promise<void>;
+/**
+ * Initialize agent configuration files and register Claude Code plugin
+ * Creates:
+ * - .claude/settings.json (static JSON)
+ * - CLAUDE.md (from template - user-customizable file)
+ * Then runs Claude CLI commands to register the plugin marketplace and install the plugin
+ */
+export declare function initializeAgentConfig(options: InitOptions): Promise<void>;
+/**
+ * Ensure OutputAI system is initialized
+ * Creates configuration files and registers Claude Code plugin
+ * @param projectRoot - Root directory of the project
+ */
+export declare function ensureOutputAISystem(projectRoot: string): Promise<void>;
+export {};

package/dist/services/coding_agents.js

@@ -0,0 +1,236 @@
+/**
+ * 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 { confirm } from '@inquirer/prompts';
+import debugFactory from 'debug';
+import { getTemplateDir } from '#utils/paths.js';
+import { executeClaudeCommand } from '#utils/claude.js';
+import { processTemplate } from '#utils/template.js';
+import { ClaudePluginError, UserCancelledError } from '#types/errors.js';
+const debug = debugFactory('output-cli:agent');
+const EXPECTED_MARKETPLACE_REPO = 'growthxai/output';
+function createLogger(silent) {
+    return silent ? debug : (msg) => ux.stdout(ux.colorize('gray', msg));
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate settings.json content has correct marketplace and plugin configuration
+ */
+async function validateSettingsJson(projectRoot) {
+    const settingsPath = join(projectRoot, '.claude/settings.json');
+    try {
+        const content = await fs.readFile(settingsPath, 'utf-8');
+        const settings = JSON.parse(content);
+        const marketplaceRepo = settings.extraKnownMarketplaces?.['team-tools']?.source?.repo;
+        const pluginEnabled = settings.enabledPlugins?.['outputai@outputai'];
+        return marketplaceRepo === EXPECTED_MARKETPLACE_REPO && pluginEnabled === true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkAgentStructure(projectRoot) {
+    const settingsValid = await validateSettingsJson(projectRoot);
+    const claudeMdExists = await fileExists(join(projectRoot, 'CLAUDE.md'));
+    if (!settingsValid) {
+        ux.warn('.claude/settings.json missing critical configuration.');
+    }
+    if (!claudeMdExists) {
+        ux.warn('CLAUDE.md missing.');
+    }
+    const isComplete = settingsValid && claudeMdExists;
+    const needsInit = !settingsValid;
+    return { isComplete, needsInit };
+}
+/**
+ * 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(templateSubpath, output, variables) {
+    const templateDir = getTemplateDir('agent_instructions');
+    const templatePath = path.join(templateDir, templateSubpath);
+    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 static file (no template processing)
+ */
+async function createStaticFile(templateSubpath, output) {
+    const templateDir = getTemplateDir('agent_instructions');
+    const templatePath = path.join(templateDir, templateSubpath);
+    const content = await fs.readFile(templatePath, 'utf-8');
+    await fs.writeFile(output, content, 'utf-8');
+    ux.stdout(ux.colorize('gray', `Created file: ${output}`));
+}
+/**
+ * Create .claude/settings.json file from template
+ */
+async function createSettingsFile(projectRoot, force) {
+    const claudeDir = join(projectRoot, '.claude');
+    await ensureDirectoryExists(claudeDir);
+    const settingsPath = join(claudeDir, 'settings.json');
+    if (force || !await fileExists(settingsPath)) {
+        await createStaticFile('dotclaude/settings.json.template', settingsPath);
+    }
+    else {
+        ux.warn('File already exists: .claude/settings.json (use --force to overwrite)');
+    }
+}
+/**
+ * Create CLAUDE.md file from template
+ */
+async function createClaudeMdFile(projectRoot, force, variables) {
+    const claudeMdPath = join(projectRoot, 'CLAUDE.md');
+    if (force || !await fileExists(claudeMdPath)) {
+        await createFromTemplate('CLAUDE.md.template', claudeMdPath, variables);
+    }
+    else {
+        ux.warn('File already exists: CLAUDE.md (use --force to overwrite)');
+    }
+}
+/**
+ * Handle Claude plugin command errors with user confirmation to proceed
+ * @param error - The error that occurred
+ * @param commandName - Name of the command that failed
+ * @param silent - If true, log to debug and re-throw without user confirmation
+ * @throws UserCancelledError if user declines to proceed or presses Ctrl+C
+ */
+async function handlePluginError(error, commandName, silent = false) {
+    const pluginError = new ClaudePluginError(commandName, error instanceof Error ? error : undefined);
+    if (silent) {
+        debug('Plugin error: %s', pluginError.message);
+        throw error;
+    }
+    ux.warn(pluginError.message);
+    try {
+        const shouldProceed = await confirm({
+            message: 'Claude plugin setup failed.\n\nThis means your project will be without Output.ai-specific commands, skills, and subagents.' +
+                ' You will not be able to use our AI-assisted workflow planning and building functionality.\n\n' +
+                'Would you like to proceed without the Claude plugin setup?',
+            default: false
+        });
+        if (!shouldProceed) {
+            throw new UserCancelledError();
+        }
+    }
+    catch (promptError) {
+        if (promptError instanceof UserCancelledError) {
+            throw promptError;
+        }
+        // Ctrl+C throws ExitPromptError - convert to UserCancelledError
+        throw new UserCancelledError();
+    }
+}
+/**
+ * Register and update the OutputAI plugin marketplace
+ */
+async function registerPluginMarketplace(projectRoot, silent = false) {
+    const log = createLogger(silent);
+    log('Registering plugin marketplace...');
+    try {
+        await executeClaudeCommand(['plugin', 'marketplace', 'add', 'growthxai/output'], projectRoot, { ignoreFailure: true });
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin marketplace add', silent);
+        return;
+    }
+    log('Updating plugin marketplace...');
+    try {
+        await executeClaudeCommand(['plugin', 'marketplace', 'update', 'outputai'], projectRoot);
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin marketplace update outputai', silent);
+    }
+}
+/**
+ * Install the OutputAI plugin
+ */
+async function installOutputAIPlugin(projectRoot, silent = false) {
+    const log = createLogger(silent);
+    log('Installing OutputAI plugin...');
+    try {
+        await executeClaudeCommand(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], projectRoot);
+    }
+    catch (error) {
+        await handlePluginError(error, 'plugin install outputai@outputai', silent);
+    }
+}
+/**
+ * Ensure Claude Code plugin is configured
+ * Registers marketplace, updates it, and installs the plugin
+ */
+export async function ensureClaudePlugin(projectRoot, options = {}) {
+    const { silent = false } = options;
+    await registerPluginMarketplace(projectRoot, silent);
+    await installOutputAIPlugin(projectRoot, silent);
+}
+/**
+ * Initialize agent configuration files and register Claude Code plugin
+ * Creates:
+ * - .claude/settings.json (static JSON)
+ * - CLAUDE.md (from template - user-customizable file)
+ * Then runs Claude CLI commands to register the plugin marketplace and install the plugin
+ */
+export async function initializeAgentConfig(options) {
+    const { projectRoot, force } = options;
+    const variables = prepareTemplateVariables();
+    await createSettingsFile(projectRoot, force);
+    await createClaudeMdFile(projectRoot, force, variables);
+    await ensureClaudePlugin(projectRoot);
+}
+/**
+ * Ensure OutputAI system is initialized
+ * Creates configuration files and registers Claude Code plugin
+ * @param projectRoot - Root directory of the project
+ */
+export async function ensureOutputAISystem(projectRoot) {
+    const { isComplete, needsInit } = await checkAgentStructure(projectRoot);
+    if (isComplete) {
+        return;
+    }
+    if (needsInit) {
+        ux.warn('Agent configuration is incomplete. Initializing...');
+        await initializeAgentConfig({ projectRoot, force: false });
+    }
+}

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

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