@output.ai/cli 0.0.9 → 0.2.3

package/dist/services/env_configurator.js

@@ -0,0 +1,158 @@
+import { input, confirm, password } from '@inquirer/prompts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ux } from '@oclif/core';
+import { getErrorMessage } from '#utils/error_utils.js';
+const COMMENT_LINE = /^\s*#/;
+const COMMENTED_VAR = /^\s*#\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
+const ACTIVE_VAR = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/;
+const VAR_IN_COMMENT = /^\s*#\s*[A-Z_]+=/;
+const SECRET_MARKER = '<SECRET>';
+function extractDescription(commentLine) {
+    return commentLine.replace(/^\s*#\s*/, '').trim();
+}
+function isSecret(value) {
+    return value.trim() === SECRET_MARKER;
+}
+function createEnvVariable(match, options) {
+    return {
+        key: match[1],
+        value: match[2],
+        description: options.lastComment ? extractDescription(options.lastComment) : undefined,
+        lineNumber: options.lineNumber,
+        isCommented: options.isCommented,
+        originalLine: options.line,
+        isSecret: isSecret(match[2])
+    };
+}
+async function parseEnvFile(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    // Use an object to track state without reassigning
+    const state = { lastComment: null };
+    const variables = [];
+    lines.forEach((line, i) => {
+        // Check if line is a comment (but not a commented-out variable)
+        if (line.match(COMMENT_LINE) && !line.match(VAR_IN_COMMENT)) {
+            state.lastComment = line;
+            return;
+        }
+        // Check for commented-out variable
+        const commentedMatch = line.match(COMMENTED_VAR);
+        if (commentedMatch) {
+            variables.push(createEnvVariable(commentedMatch, {
+                lineNumber: i,
+                line,
+                isCommented: true,
+                lastComment: state.lastComment
+            }));
+            state.lastComment = null;
+            return;
+        }
+        // Check for active variable
+        const activeMatch = line.match(ACTIVE_VAR);
+        if (activeMatch) {
+            variables.push(createEnvVariable(activeMatch, {
+                lineNumber: i,
+                line,
+                isCommented: false,
+                lastComment: state.lastComment
+            }));
+            state.lastComment = null;
+            return;
+        }
+        // Reset lastComment if we hit a blank line or non-comment line
+        if (line.trim() === '' || !line.match(COMMENT_LINE)) {
+            state.lastComment = null;
+        }
+    });
+    return variables;
+}
+const isEmpty = (value) => value.trim() === '';
+const promptForVariables = async (variables) => variables.reduce(async (accPromise, variable) => {
+    const acc = await accPromise;
+    // Skip if value is not empty and not a secret marker
+    if (!isEmpty(variable.value) && !variable.isSecret) {
+        return [...acc, variable];
+    }
+    const description = variable.description ? ` (${variable.description})` : '';
+    // Use password prompt for secrets, regular input for others
+    const newValue = variable.isSecret ?
+        await password({
+            message: `${variable.key}${description} (secret):`,
+            mask: true
+        }) :
+        await input({
+            message: `${variable.key}${description}:`,
+            default: ''
+        });
+    return [
+        ...acc,
+        {
+            ...variable,
+            value: newValue,
+            isCommented: newValue ? false : variable.isCommented,
+            isSecret: false // Clear the secret flag after getting the actual value
+        }
+    ];
+}, Promise.resolve([]));
+async function writeEnvFile(filePath, variables) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const variableMap = new Map(variables.map(v => [v.lineNumber, v]));
+    const outputLines = lines.map((line, i) => {
+        const variable = variableMap.get(i);
+        if (variable) {
+            // Reconstruct the variable line
+            return `${variable.isCommented ? '# ' : ''}${variable.key}=${variable.value}`;
+        }
+        // Preserve other lines (comments, blank lines, etc.)
+        return line;
+    });
+    await fs.writeFile(filePath, outputLines.join('\n'), 'utf-8');
+}
+/**
+ * Interactively configures environment variables for a project by prompting the user
+ * to provide values for empty variables or variables marked as secrets.
+ *
+ * @param projectPath - The absolute path to the project directory containing the .env file
+ * @param skipPrompt - If true, skips the configuration prompt and returns false immediately
+ * @returns A promise that resolves to true if environment variables were successfully configured,
+ *          false if configuration was skipped (no .env file, user declined, no variables to configure,
+ *          or an error occurred)
+ */
+export async function configureEnvironmentVariables(projectPath, skipPrompt = false) {
+    if (skipPrompt) {
+        return false;
+    }
+    ux.stdout('configuring environment variables...');
+    const envPath = path.join(projectPath, '.env');
+    try {
+        await fs.access(envPath);
+    }
+    catch {
+        ux.stdout(ux.colorize('red', '🔴 .env file does not exist, nothing to configure'));
+        return false;
+    }
+    const shouldConfigure = await confirm({
+        message: 'Would you like to configure environment variables now?',
+        default: true
+    });
+    if (!shouldConfigure) {
+        return false;
+    }
+    try {
+        const variables = await parseEnvFile(envPath);
+        const variablesToConfigure = variables.filter(v => isEmpty(v.value) || v.isSecret);
+        if (variablesToConfigure.length === 0) {
+            return false;
+        }
+        const updated = await promptForVariables(variables);
+        await writeEnvFile(envPath, updated);
+        return true;
+    }
+    catch (error) {
+        ux.warn(`Failed to configure environment variables: ${getErrorMessage(error)}`);
+        return false;
+    }
+}

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

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

package/dist/services/env_configurator.spec.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { configureEnvironmentVariables } from './env_configurator.js';
+// Mock inquirer prompts
+vi.mock('@inquirer/prompts', () => ({
+    input: vi.fn(),
+    confirm: vi.fn()
+}));
+describe('configureEnvironmentVariables', () => {
+    const testState = { tempDir: '', envPath: '' };
+    beforeEach(async () => {
+        // Clear all mocks before each test
+        vi.clearAllMocks();
+        // Create temporary directory for test files
+        testState.tempDir = path.join('/tmp', `test-env-${Date.now()}`);
+        await fs.mkdir(testState.tempDir, { recursive: true });
+        testState.envPath = path.join(testState.tempDir, '.env');
+    });
+    afterEach(async () => {
+        // Clean up temporary directory
+        try {
+            await fs.rm(testState.tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    it('should return false if skipPrompt is true', async () => {
+        // Create a minimal .env file
+        await fs.writeFile(testState.envPath, 'KEY=value');
+        const result = await configureEnvironmentVariables(testState.tempDir, true);
+        expect(result).toBe(false);
+    });
+    it('should return false if .env file does not exist', async () => {
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        expect(result).toBe(false);
+    });
+    it('should return false if user declines configuration', async () => {
+        const { confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(false);
+        await fs.writeFile(testState.envPath, '# API key\nAPIKEY=');
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        expect(result).toBe(false);
+        expect(vi.mocked(confirm)).toHaveBeenCalled();
+    });
+    it('should return false if no empty variables exist', async () => {
+        const { confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(true);
+        await fs.writeFile(testState.envPath, 'APIKEY=my-secret-key');
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        expect(result).toBe(false);
+    });
+    it('should prompt for empty variables and update .env', async () => {
+        const { input, confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(true);
+        vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
+        vi.mocked(input).mockResolvedValueOnce('');
+        await fs.writeFile(testState.envPath, `# API key for Anthropic
+ANTHROPIC_API_KEY=
+
+# API key for OpenAI
+OPENAI_API_KEY=`);
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        expect(result).toBe(true);
+        // Verify file was updated
+        const content = await fs.readFile(testState.envPath, 'utf-8');
+        expect(content).toContain('ANTHROPIC_API_KEY=sk-proj-123');
+        expect(content).toContain('OPENAI_API_KEY=');
+    });
+    it('should preserve comments in .env file', async () => {
+        const { input, confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(true);
+        vi.mocked(input).mockResolvedValueOnce('test-key');
+        const originalContent = `# This is a comment
+# API key configuration
+APIKEY=
+
+# Another comment
+OTHER=value`;
+        await fs.writeFile(testState.envPath, originalContent);
+        await configureEnvironmentVariables(testState.tempDir, false);
+        const content = await fs.readFile(testState.envPath, 'utf-8');
+        expect(content).toContain('# This is a comment');
+        expect(content).toContain('# API key configuration');
+        expect(content).toContain('# Another comment');
+        expect(content).toContain('OTHER=value');
+    });
+    it('should skip placeholder values and only prompt for truly empty variables', async () => {
+        const { input, confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(true);
+        vi.mocked(input).mockResolvedValueOnce('new-key');
+        await fs.writeFile(testState.envPath, `APIKEY=your_api_key_here
+EMPTY_KEY=`);
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        expect(result).toBe(true);
+        expect(vi.mocked(input)).toHaveBeenCalledTimes(1);
+        expect(vi.mocked(input)).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('EMPTY_KEY')
+        }));
+    });
+    it('should skip variables with existing values', async () => {
+        const { input, confirm } = await import('@inquirer/prompts');
+        vi.mocked(confirm).mockResolvedValue(true);
+        vi.mocked(input).mockResolvedValueOnce('new-key');
+        await fs.writeFile(testState.envPath, `EXISTING_KEY=existing-value
+
+EMPTY_KEY=`);
+        await configureEnvironmentVariables(testState.tempDir, false);
+        // Should only prompt for EMPTY_KEY, not EXISTING_KEY
+        expect(vi.mocked(input)).toHaveBeenCalledTimes(1);
+    });
+    it('should return false if an error occurs during parsing', async () => {
+        // This test verifies error handling by checking behavior when file operations fail
+        // The try-catch in configureEnvironmentVariables should handle it gracefully
+        await fs.writeFile(testState.envPath, 'KEY=');
+        // Delete the file to cause parsing error
+        await fs.rm(testState.envPath);
+        const result = await configureEnvironmentVariables(testState.tempDir, false);
+        // Should return false when error occurs
+        expect(result).toBe(false);
+    });
+});

package/dist/services/messages.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Success and informational messages for project initialization
+ */
+export declare const getEjectSuccessMessage: (destPath: string, outputFile: string, binName: string) => string;
+export declare const getProjectSuccessMessage: (folderName: string, installSuccess: boolean, envConfigured?: boolean) => string;

package/dist/services/messages.js

@@ -0,0 +1,233 @@
+/**
+ * Success and informational messages for project initialization
+ */
+import { ux } from '@oclif/core';
+/**
+ * Creates a colored ASCII art banner for Output.ai
+ */
+const createOutputBanner = () => {
+    // ASCII art banner for "Output.ai"
+    const banner = `
+    ██████╗ ██╗   ██╗████████╗██████╗ ██╗   ██╗████████╗    █████╗ ██╗
+   ██╔═══██╗██║   ██║╚══██╔══╝██╔══██╗██║   ██║╚══██╔══╝   ██╔══██╗██║
+   ██║   ██║██║   ██║   ██║   ██████╔╝██║   ██║   ██║      ███████║██║
+   ██║   ██║██║   ██║   ██║   ██╔═══╝ ██║   ██║   ██║      ██╔══██║██║
+   ╚██████╔╝╚██████╔╝   ██║   ██║     ╚██████╔╝   ██║   ██╗██║  ██║██║
+    ╚═════╝  ╚═════╝    ╚═╝   ╚═╝      ╚═════╝    ╚═╝   ╚═╝╚═╝  ╚═╝╚═╝`;
+    // Apply gradient colors from cyan to magenta
+    const colors = ['cyan', 'cyan', 'blue', 'blue', 'magenta', 'magenta'];
+    return banner
+        .split('\n')
+        .map((line, index) => {
+        return ux.colorize(colors[index], line);
+    })
+        .join('\n');
+};
+/**
+ * Formats a command for display with proper styling
+ */
+const formatCommand = (command) => {
+    return ux.colorize('cyan', command);
+};
+/**
+ * Formats a file path for display
+ */
+const formatPath = (path) => {
+    return ux.colorize('yellow', path);
+};
+/**
+ * Creates a section header with styling
+ */
+const createSectionHeader = (title, icon = '') => {
+    const header = icon ? `${icon} ${title}` : title;
+    return ux.colorize('bold', header);
+};
+export const getEjectSuccessMessage = (destPath, outputFile, binName) => {
+    const divider = ux.colorize('dim', '─'.repeat(80));
+    const bulletPoint = ux.colorize('green', '▸');
+    // Build the customization tips
+    const customizationTips = [
+        {
+            title: 'Environment Variables',
+            description: 'Adjust service configurations and API settings'
+        },
+        {
+            title: 'Port Mappings',
+            description: 'Change exposed ports to avoid conflicts'
+        },
+        {
+            title: 'Service Versions',
+            description: 'Update Docker images to specific versions'
+        },
+        {
+            title: 'Volume Mounts',
+            description: 'Add custom volumes for persistent data'
+        },
+        {
+            title: 'Network Configuration',
+            description: 'Modify network settings for your infrastructure'
+        }
+    ];
+    const formattedTips = customizationTips.map(tip => {
+        return `  ${bulletPoint} ${ux.colorize('white', `${tip.title}:`)} ${ux.colorize('dim', tip.description)}`;
+    }).join('\n');
+    // Build common modifications examples
+    const examples = [
+        {
+            title: 'Change Redis port',
+            code: 'ports:\n      - \'6380:6379\'  # Changed from 6379'
+        },
+        {
+            title: 'Add environment variable',
+            code: 'environment:\n      - MY_CUSTOM_VAR=value'
+        },
+        {
+            title: 'Use specific image version',
+            code: 'image: redis:8.0.0-alpine  # Pin to specific version'
+        }
+    ];
+    const formattedExamples = examples.map((example, index) => {
+        const number = ux.colorize('dim', `${index + 1}.`);
+        const title = ux.colorize('white', example.title);
+        const code = ux.colorize('cyan', example.code.split('\n').map(line => `     ${line}`).join('\n'));
+        return `  ${number} ${title}\n${code}`;
+    }).join('\n\n');
+    return `
+
+${divider}
+
+${ux.colorize('bold', ux.colorize('green', '✅ SUCCESS!'))} ${ux.colorize('bold', 'Docker Compose configuration ejected')}
+
+${divider}
+
+${createSectionHeader('CONFIGURATION DETAILS', '📦')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Location:')} ${formatPath(destPath)}
+  ${bulletPoint} ${ux.colorize('white', 'Services:')} Temporal, Redis, PostgreSQL, API, Worker, UI
+  ${bulletPoint} ${ux.colorize('white', 'Network:')} Isolated bridge network for all services
+
+${divider}
+
+${createSectionHeader('USAGE', '🚀')}
+
+  ${ux.colorize('white', 'Start services with your custom configuration:')}
+
+    ${formatCommand(`${binName} dev --compose-file ${outputFile}`)}
+
+  ${ux.colorize('white', 'Or use Docker Compose directly:')}
+
+    ${formatCommand(`docker compose -f ${outputFile} up`)}
+
+${divider}
+
+${createSectionHeader('CUSTOMIZATION OPTIONS', '🎨')}
+
+${formattedTips}
+
+${divider}
+
+${createSectionHeader('COMMON MODIFICATIONS', '🔧')}
+
+${formattedExamples}
+
+${divider}
+
+${createSectionHeader('IMPORTANT NOTES', '⚠️')}
+
+  ${bulletPoint} ${ux.colorize('yellow', 'Service Dependencies:')} Maintain the ${ux.colorize('cyan', 'depends_on')} relationships
+  ${bulletPoint} ${ux.colorize('yellow', 'Health Checks:')} Keep health check configurations for service reliability
+  ${bulletPoint} ${ux.colorize('yellow', 'Volume Names:')} Be careful when changing volume names (data persistence)
+  ${bulletPoint} ${ux.colorize('yellow', 'Network Mode:')} The ${ux.colorize('cyan', 'main')} network connects all services
+
+${divider}
+
+${ux.colorize('dim', '💡 Tip: Test your changes with ')}${formatCommand('docker compose config')}${ux.colorize('dim', ' to validate the syntax')}
+
+${ux.colorize('green', ux.colorize('bold', 'Happy customizing! 🛠️'))}
+`;
+};
+export const getProjectSuccessMessage = (folderName, installSuccess, envConfigured = false) => {
+    const divider = ux.colorize('dim', '─'.repeat(80));
+    const bulletPoint = ux.colorize('green', '▸');
+    // Build the next steps array with proper formatting
+    const steps = [
+        {
+            step: 'Navigate to your project',
+            command: `cd ${folderName}`
+        }
+    ];
+    if (!installSuccess) {
+        steps.push({
+            step: 'Install dependencies',
+            command: 'npm install',
+            note: 'Required before running workflows'
+        });
+    }
+    if (!envConfigured) {
+        steps.push({
+            step: 'Configure environment variables',
+            command: 'Edit .env file',
+            note: 'Add your Anthropic/OpenAI API keys'
+        });
+    }
+    steps.push({
+        step: 'Start development services',
+        command: 'output dev',
+        note: 'Launches Temporal, Redis, PostgreSQL, API, Worker, and UI'
+    }, {
+        step: 'Run example workflow',
+        command: 'output workflow run simple --input \'{"question": "who really is ada lovelace?"}\'',
+        note: 'Execute in a new terminal after services are running'
+    }, {
+        step: 'Monitor workflows',
+        command: 'open http://localhost:8080',
+        note: 'Access Temporal UI for workflow visualization'
+    });
+    // Format each step with proper indentation and colors
+    const formattedSteps = steps.map((item, index) => {
+        const stepNumber = ux.colorize('dim', `${index + 1}.`);
+        const stepText = ux.colorize('white', item.step);
+        const command = item.command ? `\n     ${bulletPoint} ${formatCommand(item.command)}` : '';
+        const note = item.note ? `\n     ${ux.colorize('dim', `  ${item.note}`)}` : '';
+        return `  ${stepNumber} ${stepText}${command}${note}`;
+    }).join('\n\n');
+    // Build the complete message using template string
+    return `
+
+${createOutputBanner()}
+
+${divider}
+
+${ux.colorize('bold', ux.colorize('green', '🎉 SUCCESS!'))} ${ux.colorize('bold', 'Your Output SDK project has been created')}
+
+${divider}
+
+${createSectionHeader('PROJECT DETAILS', '📁')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Name:')} ${formatPath(folderName)}
+  ${bulletPoint} ${ux.colorize('white', 'Type:')} Output SDK Workflow Project
+  ${bulletPoint} ${ux.colorize('white', 'Structure:')} ${formatPath('.outputai/')} (agents), ${formatPath('workflows/')} (implementations)
+
+${divider}
+
+${createSectionHeader('NEXT STEPS', '🚀')}
+
+${formattedSteps}
+
+${divider}
+
+${createSectionHeader('QUICK START COMMANDS', '⚡')}
+
+  ${bulletPoint} ${ux.colorize('white', 'Plan a workflow:')}     ${formatCommand('output workflow plan')}
+  ${bulletPoint} ${ux.colorize('white', 'Generate from plan:')} ${formatCommand('output workflow generate')}
+  ${bulletPoint} ${ux.colorize('white', 'List workflows:')}      ${formatCommand('output workflow list')}
+  ${bulletPoint} ${ux.colorize('white', 'View help:')}           ${formatCommand('output --help')}
+
+${divider}
+
+${ux.colorize('dim', '💡 Tip: Use ')}${formatCommand('output workflow plan')}${ux.colorize('dim', ' to design your first custom workflow')}
+${ux.colorize('dim', '         with AI assistance.')}
+
+${ux.colorize('green', ux.colorize('bold', 'Happy building with Output SDK! 🚀'))}
+`;
+};

package/dist/services/project_scaffold.d.ts

@@ -0,0 +1,6 @@
+export declare function runInit(log: (message: string) => void, _warn: (message: string) => void, skipEnv?: boolean): Promise<void>;
+export declare function handleRunInitError(error: unknown, warn: (message: string) => void): Promise<{
+    shouldCleanup: boolean;
+    errorMessage: string;
+    projectPath: string | null;
+}>;

package/dist/services/project_scaffold.js

@@ -0,0 +1,140 @@
+import { input } from '@inquirer/prompts';
+import { kebabCase, pascalCase } from 'change-case';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { FolderAlreadyExistsError, UserCancelledError, DirectoryCreationError } from '#types/errors.js';
+import { createDirectory, removeDirectory } from '#utils/file_system.js';
+import { executeCommand, executeCommandWithMessages } from '#utils/process.js';
+import { getSDKVersions } from '#utils/sdk_versions.js';
+import { getErrorMessage, getErrorCode } from '#utils/error_utils.js';
+import { configureEnvironmentVariables } from './env_configurator.js';
+import { getTemplateFiles, processTemplateFile } from './template_processor.js';
+import { ensureOutputAIStructure } from './coding_agents.js';
+import { getProjectSuccessMessage } from './messages.js';
+const getProjectConfig = async () => {
+    try {
+        const projectName = await input({
+            message: 'What is your project name?',
+            default: 'my-outputai-workflows'
+        }) || 'my-outputai-workflows';
+        const folderName = await input({
+            message: 'What folder name should be used?',
+            default: kebabCase(projectName)
+        }) || kebabCase(projectName);
+        const description = await input({
+            message: 'What is your project description? (optional)',
+            default: `An Output SDK workflow for ${kebabCase(projectName)}`
+        }) || `An Output SDK workflow for ${kebabCase(projectName)}`;
+        return {
+            projectName,
+            folderName,
+            projectPath: path.resolve(process.cwd(), folderName),
+            description
+        };
+    }
+    catch {
+        throw new UserCancelledError();
+    }
+};
+async function scaffoldProjectFiles(projectPath, projectName, description) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const templatesDir = path.join(__dirname, '..', 'templates', 'project');
+    // Get SDK versions for dynamic template injection
+    const sdkVersions = await getSDKVersions();
+    const templateVars = {
+        projectName: kebabCase(projectName),
+        ProjectName: pascalCase(projectName),
+        description: description || `An Output SDK workflow for ${projectName}`,
+        coreVersion: sdkVersions.core,
+        llmVersion: sdkVersions.llm,
+        httpVersion: sdkVersions.http,
+        cliVersion: sdkVersions.cli
+    };
+    const templateFiles = await getTemplateFiles(templatesDir);
+    await Promise.all(templateFiles.map(templateFile => processTemplateFile(templateFile, projectPath, templateVars)));
+    return templateFiles.map(f => f.outputName);
+}
+async function executeNpmInstall(projectPath) {
+    await executeCommand('npm', ['install'], projectPath);
+}
+async function initializeAgents(projectPath) {
+    await ensureOutputAIStructure(projectPath);
+}
+function extractProjectPath(error) {
+    if (error instanceof FolderAlreadyExistsError) {
+        return error.folderPath;
+    }
+    const errorObject = error;
+    if (errorObject.projectPath) {
+        return errorObject.projectPath;
+    }
+    return null;
+}
+function handleInitError(error, projectPath) {
+    if (error instanceof UserCancelledError) {
+        return {
+            shouldCleanup: false,
+            errorMessage: error.message
+        };
+    }
+    if (error instanceof FolderAlreadyExistsError) {
+        return {
+            shouldCleanup: false,
+            errorMessage: error.message
+        };
+    }
+    const errorCode = getErrorCode(error);
+    if (errorCode === 'EEXIST') {
+        return {
+            shouldCleanup: false,
+            errorMessage: 'Folder already exists'
+        };
+    }
+    if (errorCode === 'EACCES') {
+        return {
+            shouldCleanup: projectPath !== null,
+            errorMessage: 'Permission denied'
+        };
+    }
+    return {
+        shouldCleanup: projectPath !== null,
+        errorMessage: 'Failed to create project'
+    };
+}
+export async function runInit(log, _warn, skipEnv = false) {
+    const config = await getProjectConfig();
+    try {
+        createDirectory(config.projectPath);
+    }
+    catch (error) {
+        throw new DirectoryCreationError(getErrorMessage(error), config.projectPath);
+    }
+    log(`✅ Created project folder: ${config.folderName}`);
+    try {
+        const filesCreated = await scaffoldProjectFiles(config.projectPath, config.projectName, config.description);
+        log(`✅ Created ${filesCreated.length} project files`);
+    }
+    catch (error) {
+        const enrichedError = error;
+        enrichedError.projectPath = config.projectPath;
+        throw enrichedError;
+    }
+    const envConfigured = await configureEnvironmentVariables(config.projectPath, skipEnv);
+    if (envConfigured) {
+        log('🔐 Environment variables configured in .env');
+    }
+    await executeCommandWithMessages(() => initializeAgents(config.projectPath), '🤖 Initializing agent system...', '✅ Agent system initialized in .outputai/');
+    const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), '📦 Installing dependencies...', '✅ Dependencies installed');
+    const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, envConfigured);
+    log('✅ Project created successfully!');
+    log(nextSteps);
+}
+export async function handleRunInitError(error, warn) {
+    const projectPath = extractProjectPath(error);
+    const { shouldCleanup, errorMessage } = handleInitError(error, projectPath);
+    if (shouldCleanup && projectPath) {
+        await removeDirectory(projectPath, warn);
+    }
+    return { shouldCleanup, errorMessage, projectPath };
+}

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

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