@agents-at-scale/ark 0.1.35-rc1 → 0.1.35

package/dist/lib/errors.spec.js

@@ -1,221 +0,0 @@
-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/output.d.ts

@@ -1,36 +0,0 @@
-export type StatusType = 'success' | 'warning' | 'info' | 'error';
-declare const output: {
-    /**
-     * Display a status message with flexible formatting
-     */
-    statusMessage(type: StatusType, title: string, message?: string, ...args: unknown[]): void;
-    /**
-     * Display an error message with consistent formatting
-     */
-    error(message: string, ...args: unknown[]): void;
-    /**
-     * Display a success message with consistent formatting
-     */
-    success(message: string, ...args: unknown[]): void;
-    /**
-     * Display an info message (indented gray text)
-     */
-    info(message: string, ...args: unknown[]): void;
-    /**
-     * Display a warning message with consistent formatting
-     */
-    warning(message: string, ...args: unknown[]): void;
-    /**
-     * Display a status check item (like ark status format)
-     * @param status - 'found', 'missing', 'warning', 'error'
-     * @param label - The label to show (e.g., 'platform')
-     * @param value - The value in bright white (e.g., 'python3')
-     * @param details - Optional grey details
-     */
-    statusCheck(status: "found" | "missing" | "warning" | "error", label: string, value?: string, details?: string): void;
-    /**
-     * Display a section header (like 'ark services:')
-     */
-    section(title: string): void;
-};
-export default output;

package/dist/lib/output.js

@@ -1,89 +0,0 @@
-import chalk from 'chalk';
-const output = {
-    /**
-     * Display a status message with flexible formatting
-     */
-    statusMessage(type, title, message, ...args) {
-        const icons = {
-            success: chalk.green('✓'),
-            warning: chalk.yellow.bold('!'),
-            info: chalk.blue('ℹ'),
-            error: chalk.red('✗'),
-        };
-        const colors = {
-            success: chalk.green,
-            warning: chalk.yellow,
-            info: chalk.blue,
-            error: chalk.red,
-        };
-        const icon = icons[type];
-        const color = colors[type];
-        const logFn = type === 'error' ? console.error : console.log;
-        if (message) {
-            logFn(icon, color(`${title}:`), message, ...args);
-        }
-        else {
-            logFn(icon, title, ...args);
-        }
-    },
-    /**
-     * Display an error message with consistent formatting
-     */
-    error(message, ...args) {
-        this.statusMessage('error', 'error', message, ...args);
-    },
-    /**
-     * Display a success message with consistent formatting
-     */
-    success(message, ...args) {
-        this.statusMessage('success', message, undefined, ...args);
-    },
-    /**
-     * Display an info message (indented gray text)
-     */
-    info(message, ...args) {
-        console.log(chalk.gray(message), ...args);
-    },
-    /**
-     * Display a warning message with consistent formatting
-     */
-    warning(message, ...args) {
-        this.statusMessage('warning', 'warning', message, ...args);
-    },
-    /**
-     * Display a status check item (like ark status format)
-     * @param status - 'found', 'missing', 'warning', 'error'
-     * @param label - The label to show (e.g., 'platform')
-     * @param value - The value in bright white (e.g., 'python3')
-     * @param details - Optional grey details
-     */
-    statusCheck(status, label, value, details) {
-        const icons = {
-            found: chalk.green('✓'),
-            missing: chalk.yellow('?'),
-            warning: chalk.yellow('!'),
-            error: chalk.red('✗'),
-        };
-        const statusText = {
-            found: chalk.green(label),
-            missing: chalk.yellow(label),
-            warning: chalk.yellow(label),
-            error: chalk.red(label),
-        };
-        let output = `  ${icons[status]} ${statusText[status]}`;
-        if (value) {
-            output += ` ${chalk.bold.white(value)}`;
-        }
-        if (details) {
-            output += chalk.gray(` ${details}`);
-        }
-        console.log(output);
-    },
-    /**
-     * Display a section header (like 'ark services:')
-     */
-    section(title) {
-        console.log(chalk.cyan.bold(`${title}:`));
-    },
-};
-export default output;

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

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

package/dist/lib/output.spec.js

@@ -1,123 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import chalk from 'chalk';
-import output from './output.js';
-describe('output', () => {
-    let consoleErrorSpy;
-    let consoleLogSpy;
-    beforeEach(() => {
-        consoleErrorSpy = jest
-            .spyOn(console, 'error')
-            .mockImplementation(() => undefined);
-        consoleLogSpy = jest
-            .spyOn(console, 'log')
-            .mockImplementation(() => undefined);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('error', () => {
-        it('should output error message with red cross and prefix', () => {
-            output.error('Something went wrong');
-            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('error:'), 'Something went wrong');
-        });
-        it('should handle additional arguments', () => {
-            const error = new Error('Test error');
-            output.error('Failed to connect', error, 123);
-            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('error:'), 'Failed to connect', error, 123);
-        });
-    });
-    describe('success', () => {
-        it('should output success message with green checkmark', () => {
-            output.success('Operation completed');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Operation completed');
-        });
-        it('should handle additional arguments', () => {
-            output.success('Deployed', 'v1.0.0', { status: 'ok' });
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Deployed', 'v1.0.0', { status: 'ok' });
-        });
-    });
-    describe('info', () => {
-        it('should output info message in gray', () => {
-            output.info('Processing request...');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.gray('Processing request...'));
-        });
-        it('should handle additional arguments', () => {
-            output.info('Status:', 'running', 42);
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.gray('Status:'), 'running', 42);
-        });
-    });
-    describe('warning', () => {
-        it('should output warning message with yellow exclamation and prefix', () => {
-            output.warning('Resource limit approaching');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('warning:'), 'Resource limit approaching');
-        });
-        it('should handle additional arguments', () => {
-            const details = { cpu: '85%', memory: '92%' };
-            output.warning('High resource usage', details);
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('warning:'), 'High resource usage', details);
-        });
-    });
-    describe('statusCheck', () => {
-        it('should display found status with value and details', () => {
-            output.statusCheck('found', 'platform', 'python3', 'v3.10');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('platform')} ${chalk.bold.white('python3')}${chalk.gray(' v3.10')}`);
-        });
-        it('should display found status with value only', () => {
-            output.statusCheck('found', 'fastmcp', 'v0.1.0');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('fastmcp')} ${chalk.bold.white('v0.1.0')}`);
-        });
-        it('should display found status with label only', () => {
-            output.statusCheck('found', '3 tools');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('3 tools')}`);
-        });
-        it('should display missing status with details', () => {
-            output.statusCheck('missing', 'fastmcp', undefined, 'not in dependencies');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.yellow('?')} ${chalk.yellow('fastmcp')}${chalk.gray(' not in dependencies')}`);
-        });
-        it('should display warning status', () => {
-            output.statusCheck('warning', 'version', '0.0.1', 'pre-release');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.yellow('!')} ${chalk.yellow('version')} ${chalk.bold.white('0.0.1')}${chalk.gray(' pre-release')}`);
-        });
-        it('should display error status', () => {
-            output.statusCheck('error', 'tools', undefined, 'discovery failed');
-            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.red('✗')} ${chalk.red('tools')}${chalk.gray(' discovery failed')}`);
-        });
-    });
-    describe('section', () => {
-        it('should display section header with colon', () => {
-            output.section('dev-tests');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.cyan.bold('dev-tests:'));
-        });
-        it('should display section header with custom text', () => {
-            output.section('ark services');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.cyan.bold('ark services:'));
-        });
-    });
-    describe('statusMessage', () => {
-        it('should output success status with title and message', () => {
-            output.statusMessage('success', 'fastmcp', 'installed (v0.1.0)');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), chalk.green('fastmcp:'), 'installed (v0.1.0)');
-        });
-        it('should output warning status with title and message', () => {
-            output.statusMessage('warning', 'virtual environment', 'not found');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('virtual environment:'), 'not found');
-        });
-        it('should output error status with title and message', () => {
-            output.statusMessage('error', 'fastmcp', 'not found in dependencies');
-            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('fastmcp:'), 'not found in dependencies');
-        });
-        it('should output info status with title and message', () => {
-            output.statusMessage('info', 'platform', 'python3');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.blue('ℹ'), chalk.blue('platform:'), 'python3');
-        });
-        it('should handle title-only messages', () => {
-            output.statusMessage('success', 'Operation completed');
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Operation completed');
-        });
-        it('should handle additional arguments', () => {
-            const extra = { version: '1.0' };
-            output.statusMessage('info', 'status', 'running', extra, 42);
-            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.blue('ℹ'), chalk.blue('status:'), 'running', extra, 42);
-        });
-    });
-});

package/dist/lib/portUtils.d.ts

@@ -1,8 +0,0 @@
-/**
- * Check if a port is available
- */
-export declare function isPortAvailable(port: number): Promise<boolean>;
-/**
- * Find an available port, starting from the preferred port
- */
-export declare function findAvailablePort(preferredPort: number, maxAttempts?: number): Promise<number>;

package/dist/lib/portUtils.js

@@ -1,39 +0,0 @@
-import net from 'net';
-/**
- * Check if a port is available
- */
-export async function isPortAvailable(port) {
-    return new Promise((resolve) => {
-        const server = net.createServer();
-        server.once('error', (err) => {
-            if (err.code === 'EADDRINUSE') {
-                resolve(false);
-            }
-            else {
-                resolve(false);
-            }
-        });
-        server.once('listening', () => {
-            server.close();
-            resolve(true);
-        });
-        server.listen(port, '127.0.0.1');
-    });
-}
-/**
- * Find an available port, starting from the preferred port
- */
-export async function findAvailablePort(preferredPort, maxAttempts = 10) {
-    // First try the preferred port
-    if (await isPortAvailable(preferredPort)) {
-        return preferredPort;
-    }
-    // Try random ports
-    for (let i = 0; i < maxAttempts; i++) {
-        const randomPort = Math.floor(Math.random() * (65535 - 1024) + 1024);
-        if (await isPortAvailable(randomPort)) {
-            return randomPort;
-        }
-    }
-    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
-}

package/dist/lib/startup.d.ts

@@ -1,5 +0,0 @@
-import type { ArkConfig } from './config.js';
-/**
- * Initialize the CLI by checking requirements and loading config
- */
-export declare function startup(): Promise<ArkConfig>;

package/dist/lib/startup.js

@@ -1,73 +0,0 @@
-import chalk from 'chalk';
-import { checkCommandExists } from './commands.js';
-import { loadConfig } from './config.js';
-import { getArkVersion } from './arkStatus.js';
-const REQUIRED_COMMANDS = [
-    {
-        name: 'kubectl',
-        command: 'kubectl',
-        args: ['version', '--client'],
-        installUrl: 'https://kubernetes.io/docs/tasks/tools/',
-    },
-    {
-        name: 'helm',
-        command: 'helm',
-        args: ['version', '--short'],
-        installUrl: 'https://helm.sh/docs/intro/install/',
-    },
-];
-async function checkRequirements() {
-    const missing = [];
-    for (const cmd of REQUIRED_COMMANDS) {
-        const exists = await checkCommandExists(cmd.command, cmd.args);
-        if (!exists) {
-            missing.push(cmd);
-        }
-    }
-    if (missing.length > 0) {
-        for (const cmd of missing) {
-            console.error(chalk.red('error:') + ` ${cmd.name} is required`);
-            console.error('  ' + chalk.blue(cmd.installUrl));
-        }
-        process.exit(1);
-    }
-}
-/**
- * Fetch version information (non-blocking)
- */
-async function fetchVersionInfo(config) {
-    // Fetch latest version from GitHub
-    try {
-        const response = await fetch('https://api.github.com/repos/mckinsey/agents-at-scale-ark/releases/latest');
-        if (response.ok) {
-            const data = (await response.json());
-            // Remove 'v' prefix if present for consistent comparison
-            config.latestVersion = data.tag_name.replace(/^v/, '');
-        }
-    }
-    catch {
-        // Silently fail - latestVersion will remain undefined
-    }
-    // Fetch current installed version (already without 'v' from helm)
-    try {
-        const currentVersion = await getArkVersion();
-        if (currentVersion) {
-            config.currentVersion = currentVersion;
-        }
-    }
-    catch {
-        // Silently fail - currentVersion will remain undefined
-    }
-}
-/**
- * Initialize the CLI by checking requirements and loading config
- */
-export async function startup() {
-    // Check required commands
-    await checkRequirements();
-    // Load config
-    const config = loadConfig();
-    // Fetch version info synchronously so it's available immediately
-    await fetchVersionInfo(config);
-    return config;
-}

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

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