@outputai/cli 0.2.1-next.af8a069.0 → 0.2.1-next.bc8ccee.0

package/dist/hooks/init.js

@@ -1,6 +1,22 @@
 import { ux } from '@oclif/core';
 import { checkForUpdate } from '#services/version_check.js';
-const hook = async function () {
+import { setNonInteractive } from '#utils/interactive.js';
+export const INTERACTIVE_FLAGS = ['--yes', '--non-interactive'];
+export const GLOBAL_FLAGS = new Set(INTERACTIVE_FLAGS);
+export const hasInteractiveFlag = (argv) => argv.some(arg => INTERACTIVE_FLAGS.includes(arg));
+export const stripGlobalFlags = (argv) => {
+    const kept = argv.filter(arg => !GLOBAL_FLAGS.has(arg));
+    if (kept.length !== argv.length) {
+        argv.splice(0, argv.length, ...kept);
+    }
+};
+const hook = async function (opts) {
+    const interactive = hasInteractiveFlag(opts.argv) || hasInteractiveFlag(process.argv);
+    stripGlobalFlags(opts.argv);
+    stripGlobalFlags(process.argv);
+    if (interactive) {
+        setNonInteractive(true);
+    }
     try {
         const result = await checkForUpdate(this.config.version, this.config.cacheDir);
         if (!result.updateAvailable) {

package/dist/hooks/init.spec.js

@@ -1,9 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { checkForUpdate } from '#services/version_check.js';
+import { setNonInteractive } from '#utils/interactive.js';
 vi.mock('#services/version_check.js', () => ({
     checkForUpdate: vi.fn()
 }));
+vi.mock('#utils/interactive.js', () => ({
+    setNonInteractive: vi.fn()
+}));
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),
@@ -11,7 +15,7 @@ vi.mock('@oclif/core', () => ({
     }
 }));
 import { ux } from '@oclif/core';
-import hook from './init.js';
+import hook, { hasInteractiveFlag, stripGlobalFlags } from './init.js';
 describe('init hook', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -26,7 +30,7 @@ describe('init hook', () => {
             latestVersion: '1.0.0'
         });
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(checkForUpdate).toHaveBeenCalledWith('0.8.4', '/tmp/test-cache');
         expect(ux.stdout).toHaveBeenCalled();
         const output = vi.mocked(ux.stdout).mock.calls.map(c => c[0]).join('\n');
@@ -42,13 +46,83 @@ describe('init hook', () => {
             latestVersion: '0.8.4'
         });
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(ux.stdout).not.toHaveBeenCalled();
     });
     it('should silently handle errors', async () => {
         vi.mocked(checkForUpdate).mockRejectedValue(new Error('network failure'));
         const ctx = createHookContext();
-        await hook.call(ctx, {});
+        await hook.call(ctx, { argv: [], id: undefined });
         expect(ux.stdout).not.toHaveBeenCalled();
     });
+    describe('global interactive flags', () => {
+        const originalArgv = process.argv;
+        beforeEach(() => {
+            vi.mocked(checkForUpdate).mockResolvedValue({
+                updateAvailable: false,
+                currentVersion: '0.8.4',
+                latestVersion: '0.8.4'
+            });
+        });
+        afterEach(() => {
+            process.argv = originalArgv;
+        });
+        it('should mutate opts.argv in place to strip --yes', async () => {
+            process.argv = ['node', 'run.js', 'init', '--yes', 'my-project'];
+            const optsArgv = ['--yes', 'my-project'];
+            const argvRef = optsArgv;
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).toHaveBeenCalledWith(true);
+            expect(optsArgv).toBe(argvRef);
+            expect(optsArgv).toEqual(['my-project']);
+            expect(process.argv).toEqual(['node', 'run.js', 'init', 'my-project']);
+        });
+        it('should mutate opts.argv in place to strip --non-interactive', async () => {
+            process.argv = ['node', 'run.js', 'init', '--non-interactive'];
+            const optsArgv = ['--non-interactive'];
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).toHaveBeenCalledWith(true);
+            expect(optsArgv).toEqual([]);
+            expect(process.argv).toEqual(['node', 'run.js', 'init']);
+        });
+        it('should leave argv untouched when no global flag is present', async () => {
+            process.argv = ['node', 'run.js', 'init', '--skip-env'];
+            const optsArgv = ['--skip-env'];
+            const ctx = createHookContext();
+            await hook.call(ctx, { argv: optsArgv, id: 'init' });
+            expect(setNonInteractive).not.toHaveBeenCalled();
+            expect(optsArgv).toEqual(['--skip-env']);
+            expect(process.argv).toEqual(['node', 'run.js', 'init', '--skip-env']);
+        });
+    });
+    describe('hasInteractiveFlag', () => {
+        it('returns true when --yes is present', () => {
+            expect(hasInteractiveFlag(['init', '--yes', 'foo'])).toBe(true);
+        });
+        it('returns true when --non-interactive is present', () => {
+            expect(hasInteractiveFlag(['--non-interactive'])).toBe(true);
+        });
+        it('returns false for unrelated flags', () => {
+            expect(hasInteractiveFlag(['init', '--skip-env', '--skip-git'])).toBe(false);
+        });
+        it('returns false for an empty argv', () => {
+            expect(hasInteractiveFlag([])).toBe(false);
+        });
+    });
+    describe('stripGlobalFlags', () => {
+        it('mutates argv in place to remove global flags', () => {
+            const argv = ['init', '--yes', 'foo', '--non-interactive'];
+            const ref = argv;
+            stripGlobalFlags(argv);
+            expect(argv).toBe(ref);
+            expect(argv).toEqual(['init', 'foo']);
+        });
+        it('leaves argv untouched when no global flag is present', () => {
+            const argv = ['init', '--skip-env'];
+            stripGlobalFlags(argv);
+            expect(argv).toEqual(['init', '--skip-env']);
+        });
+    });
 });

package/dist/services/coding_agents.js

@@ -7,7 +7,8 @@ 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 { confirm } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import debugFactory from 'debug';
 import { getTemplateDir } from '#utils/paths.js';
 import { executeClaudeCommand } from '#utils/claude.js';
@@ -142,6 +143,9 @@ async function handlePluginError(error, commandName, silent = false) {
         debug('Plugin error: %s', pluginError.message);
         throw error;
     }
+    if (!isInteractive()) {
+        throw pluginError;
+    }
     ux.warn(pluginError.message);
     try {
         const shouldProceed = await confirm({

package/dist/services/coding_agents.spec.js

@@ -19,9 +19,12 @@ vi.mock('@oclif/core', () => ({
         colorize: vi.fn().mockImplementation((_color, text) => text)
     }
 }));
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     confirm: vi.fn()
 }));
+vi.mock('#utils/interactive.js', () => ({
+    isInteractive: vi.fn(() => true)
+}));
 describe('coding_agents service', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -157,7 +160,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when plugin commands fail', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
@@ -169,7 +172,7 @@ describe('coding_agents service', () => {
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
             vi.mocked(confirm).mockResolvedValue(true);
@@ -219,7 +222,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when registerPluginMarketplace fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
@@ -231,7 +234,7 @@ describe('coding_agents service', () => {
         });
         it('should show error and prompt user when installOutputAIPlugin fails', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockResolvedValueOnce(undefined) // marketplace add
                 .mockResolvedValueOnce(undefined) // marketplace update
@@ -244,7 +247,7 @@ describe('coding_agents service', () => {
         });
         it('should allow user to proceed without plugin setup if they confirm', async () => {
             const { executeClaudeCommand } = await import('../utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(executeClaudeCommand)
                 .mockRejectedValue(new Error('All plugin commands fail'));
             vi.mocked(confirm).mockResolvedValue(true);
@@ -252,5 +255,15 @@ describe('coding_agents service', () => {
             // File operations should still complete
             expect(fs.mkdir).toHaveBeenCalled();
         });
+        it('should rethrow plugin error in non-interactive mode without prompting', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('#utils/prompt.js');
+            const { isInteractive } = await import('#utils/interactive.js');
+            vi.mocked(isInteractive).mockReturnValueOnce(false);
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValueOnce(new Error('Plugin marketplace add failed'));
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).rejects.toThrow(/plugin marketplace add/i);
+            expect(confirm).not.toHaveBeenCalled();
+        });
     });
 });

package/dist/services/credentials_configurator.js

@@ -1,4 +1,4 @@
-import { password, confirm } from '@inquirer/prompts';
+import { password, confirm } from '#utils/prompt.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { ux } from '@oclif/core';

package/dist/services/env_configurator.js

@@ -1,4 +1,4 @@
-import { input, confirm, password } from '@inquirer/prompts';
+import { input, confirm, password } from '#utils/prompt.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { ux } from '@oclif/core';

package/dist/services/env_configurator.spec.js

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { configureEnvironmentVariables } from './env_configurator.js';
 // Mock inquirer prompts
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     input: vi.fn(),
     confirm: vi.fn(),
     password: vi.fn()
@@ -45,7 +45,7 @@ describe('configureEnvironmentVariables', () => {
         expect(result).toBe(false);
     });
     it('should return false if user declines configuration', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(false);
         await fs.writeFile(testState.envExamplePath, '# API key\nAPIKEY=');
         const result = await configureEnvironmentVariables(testState.tempDir, false);
@@ -53,14 +53,14 @@ describe('configureEnvironmentVariables', () => {
         expect(vi.mocked(confirm)).toHaveBeenCalled();
     });
     it('should return false if no empty variables exist', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         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');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -72,7 +72,7 @@ APIKEY=`;
         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');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         const originalContent = `# API key
@@ -88,7 +88,7 @@ APIKEY=`;
         expect(envExampleContent).toBe(originalContent);
     });
     it('should prompt for empty variables and update .env', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('sk-proj-123');
         vi.mocked(input).mockResolvedValueOnce('');
@@ -105,7 +105,7 @@ OPENAI_API_KEY=`);
         expect(content).toContain('OPENAI_API_KEY=');
     });
     it('should preserve comments in .env file', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('test-key');
         const originalContent = `# This is a comment
@@ -123,7 +123,7 @@ OTHER=value`;
         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');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `APIKEY=your_api_key_here
@@ -136,7 +136,7 @@ EMPTY_KEY=`);
         }));
     });
     it('should skip variables with existing values', async () => {
-        const { input, confirm } = await import('@inquirer/prompts');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-key');
         await fs.writeFile(testState.envExamplePath, `EXISTING_KEY=existing-value
@@ -147,7 +147,7 @@ EMPTY_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');
+        const { input, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(input).mockResolvedValueOnce('new-configured-value');
         // Create existing .env with old content
@@ -162,7 +162,7 @@ EMPTY_KEY=`);
         expect(envContent).not.toContain('OLD_KEY');
     });
     it('should return false if an error occurs during parsing', async () => {
-        const { confirm } = await import('@inquirer/prompts');
+        const { confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         await fs.writeFile(testState.envExamplePath, 'KEY=');
         // Delete the .env.example file after access check but before parsing would happen
@@ -178,7 +178,7 @@ EMPTY_KEY=`);
         vi.mocked(fs.copyFile).mockImplementation(originalCopyFile);
     });
     it('should prompt for SECRET marker values with password input', async () => {
-        const { password, confirm } = await import('@inquirer/prompts');
+        const { password, confirm } = await import('#utils/prompt.js');
         vi.mocked(confirm).mockResolvedValue(true);
         vi.mocked(password).mockResolvedValueOnce('my-secret-api-key');
         await fs.writeFile(testState.envExamplePath, `# API Key

package/dist/services/project_scaffold.d.ts

@@ -27,5 +27,5 @@ export declare function createSigintHandler(projectPath: string, folderCreated:
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export declare function runInit(skipEnv?: boolean, folderName?: string): Promise<void>;
+export declare function runInit(skipEnv?: boolean, skipGit?: boolean, folderName?: string): Promise<void>;
 export {};

package/dist/services/project_scaffold.js

@@ -1,4 +1,4 @@
-import { input, confirm } from '@inquirer/prompts';
+import { input, confirm } from '#utils/prompt.js';
 import { ux } from '@oclif/core';
 import { kebabCase, pascalCase } from 'change-case';
 import fs from 'node:fs/promises';
@@ -119,6 +119,18 @@ async function executeNpmInstall(projectPath) {
 async function initializeAgents(projectPath) {
     await initializeAgentConfig({ projectRoot: projectPath, force: false });
 }
+async function maybeInitializeGit(projectPath) {
+    const shouldInit = await confirm({
+        message: 'Initialize a git repository?',
+        default: true
+    });
+    if (!shouldInit) {
+        return false;
+    }
+    return executeCommandWithMessages(async () => {
+        await executeCommand('git', ['init'], projectPath);
+    }, 'Initializing git repository...', 'Git repository initialized');
+}
 /**
  * Format error message for init errors
  * Single responsibility: only format error messages, no cleanup logic
@@ -172,7 +184,7 @@ function handleRunInitError(error, projectPath, projectFolderCreated) {
  * @param skipEnv - Whether to skip environment configuration prompts
  * @param folderName - Optional folder name to skip folder name prompt
  */
-export async function runInit(skipEnv = false, folderName) {
+export async function runInit(skipEnv = false, skipGit = false, folderName) {
     // Track state for SIGINT cleanup using an object to avoid let
     const state = {
         projectFolderCreated: false,
@@ -210,6 +222,9 @@ export async function runInit(skipEnv = false, folderName) {
         await fs.copyFile(path.join(config.projectPath, '.env.example'), path.join(config.projectPath, '.env'));
         await executeCommandWithMessages(() => initializeAgents(config.projectPath), 'Initializing agent system...', 'Agent system initialized');
         const installSuccess = await executeCommandWithMessages(() => executeNpmInstall(config.projectPath), 'Installing dependencies...', 'Dependencies installed');
+        if (!skipGit) {
+            await maybeInitializeGit(config.projectPath);
+        }
         const nextSteps = getProjectSuccessMessage(config.folderName, installSuccess, credentialsConfigured);
         ux.stdout('Project created successfully!');
         ux.stdout(nextSteps);

package/dist/services/project_scaffold.spec.js

@@ -8,7 +8,7 @@ vi.mock('#utils/framework_version.js', () => ({
     })
 }));
 // Mock other dependencies
-vi.mock('@inquirer/prompts', () => ({
+vi.mock('#utils/prompt.js', () => ({
     input: vi.fn(),
     confirm: vi.fn()
 }));
@@ -47,7 +47,7 @@ describe('project_scaffold', () => {
     });
     describe('getProjectConfig', () => {
         it('should skip all prompts when folderName is provided', async () => {
-            const { input } = await import('@inquirer/prompts');
+            const { input } = await import('#utils/prompt.js');
             const config = await getProjectConfig('my-project');
             expect(config.folderName).toBe('my-project');
             expect(config.projectName).toBe('my-project');
@@ -58,7 +58,7 @@ describe('project_scaffold', () => {
             expect(config.description).toBe('AI Agents & Workflows built with Output.ai for test-folder');
         });
         it('should prompt for project name and folder name when not provided', async () => {
-            const { input } = await import('@inquirer/prompts');
+            const { input } = await import('#utils/prompt.js');
             vi.mocked(input)
                 .mockResolvedValueOnce('Test Project')
                 .mockResolvedValueOnce('test-project');
@@ -73,7 +73,7 @@ describe('project_scaffold', () => {
         it('should not prompt when all dependencies are available', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(true);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             await checkDependencies();
@@ -82,7 +82,7 @@ describe('project_scaffold', () => {
         it('should prompt user when docker is missing', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(true);
@@ -94,7 +94,7 @@ describe('project_scaffold', () => {
         it('should throw UserCancelledError when user declines to proceed', async () => {
             const { isDockerInstalled } = await import('#services/docker.js');
             const { isClaudeCliAvailable } = await import('#utils/claude.js');
-            const { confirm } = await import('@inquirer/prompts');
+            const { confirm } = await import('#utils/prompt.js');
             vi.mocked(isDockerInstalled).mockReturnValue(false);
             vi.mocked(isClaudeCliAvailable).mockReturnValue(true);
             vi.mocked(confirm).mockResolvedValue(false);

package/dist/services/workflow_builder.js

@@ -2,7 +2,8 @@
  * Workflow builder service for implementing workflows from plan files
  */
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow as invokeBuildWorkflowFromClient, replyToClaude } from './claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
+import { isInteractive } from '#utils/interactive.js';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
@@ -70,6 +71,9 @@ async function processModification(modification, currentOutput) {
     }
 }
 async function interactiveRefinementLoop(currentOutput) {
+    if (!isInteractive()) {
+        return currentOutput;
+    }
     const modification = await promptForModification();
     if (isAcceptCommand(modification)) {
         return currentOutput;

package/dist/services/workflow_builder.spec.js

@@ -1,11 +1,12 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { buildWorkflow, buildWorkflowInteractiveLoop } from './workflow_builder.js';
 import { ADDITIONAL_INSTRUCTIONS, BUILD_COMMAND_OPTIONS, invokeBuildWorkflow, replyToClaude } from './claude_client.js';
-import { input } from '@inquirer/prompts';
+import { input } from '#utils/prompt.js';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 vi.mock('./claude_client.js');
-vi.mock('@inquirer/prompts');
+vi.mock('#utils/prompt.js');
+vi.mock('#utils/interactive.js', () => ({ isInteractive: () => true }));
 vi.mock('@oclif/core', () => ({
     ux: {
         stdout: vi.fn(),

package/dist/utils/env_loader.js

@@ -7,11 +7,10 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import * as dotenv from 'dotenv';
 import debugFactory from 'debug';
-import { config } from '#config.js';
 const debug = debugFactory('output-cli:env-loader');
 export function loadEnvironment() {
     const cwd = process.cwd();
-    const envFile = config.envFile;
+    const envFile = process.env.OUTPUT_CLI_ENV || '.env';
     const envPath = resolve(cwd, envFile);
     if (!existsSync(envPath)) {
         debug(`Warning: Env file not found: ${envPath}`);

package/dist/utils/error_handler.js

@@ -1,11 +1,13 @@
 import { config } from '#config.js';
-const DEFAULT_MESSAGES = {
-    ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
-    401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
-    404: 'Resource not found.',
-    500: 'Server error.',
-    UNKNOWN: 'An unknown error occurred.'
-};
+function getDefaultMessages() {
+    return {
+        ECONNREFUSED: `Connection refused to ${config.apiUrl}. Is the API server running?`,
+        401: 'Authentication failed. Check your OUTPUT_API_AUTH_TOKEN.',
+        404: 'Resource not found.',
+        500: 'Server error.',
+        UNKNOWN: 'An unknown error occurred.'
+    };
+}
 /**
  * Extract error type and message from API response data
  */
@@ -49,7 +51,7 @@ function getDetailedErrorMessage(error) {
 }
 export function handleApiError(error, errorFn, overrides = {}) {
     const apiError = error;
-    const errorMessages = { ...DEFAULT_MESSAGES, ...overrides };
+    const errorMessages = { ...getDefaultMessages(), ...overrides };
     if (apiError.code === 'ECONNREFUSED' || apiError.cause?.code === 'ECONNREFUSED') {
         errorFn(errorMessages.ECONNREFUSED, { exit: 1 });
     }

package/dist/utils/interactive.d.ts

@@ -0,0 +1,2 @@
+export declare const setNonInteractive: (value: boolean) => void;
+export declare const isInteractive: () => boolean;

package/dist/utils/interactive.js

@@ -0,0 +1,5 @@
+const state = { nonInteractive: false };
+export const setNonInteractive = (value) => {
+    state.nonInteractive = value;
+};
+export const isInteractive = () => !state.nonInteractive && !!process.stdin.isTTY;

package/dist/utils/interactive.spec.d.ts

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

package/dist/utils/interactive.spec.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+describe('interactive', () => {
+    beforeEach(async () => {
+        // Re-import to reset singleton state
+        const mod = await import('./interactive.js');
+        mod.setNonInteractive(false);
+    });
+    it('isInteractive returns true by default when TTY is available', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false when no TTY', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: undefined, configurable: true });
+        const { isInteractive } = await import('./interactive.js');
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('isInteractive returns false after setNonInteractive(true)', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+    it('setNonInteractive(false) restores interactive mode', async () => {
+        const originalIsTTY = process.stdin.isTTY;
+        Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
+        const { isInteractive, setNonInteractive } = await import('./interactive.js');
+        setNonInteractive(true);
+        expect(isInteractive()).toBe(false);
+        setNonInteractive(false);
+        expect(isInteractive()).toBe(true);
+        Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    });
+});

package/dist/utils/prompt.d.ts

@@ -0,0 +1,17 @@
+type ConfirmOptions = {
+    message: string;
+    default?: boolean;
+};
+type InputOptions = {
+    message: string;
+    default?: string;
+    validate?: (value: string) => boolean | string;
+};
+type PasswordOptions = {
+    message: string;
+    mask?: boolean;
+};
+export declare const confirm: (options: ConfirmOptions) => Promise<boolean>;
+export declare const input: (options: InputOptions) => Promise<string>;
+export declare const password: (options: PasswordOptions) => Promise<string>;
+export {};

package/dist/utils/prompt.js

@@ -0,0 +1,20 @@
+import { confirm as inquirerConfirm, input as inquirerInput, password as inquirerPassword } from '@inquirer/prompts';
+import { isInteractive } from './interactive.js';
+export const confirm = async (options) => {
+    if (!isInteractive()) {
+        return true;
+    }
+    return inquirerConfirm(options);
+};
+export const input = async (options) => {
+    if (!isInteractive()) {
+        return options.default ?? '';
+    }
+    return inquirerInput(options);
+};
+export const password = async (options) => {
+    if (!isInteractive()) {
+        return '';
+    }
+    return inquirerPassword(options);
+};

package/dist/utils/prompt.spec.d.ts

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