@outputai/cli 0.1.4-dev.0 → 0.1.4

package/dist/services/env_configurator.js

@@ -1,163 +0,0 @@
-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';
-import { UserCancelledError } from '#types/errors.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.
- *
- * This function reads from .env.example and, when the user confirms configuration,
- * copies it to .env before prompting for values. The .env.example file remains
- * unchanged as a template for other developers.
- *
- * @param projectPath - The absolute path to the project directory containing the .env.example file
- * @param skipPrompt - If true, copies .env.example to .env without interactive prompts and returns false
- * @returns A promise that resolves to true if environment variables were successfully configured,
- *          false if configuration was skipped (no .env.example file, user declined, no variables to configure,
- *          or an error occurred)
- */
-export async function configureEnvironmentVariables(projectPath, skipPrompt = false) {
-    try {
-        ux.stdout('configuring environment variables...');
-        const envExamplePath = path.join(projectPath, '.env.example');
-        const envPath = path.join(projectPath, '.env');
-        // Copy .env.example to .env before configuring
-        await fs.copyFile(envExamplePath, envPath);
-        if (skipPrompt) {
-            return false;
-        }
-        const shouldConfigure = await confirm({
-            message: 'Would you like to configure environment variables now?',
-            default: true
-        });
-        if (!shouldConfigure) {
-            return false;
-        }
-        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) {
-        // Ctrl+C in @inquirer/prompts throws ExitPromptError - propagate as UserCancelledError
-        if (error instanceof Error && error.name === 'ExitPromptError') {
-            throw new UserCancelledError();
-        }
-        ux.warn(`Failed to configure environment variables: ${getErrorMessage(error)}`);
-        return false;
-    }
-}

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

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

package/dist/services/env_configurator.spec.js

@@ -1,192 +0,0 @@
-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(),
-    password: vi.fn()
-}));
-describe('configureEnvironmentVariables', () => {
-    const testState = { tempDir: '', envExamplePath: '', 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.envExamplePath = path.join(testState.tempDir, '.env.example');
-        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 copy .env.example to .env when skipPrompt is true', async () => {
-        const envExampleContent = 'API_KEY=<SECRET>\nDATABASE_URL=localhost';
-        await fs.writeFile(testState.envExamplePath, envExampleContent);
-        const result = await configureEnvironmentVariables(testState.tempDir, true);
-        expect(result).toBe(false);
-        const envContent = await fs.readFile(testState.envPath, 'utf-8');
-        expect(envContent).toBe(envExampleContent);
-    });
-    it('should return false if .env.example file does not exist', async () => {
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        expect(result).toBe(false);
-    });
-    it('should handle missing .env.example gracefully when skipPrompt is true', async () => {
-        const result = await configureEnvironmentVariables(testState.tempDir, true);
-        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.envExamplePath, '# 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.envExamplePath, 'APIKEY=my-secret-key');
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        expect(result).toBe(false);
-    });
-    it('should copy .env.example to .env when user confirms configuration', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(true);
-        vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
-        const originalContent = `# API key
-APIKEY=`;
-        await fs.writeFile(testState.envExamplePath, originalContent);
-        await configureEnvironmentVariables(testState.tempDir, false);
-        // Both files should exist
-        await expect(fs.access(testState.envExamplePath)).resolves.toBeUndefined();
-        await expect(fs.access(testState.envPath)).resolves.toBeUndefined();
-    });
-    it('should write configured values to .env while leaving .env.example unchanged', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(true);
-        vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
-        const originalContent = `# API key
-APIKEY=`;
-        await fs.writeFile(testState.envExamplePath, originalContent);
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        expect(result).toBe(true);
-        // .env should have the configured value
-        const envContent = await fs.readFile(testState.envPath, 'utf-8');
-        expect(envContent).toContain('APIKEY=sk-proj-123');
-        // .env.example should remain unchanged
-        const envExampleContent = await fs.readFile(testState.envExamplePath, 'utf-8');
-        expect(envExampleContent).toBe(originalContent);
-    });
-    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.envExamplePath, `# 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.envExamplePath, 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.envExamplePath, `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.envExamplePath, `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 handle case where .env already exists (overwrite with copy)', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(true);
-        vi.mocked(input).mockResolvedValueOnce('new-configured-value');
-        // Create existing .env with old content
-        await fs.writeFile(testState.envPath, 'OLD_KEY=old-value');
-        // Create .env.example with new content
-        await fs.writeFile(testState.envExamplePath, 'NEW_KEY=');
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        expect(result).toBe(true);
-        // .env should be overwritten with .env.example content and configured values
-        const envContent = await fs.readFile(testState.envPath, 'utf-8');
-        expect(envContent).toContain('NEW_KEY=new-configured-value');
-        expect(envContent).not.toContain('OLD_KEY');
-    });
-    it('should return false if an error occurs during parsing', async () => {
-        const { confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(true);
-        await fs.writeFile(testState.envExamplePath, 'KEY=');
-        // Delete the .env.example file after access check but before parsing would happen
-        // We simulate this by deleting during the copy operation
-        const originalCopyFile = fs.copyFile;
-        vi.spyOn(fs, 'copyFile').mockImplementation(async () => {
-            throw new Error('Copy failed');
-        });
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        // Should return false when error occurs
-        expect(result).toBe(false);
-        // Restore original function
-        vi.mocked(fs.copyFile).mockImplementation(originalCopyFile);
-    });
-    it('should prompt for SECRET marker values with password input', async () => {
-        const { password, confirm } = await import('@inquirer/prompts');
-        vi.mocked(confirm).mockResolvedValue(true);
-        vi.mocked(password).mockResolvedValueOnce('my-secret-api-key');
-        await fs.writeFile(testState.envExamplePath, `# API Key
-ANTHROPIC_API_KEY=<SECRET>`);
-        const result = await configureEnvironmentVariables(testState.tempDir, false);
-        expect(result).toBe(true);
-        expect(vi.mocked(password)).toHaveBeenCalledTimes(1);
-        const envContent = await fs.readFile(testState.envPath, 'utf-8');
-        expect(envContent).toContain('ANTHROPIC_API_KEY=my-secret-api-key');
-    });
-});

package/dist/services/generate_plan_name@v1.prompt

@@ -1,24 +0,0 @@
----
-provider: anthropic
-model: claude-haiku-4-5
-temperature: 0.3
----
-
-<assistant>
-You are a semantic naming assistant. Generate concise, descriptive slugs for workflow plans.
-</assistant>
-
-<user>
-Convert this workflow description into a short, semantic slug (2-6 words max):
-
-"{{ description }}"
-
-Requirements:
-- Use snake_case format
-- Be descriptive but concise
-- Focus on the core action/purpose
-- Use common technical terms
-- Maximum 50 characters
-
-Return ONLY the slug, no quotes, no explanation.
-</user>

package/dist/services/messages.d.ts

@@ -1,9 +0,0 @@
-/**
- * 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;
-export declare const getWorkflowGenerateSuccessMessage: (workflowName: string, targetDir: string, filesCreated: string[]) => string;
-export declare const getDevSuccessMessage: (services: Array<{
-    name: string;
-}>) => string;