@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc1

package/dist/lib/commands.spec.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock chalk to avoid ANSI codes in tests
+jest.unstable_mockModule('chalk', () => ({
+    default: {
+        gray: (str) => str,
+    },
+}));
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { checkCommandExists, execute } = await import('./commands.js');
+// Type the mock properly
+const mockExeca = execa;
+describe('commands', () => {
+    describe('checkCommandExists', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('returns true when command executes successfully', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'v1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('helm', ['version']);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['version']);
+        });
+        it('returns false when command fails', async () => {
+            mockExeca.mockRejectedValue(new Error('Command not found'));
+            const result = await checkCommandExists('nonexistent', ['--version']);
+            expect(result).toBe(false);
+            expect(mockExeca).toHaveBeenCalledWith('nonexistent', ['--version']);
+        });
+        it('uses default --version arg when no args provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('node');
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('node', ['--version']);
+        });
+        it('uses custom args when provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'Client Version: v1.28.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('kubectl', [
+                'version',
+                '--client',
+            ]);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'version',
+                '--client',
+            ]);
+        });
+        it('handles empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('echo', []);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('echo', []);
+        });
+    });
+    describe('execute', () => {
+        let mockConsoleLog;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            mockConsoleLog.mockRestore();
+        });
+        it('executes command without verbose output by default', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' });
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('prints command when verbose is true', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' }, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ helm install test');
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('works with empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('ls', [], {}, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ ls ');
+            expect(mockExeca).toHaveBeenCalledWith('ls', [], {});
+        });
+        it('passes through execa options correctly', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const execaOpts = { stdio: 'pipe', timeout: 5000, cwd: '/tmp' };
+            await execute('kubectl', ['get', 'pods'], execaOpts);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'pods'], execaOpts);
+        });
+        it('handles command failure', async () => {
+            const error = new Error('Command failed');
+            mockExeca.mockRejectedValue(error);
+            await expect(execute('fail', ['now'])).rejects.toThrow('Command failed');
+            expect(mockExeca).toHaveBeenCalledWith('fail', ['now'], {});
+        });
+        it('defaults to no verbose when additionalOptions not provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'ok',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('echo', ['test']);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('echo', ['test'], {});
+        });
+    });
+});

package/dist/lib/config.d.ts

@@ -4,6 +4,8 @@ export interface ChatConfig {
 }
 export interface ArkConfig {
     chat?: ChatConfig;
+    latestVersion?: string;
+    currentVersion?: string;
 }
 /**
  * Load configuration from multiple sources with proper precedence:

package/dist/lib/config.js

@@ -24,8 +24,9 @@ export function loadConfig() {
             const userConfig = yaml.parse(fs.readFileSync(userConfigPath, 'utf-8'));
             mergeConfig(config, userConfig);
         }
-        catch (_e) {
-            // Silently ignore invalid config files
+        catch (e) {
+            const message = e instanceof Error ? e.message : 'Unknown error';
+            throw new Error(`Invalid YAML in ${userConfigPath}: ${message}`);
         }
     }
     // Load project config from current directory
@@ -35,8 +36,9 @@ export function loadConfig() {
             const projectConfig = yaml.parse(fs.readFileSync(projectConfigPath, 'utf-8'));
             mergeConfig(config, projectConfig);
         }
-        catch (_e) {
-            // Silently ignore invalid config files
+        catch (e) {
+            const message = e instanceof Error ? e.message : 'Unknown error';
+            throw new Error(`Invalid YAML in ${projectConfigPath}: ${message}`);
         }
     }
     // Apply environment variable overrides

package/dist/lib/config.spec.d.ts

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

package/dist/lib/config.spec.js

@@ -0,0 +1,99 @@
+import { jest } from '@jest/globals';
+import path from 'path';
+import os from 'os';
+const mockFs = {
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+};
+jest.unstable_mockModule('fs', () => ({
+    default: mockFs,
+    ...mockFs,
+}));
+const mockYaml = {
+    parse: jest.fn(),
+    stringify: jest.fn(),
+};
+jest.unstable_mockModule('yaml', () => ({
+    default: mockYaml,
+    ...mockYaml,
+}));
+const { loadConfig, getConfigPaths, formatConfig } = await import('./config.js');
+describe('config', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it('returns default config when no files exist', () => {
+        mockFs.existsSync.mockReturnValue(false);
+        const config = loadConfig();
+        expect(config).toEqual({
+            chat: {
+                streaming: true,
+                outputFormat: 'text',
+            },
+        });
+    });
+    it('loads and merges configs in order: defaults, user, project', () => {
+        mockFs.existsSync.mockReturnValue(true);
+        mockFs.readFileSync
+            .mockReturnValueOnce('user yaml')
+            .mockReturnValueOnce('project yaml');
+        mockYaml.parse
+            .mockReturnValueOnce({
+            chat: {
+                streaming: false,
+                outputFormat: 'markdown',
+            },
+        })
+            .mockReturnValueOnce({
+            chat: {
+                streaming: true,
+            },
+        });
+        const config = loadConfig();
+        expect(config.chat?.streaming).toBe(true);
+        expect(config.chat?.outputFormat).toBe('markdown');
+    });
+    it('environment variables override all configs', () => {
+        mockFs.existsSync.mockReturnValue(false);
+        process.env.ARK_CHAT_STREAMING = '1';
+        process.env.ARK_CHAT_OUTPUT_FORMAT = 'MARKDOWN';
+        const config = loadConfig();
+        expect(config.chat?.streaming).toBe(true);
+        expect(config.chat?.outputFormat).toBe('markdown');
+    });
+    it('throws error for invalid YAML', () => {
+        const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
+        mockFs.existsSync.mockImplementation((path) => path === userConfigPath);
+        mockFs.readFileSync.mockReturnValue('invalid yaml');
+        mockYaml.parse.mockImplementation(() => {
+            throw new Error('YAML parse error');
+        });
+        expect(() => loadConfig()).toThrow(`Invalid YAML in ${userConfigPath}: YAML parse error`);
+    });
+    it('handles non-Error exceptions', () => {
+        const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
+        mockFs.existsSync.mockImplementation((path) => path === userConfigPath);
+        mockFs.readFileSync.mockReturnValue('invalid yaml');
+        mockYaml.parse.mockImplementation(() => {
+            throw 'string error';
+        });
+        expect(() => loadConfig()).toThrow(`Invalid YAML in ${userConfigPath}: Unknown error`);
+    });
+    it('getConfigPaths returns correct paths', () => {
+        const paths = getConfigPaths();
+        expect(paths.user).toBe(path.join(os.homedir(), '.arkrc.yaml'));
+        expect(paths.project).toBe(path.join(process.cwd(), '.arkrc.yaml'));
+    });
+    it('formatConfig uses yaml.stringify', () => {
+        const config = { chat: { streaming: true, outputFormat: 'text' } };
+        mockYaml.stringify.mockReturnValue('formatted');
+        const result = formatConfig(config);
+        expect(mockYaml.stringify).toHaveBeenCalledWith(config);
+        expect(result).toBe('formatted');
+    });
+});

package/dist/lib/consts.d.ts

@@ -7,4 +7,3 @@ export declare const DEFAULT_ARK_DASHBOARD_URL = "http://localhost:3000";
 export declare const DEFAULT_ARK_A2A_URL = "http://localhost:8080";
 export declare const DEFAULT_ARK_MEMORY_URL = "http://localhost:8081";
 export declare const DEFAULT_ARK_OTEL_URL = "http://localhost:4318";
-export declare const ARK_REPO_ERROR_MESSAGE = "Error: This command must be run inside the ARK repository.";

package/dist/lib/consts.js

@@ -11,5 +11,3 @@ export const DEFAULT_ARK_DASHBOARD_URL = 'http://localhost:3000';
 export const DEFAULT_ARK_A2A_URL = 'http://localhost:8080';
 export const DEFAULT_ARK_MEMORY_URL = 'http://localhost:8081';
 export const DEFAULT_ARK_OTEL_URL = 'http://localhost:4318';
-// Error message for different ARK repo
-export const ARK_REPO_ERROR_MESSAGE = 'Error: This command must be run inside the ARK repository.';

package/dist/lib/consts.spec.d.ts

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

package/dist/lib/consts.spec.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from '@jest/globals';
+import { DEFAULT_ADDRESS_ARK_API, DEFAULT_TIMEOUT_MS, DEFAULT_CONNECTION_TEST_TIMEOUT_MS, CONFIG_DIR_NAME, CONFIG_FILE_NAME, DEFAULT_ARK_DASHBOARD_URL, DEFAULT_ARK_A2A_URL, DEFAULT_ARK_MEMORY_URL, DEFAULT_ARK_OTEL_URL, } from './consts.js';
+describe('Constants', () => {
+    it('defines correct default values', () => {
+        expect(DEFAULT_ADDRESS_ARK_API).toBe('http://localhost:8000');
+        expect(DEFAULT_TIMEOUT_MS).toBe(30000);
+        expect(DEFAULT_CONNECTION_TEST_TIMEOUT_MS).toBe(5000);
+        expect(CONFIG_DIR_NAME).toBe('ark');
+        expect(CONFIG_FILE_NAME).toBe('ark-cli.json');
+        expect(DEFAULT_ARK_DASHBOARD_URL).toBe('http://localhost:3000');
+        expect(DEFAULT_ARK_A2A_URL).toBe('http://localhost:8080');
+        expect(DEFAULT_ARK_MEMORY_URL).toBe('http://localhost:8081');
+        expect(DEFAULT_ARK_OTEL_URL).toBe('http://localhost:4318');
+    });
+});

package/dist/lib/errors.js

@@ -162,9 +162,9 @@ export class InputValidator {
         if (!kebabRegex.test(trimmed)) {
             const suggestions = [];
             const normalized = trimmed
+                .replace(/([a-z])([A-Z])/g, '$1-$2') // Handle camelCase first
                 .toLowerCase()
                 .replace(/[\s_]+/g, '-')
-                .replace(/([a-z])([A-Z])/g, '$1-$2')
                 .replace(/-{2,}/g, '-') // Replace 2+ consecutive hyphens with single hyphen (ReDoS-safe)
                 .replace(/^-/, '') // Remove single leading hyphen (ReDoS-safe)
                 .replace(/-$/, ''); // Remove single trailing hyphen (ReDoS-safe)

package/dist/lib/errors.spec.d.ts

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

package/dist/lib/errors.spec.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { ErrorCode, ArkError, ValidationError, TemplateError, ProjectStructureError, ErrorHandler, InputValidator, } from './errors.js';
+jest.mock('fs');
+describe('Error Classes', () => {
+    describe('ArkError', () => {
+        it('creates error with default code', () => {
+            const error = new ArkError('test message');
+            expect(error.message).toBe('test message');
+            expect(error.code).toBe(ErrorCode.UNKNOWN_ERROR);
+            expect(error.name).toBe('ArkError');
+            expect(error.details).toBeUndefined();
+            expect(error.suggestions).toBeUndefined();
+        });
+        it('creates error with all properties', () => {
+            const error = new ArkError('test error', ErrorCode.INVALID_INPUT, { field: 'name' }, ['Check the input', 'Try again']);
+            expect(error.message).toBe('test error');
+            expect(error.code).toBe(ErrorCode.INVALID_INPUT);
+            expect(error.details).toEqual({ field: 'name' });
+            expect(error.suggestions).toEqual(['Check the input', 'Try again']);
+        });
+    });
+    describe('ValidationError', () => {
+        it('creates validation error without field', () => {
+            const error = new ValidationError('validation failed');
+            expect(error.message).toBe('validation failed');
+            expect(error.code).toBe(ErrorCode.VALIDATION_ERROR);
+            expect(error.name).toBe('ValidationError');
+            expect(error.details).toBeUndefined();
+        });
+        it('creates validation error with field and suggestions', () => {
+            const error = new ValidationError('invalid email', 'email', [
+                'Use valid format',
+            ]);
+            expect(error.message).toBe('invalid email');
+            expect(error.code).toBe(ErrorCode.VALIDATION_ERROR);
+            expect(error.details).toEqual({ field: 'email' });
+            expect(error.suggestions).toEqual(['Use valid format']);
+        });
+    });
+    describe('TemplateError', () => {
+        it('creates template error', () => {
+            const error = new TemplateError('template failed', 'template.yaml');
+            expect(error.message).toBe('template failed');
+            expect(error.code).toBe(ErrorCode.TEMPLATE_ERROR);
+            expect(error.name).toBe('TemplateError');
+            expect(error.details).toEqual({ templatePath: 'template.yaml' });
+        });
+    });
+    describe('ProjectStructureError', () => {
+        it('creates project structure error with defaults', () => {
+            const error = new ProjectStructureError('project invalid');
+            expect(error.message).toBe('project invalid');
+            expect(error.code).toBe(ErrorCode.PROJECT_STRUCTURE_INVALID);
+            expect(error.name).toBe('ProjectStructureError');
+            expect(error.suggestions).toEqual([
+                'Ensure you are in a valid ARK project directory',
+                'Run "ark generate project" to create a new project',
+                'Check that Chart.yaml and agents/ directory exist',
+            ]);
+        });
+        it('creates project structure error with path', () => {
+            const error = new ProjectStructureError('project invalid', '/path/to/project');
+            expect(error.message).toBe('project invalid');
+            expect(error.code).toBe(ErrorCode.PROJECT_STRUCTURE_INVALID);
+            expect(error.details).toEqual({ projectPath: '/path/to/project' });
+        });
+    });
+    describe('ErrorHandler', () => {
+        it('formats basic error', () => {
+            const error = new Error('simple error');
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('❌ simple error');
+        });
+        it('formats ArkError with details and suggestions', () => {
+            const error = new ArkError('test error', ErrorCode.INVALID_INPUT, { field: 'name', value: 'test' }, ['Fix the input', 'Try again']);
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('❌ test error');
+            expect(formatted).toContain('Details:');
+            expect(formatted).toContain('field: name');
+            expect(formatted).toContain('value: test');
+            expect(formatted).toContain('💡 Suggestions:');
+            expect(formatted).toContain('• Fix the input');
+            expect(formatted).toContain('• Try again');
+        });
+        it('includes stack trace in debug mode', () => {
+            process.env.DEBUG = 'true';
+            const error = new Error('debug error');
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('Stack trace:');
+            delete process.env.DEBUG;
+        });
+        it('handles missing stack trace', () => {
+            process.env.NODE_ENV = 'development';
+            const error = new Error('no stack');
+            error.stack = undefined;
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('No stack trace available');
+            delete process.env.NODE_ENV;
+        });
+        describe('handleAndExit', () => {
+            let mockExit;
+            let mockConsoleError;
+            beforeEach(() => {
+                mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+                    throw new Error('process.exit');
+                });
+                mockConsoleError = jest
+                    .spyOn(console, 'error')
+                    .mockImplementation(() => { });
+            });
+            afterEach(() => {
+                mockExit.mockRestore();
+                mockConsoleError.mockRestore();
+            });
+            it('exits with code 22 for validation errors', () => {
+                const error = new ValidationError('invalid');
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(22);
+            });
+            it('exits with code 2 for file not found', () => {
+                const error = new ArkError('not found', ErrorCode.FILE_NOT_FOUND);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(2);
+            });
+            it('exits with code 13 for permission denied', () => {
+                const error = new ArkError('denied', ErrorCode.PERMISSION_DENIED);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(13);
+            });
+            it('exits with code 127 for missing dependency', () => {
+                const error = new ArkError('missing', ErrorCode.DEPENDENCY_MISSING);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(127);
+            });
+            it('exits with code 1 for unknown errors', () => {
+                const error = new Error('unknown');
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(1);
+            });
+            it('exits with code 1 for default ArkError', () => {
+                const error = new ArkError('general', ErrorCode.UNKNOWN_ERROR);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(1);
+            });
+        });
+        describe('catchAndHandle', () => {
+            it('returns successful promise result', async () => {
+                const result = await ErrorHandler.catchAndHandle(async () => 'success');
+                expect(result).toBe('success');
+            });
+            it('rethrows ArkError unchanged', async () => {
+                const arkError = new ValidationError('test');
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw arkError;
+                })).rejects.toThrow(arkError);
+            });
+            it('wraps generic errors with context', async () => {
+                const error = new Error('generic');
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw error;
+                }, 'context')).rejects.toThrow('context: generic');
+            });
+            it('wraps non-Error objects', async () => {
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw 'string error';
+                })).rejects.toThrow('string error');
+            });
+        });
+    });
+    describe('InputValidator', () => {
+        describe('validateName', () => {
+            it('accepts valid names', () => {
+                expect(() => InputValidator.validateName('valid-name')).not.toThrow();
+                expect(() => InputValidator.validateName('test123')).not.toThrow();
+                expect(() => InputValidator.validateName('a-b-c-123')).not.toThrow();
+            });
+            it('rejects empty names', () => {
+                expect(() => InputValidator.validateName('')).toThrow('name cannot be empty');
+                expect(() => InputValidator.validateName('   ')).toThrow('name cannot be empty');
+            });
+            it('rejects names over 63 characters', () => {
+                const longName = 'a'.repeat(64);
+                expect(() => InputValidator.validateName(longName)).toThrow('must be 63 characters or less');
+            });
+            it('rejects invalid characters', () => {
+                expect(() => InputValidator.validateName('Invalid Name')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('test_name')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('-start')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('end-')).toThrow('Invalid name');
+            });
+            it('suggests normalized names', () => {
+                try {
+                    InputValidator.validateName('TestName');
+                }
+                catch (e) {
+                    expect(e.suggestions).toContain('Try: "test-name"');
+                }
+            });
+        });
+        describe('validatePath', () => {
+            it('accepts valid paths', () => {
+                expect(() => InputValidator.validatePath('/valid/path')).not.toThrow();
+                expect(() => InputValidator.validatePath('./relative')).not.toThrow();
+                expect(() => InputValidator.validatePath('simple')).not.toThrow();
+            });
+            it('rejects empty paths', () => {
+                expect(() => InputValidator.validatePath('')).toThrow('path cannot be empty');
+            });
+            it('rejects dangerous paths', () => {
+                expect(() => InputValidator.validatePath('../parent')).toThrow('unsafe characters');
+                expect(() => InputValidator.validatePath('~/home')).toThrow('unsafe characters');
+                expect(() => InputValidator.validatePath('$HOME/test')).toThrow('unsafe characters');
+            });
+        });
+        describe('validateDirectory', () => {
+            it('validates path first', () => {
+                expect(() => InputValidator.validateDirectory('')).toThrow('directory cannot be empty');
+            });
+        });
+    });
+});

package/dist/lib/exec.d.ts

@@ -1,5 +1 @@
-export declare function executeCommand(command: string, args?: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
 export declare function fileExists(path: string): boolean;

package/dist/lib/exec.js

@@ -1,15 +1,4 @@
 import fs from 'fs';
-import { execa } from 'execa';
-export async function executeCommand(command, args = []) {
-    try {
-        const result = await execa(command, args);
-        return { stdout: result.stdout, stderr: result.stderr };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${errorMessage}`);
-    }
-}
 export function fileExists(path) {
     try {
         return fs.existsSync(path);

package/dist/lib/output.spec.d.ts

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