@agents-at-scale/ark 0.1.53 → 0.1.56

package/dist/lib/config.spec.js

@@ -1,202 +0,0 @@
-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',
-            },
-            marketplace: {
-                repoUrl: 'https://github.com/mckinsey/agents-at-scale-marketplace',
-                registry: 'oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts',
-            },
-            services: {
-                reusePortForwards: false,
-            },
-        });
-    });
-    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('loads queryTimeout from config file', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({ queryTimeout: '30m' });
-        const config = loadConfig();
-        expect(config.queryTimeout).toBe('30m');
-    });
-    it('loads defaultExportTypes from config file', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({ defaultExportTypes: ['agents', 'teams'] });
-        const config = loadConfig();
-        expect(config.defaultExportTypes).toEqual(['agents', 'teams']);
-    });
-    it('ARK_QUERY_TIMEOUT environment variable overrides config', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({ queryTimeout: '5m' });
-        process.env.ARK_QUERY_TIMEOUT = '1h';
-        const config = loadConfig();
-        expect(config.queryTimeout).toBe('1h');
-    });
-    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');
-    });
-    it('loads marketplace config from config file', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({
-            marketplace: {
-                repoUrl: 'https://example.com/my-marketplace',
-                registry: 'oci://example.com/charts',
-            },
-        });
-        const config = loadConfig();
-        expect(config.marketplace?.repoUrl).toBe('https://example.com/my-marketplace');
-        expect(config.marketplace?.registry).toBe('oci://example.com/charts');
-    });
-    it('marketplace environment variables override config', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({
-            marketplace: {
-                repoUrl: 'https://example.com/my-marketplace',
-                registry: 'oci://example.com/charts',
-            },
-        });
-        process.env.ARK_MARKETPLACE_REPO_URL = 'https://custom.com/marketplace';
-        process.env.ARK_MARKETPLACE_REGISTRY = 'oci://custom.com/charts';
-        const config = loadConfig();
-        expect(config.marketplace?.repoUrl).toBe('https://custom.com/marketplace');
-        expect(config.marketplace?.registry).toBe('oci://custom.com/charts');
-    });
-});
-describe('marketplace helpers', () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        process.env = { ...originalEnv };
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it('getMarketplaceRepoUrl returns custom config value', async () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({
-            marketplace: {
-                repoUrl: 'https://custom-repo.com/marketplace',
-            },
-        });
-        jest.resetModules();
-        const { getMarketplaceRepoUrl } = await import('./config.js');
-        expect(getMarketplaceRepoUrl()).toBe('https://custom-repo.com/marketplace');
-    });
-    it('getMarketplaceRepoUrl returns default value', async () => {
-        mockFs.existsSync.mockReturnValue(false);
-        jest.resetModules();
-        const { getMarketplaceRepoUrl } = await import('./config.js');
-        expect(getMarketplaceRepoUrl()).toBe('https://github.com/mckinsey/agents-at-scale-marketplace');
-    });
-    it('getMarketplaceRegistry returns custom config value', async () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync.mockReturnValue('yaml');
-        mockYaml.parse.mockReturnValue({
-            marketplace: {
-                registry: 'oci://custom-registry.com/charts',
-            },
-        });
-        jest.resetModules();
-        const { getMarketplaceRegistry } = await import('./config.js');
-        expect(getMarketplaceRegistry()).toBe('oci://custom-registry.com/charts');
-    });
-    it('getMarketplaceRegistry returns default value', async () => {
-        mockFs.existsSync.mockReturnValue(false);
-        jest.resetModules();
-        const { getMarketplaceRegistry } = await import('./config.js');
-        expect(getMarketplaceRegistry()).toBe('oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts');
-    });
-});

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

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

package/dist/lib/duration.spec.js

@@ -1,13 +0,0 @@
-import { parseDuration } from './duration.js';
-describe('parseDuration', () => {
-    it('should parse durations correctly', () => {
-        expect(parseDuration('100ms')).toBe(100);
-        expect(parseDuration('30s')).toBe(30000);
-        expect(parseDuration('5m')).toBe(300000);
-        expect(parseDuration('1h')).toBe(3600000);
-    });
-    it('should throw on invalid format', () => {
-        expect(() => parseDuration('invalid')).toThrow('Invalid duration format');
-        expect(() => parseDuration('10')).toThrow('Invalid duration format');
-    });
-});

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

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

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/executeEvaluation.d.ts

@@ -1,16 +0,0 @@
-export interface DirectEvaluationOptions {
-    evaluatorName: string;
-    input: string;
-    output: string;
-    timeout?: string;
-    watchTimeout?: string;
-}
-export interface QueryEvaluationOptions {
-    evaluatorName: string;
-    queryName: string;
-    responseTarget?: string;
-    timeout?: string;
-    watchTimeout?: string;
-}
-export declare function executeDirectEvaluation(options: DirectEvaluationOptions): Promise<void>;
-export declare function executeQueryEvaluation(options: QueryEvaluationOptions): Promise<void>;

package/dist/lib/executeEvaluation.js

@@ -1,155 +0,0 @@
-import { execa } from 'execa';
-import ora from 'ora';
-import chalk from 'chalk';
-import output from './output.js';
-import { ExitCodes } from './errors.js';
-import { parseDuration } from './duration.js';
-async function waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay) {
-    const spinner = ora('Waiting for evaluation completion...').start();
-    try {
-        await execa('kubectl', [
-            'wait',
-            '--for=condition=Completed',
-            `evaluation/${evaluationName}`,
-            `--timeout=${Math.floor(watchTimeoutMs / 1000)}s`,
-        ], { timeout: watchTimeoutMs });
-    }
-    catch (error) {
-        spinner.stop();
-        if (error instanceof Error && error.message.includes('timed out waiting')) {
-            console.error(chalk.red(`Evaluation did not complete within ${watchTimeoutDisplay}`));
-            process.exit(ExitCodes.Timeout);
-        }
-        throw error;
-    }
-    spinner.stop();
-    const { stdout } = await execa('kubectl', ['get', 'evaluation', evaluationName, '-o', 'json'], { stdio: 'pipe' });
-    const evaluation = JSON.parse(stdout);
-    const status = evaluation.status;
-    if (status?.phase === 'done') {
-        console.log(chalk.green('\nEvaluation completed successfully:'));
-        if (status.score !== undefined) {
-            console.log(`Score: ${status.score}`);
-        }
-        if (status.passed !== undefined) {
-            console.log(`Result: ${status.passed ? chalk.green('PASSED') : chalk.red('FAILED')}`);
-        }
-        if (status.message) {
-            console.log(`Message: ${status.message}`);
-        }
-    }
-    else if (status?.phase === 'error') {
-        console.error(chalk.red(status.message || 'Evaluation failed with unknown error'));
-        process.exit(ExitCodes.OperationError);
-    }
-    else {
-        output.warning(`Unexpected evaluation phase: ${status?.phase}`);
-    }
-}
-export async function executeDirectEvaluation(options) {
-    const spinner = ora('Creating evaluation...').start();
-    const queryTimeoutMs = options.timeout
-        ? parseDuration(options.timeout)
-        : parseDuration('5m');
-    const watchTimeoutMs = options.watchTimeout
-        ? parseDuration(options.watchTimeout)
-        : queryTimeoutMs + 60000;
-    const timestamp = Date.now();
-    const evaluationName = `cli-eval-${timestamp}`;
-    const evaluationManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Evaluation',
-        metadata: {
-            name: evaluationName,
-        },
-        spec: {
-            type: 'direct',
-            evaluator: {
-                name: options.evaluatorName,
-            },
-            config: {
-                input: options.input,
-                output: options.output,
-            },
-            ...(options.timeout && { timeout: options.timeout }),
-            ttl: '1h',
-        },
-    };
-    try {
-        spinner.text = 'Submitting evaluation...';
-        await execa('kubectl', ['apply', '-f', '-'], {
-            input: JSON.stringify(evaluationManifest),
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        spinner.stop();
-        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
-        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
-    }
-    catch (error) {
-        spinner.stop();
-        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
-        process.exit(ExitCodes.CliError);
-    }
-}
-export async function executeQueryEvaluation(options) {
-    const spinner = ora('Creating evaluation...').start();
-    const queryTimeoutMs = options.timeout
-        ? parseDuration(options.timeout)
-        : parseDuration('5m');
-    const watchTimeoutMs = options.watchTimeout
-        ? parseDuration(options.watchTimeout)
-        : queryTimeoutMs + 60000;
-    const timestamp = Date.now();
-    const evaluationName = `cli-eval-${timestamp}`;
-    let responseTarget;
-    if (options.responseTarget) {
-        const parts = options.responseTarget.split(':');
-        if (parts.length === 2) {
-            responseTarget = {
-                type: parts[0],
-                name: parts[1],
-            };
-        }
-        else {
-            spinner.stop();
-            console.error(chalk.red('Invalid response-target format. Use: type:name (e.g., agent:my-agent)'));
-            process.exit(ExitCodes.CliError);
-        }
-    }
-    const evaluationManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Evaluation',
-        metadata: {
-            name: evaluationName,
-        },
-        spec: {
-            type: 'query',
-            evaluator: {
-                name: options.evaluatorName,
-            },
-            config: {
-                queryRef: {
-                    name: options.queryName,
-                },
-                ...(responseTarget && { responseTarget }),
-            },
-            ...(options.timeout && { timeout: options.timeout }),
-            ttl: '1h',
-        },
-    };
-    try {
-        spinner.text = 'Submitting evaluation...';
-        await execa('kubectl', ['apply', '-f', '-'], {
-            input: JSON.stringify(evaluationManifest),
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        spinner.stop();
-        const watchTimeoutDisplay = options.watchTimeout ?? `${Math.floor(watchTimeoutMs / 1000)}s`;
-        await waitForEvaluationAndDisplayResults(evaluationName, watchTimeoutMs, watchTimeoutDisplay);
-    }
-    catch (error) {
-        spinner.stop();
-        console.error(chalk.red(error instanceof Error ? error.message : 'Unknown error'));
-        process.exit(ExitCodes.CliError);
-    }
-}

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

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