@agents-at-scale/ark 0.1.52 → 0.1.55

package/dist/lib/marketplaceFetcher.spec.js

@@ -1,225 +0,0 @@
-import { jest } from '@jest/globals';
-const mockAxiosGet = jest.fn();
-jest.unstable_mockModule('axios', () => ({
-    default: {
-        get: mockAxiosGet,
-        isAxiosError: (error) => {
-            return (typeof error === 'object' &&
-                error !== null &&
-                'isAxiosError' in error &&
-                error.isAxiosError === true);
-        },
-    },
-}));
-const mockGetMarketplaceRepoUrl = jest.fn();
-const mockGetMarketplaceRegistry = jest.fn();
-jest.unstable_mockModule('./config.js', () => ({
-    getMarketplaceRepoUrl: mockGetMarketplaceRepoUrl,
-    getMarketplaceRegistry: mockGetMarketplaceRegistry,
-}));
-const { fetchMarketplaceManifest, mapMarketplaceItemToArkService, getMarketplaceServicesFromManifest, } = await import('./marketplaceFetcher.js');
-describe('marketplaceFetcher', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockAxiosGet.mockClear();
-        mockGetMarketplaceRepoUrl.mockReturnValue('https://test-repo.example.com/marketplace');
-        mockGetMarketplaceRegistry.mockReturnValue('oci://test-registry.example.com/charts');
-    });
-    describe('fetchMarketplaceManifest', () => {
-        it('fetches and returns manifest successfully', async () => {
-            const mockManifest = {
-                version: '1.0.0',
-                marketplace: 'ARK Marketplace',
-                items: [
-                    {
-                        name: 'test-service',
-                        description: 'Test service',
-                        ark: {
-                            chartPath: 'oci://registry/test-service',
-                            namespace: 'test',
-                        },
-                    },
-                ],
-            };
-            mockAxiosGet.mockResolvedValue({
-                data: mockManifest,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {},
-            });
-            const result = await fetchMarketplaceManifest();
-            expect(result).toEqual(mockManifest);
-            expect(mockAxiosGet).toHaveBeenCalledWith(expect.stringContaining('marketplace.json'), expect.objectContaining({
-                timeout: 10000,
-                headers: { Accept: 'application/json' },
-            }));
-        });
-        it('returns null on network error', async () => {
-            const networkError = new Error('Network error');
-            networkError.code = 'ENOTFOUND';
-            networkError.isAxiosError = true;
-            mockAxiosGet.mockRejectedValue(networkError);
-            const result = await fetchMarketplaceManifest();
-            expect(result).toBeNull();
-        });
-        it('returns null on connection refused', async () => {
-            const connectionError = Object.assign(new Error('Connection refused'), {
-                code: 'ECONNREFUSED',
-                isAxiosError: true,
-            });
-            mockAxiosGet.mockRejectedValue(connectionError);
-            const result = await fetchMarketplaceManifest();
-            expect(result).toBeNull();
-        });
-    });
-    describe('mapMarketplaceItemToArkService', () => {
-        it('maps marketplace item to ARK service correctly', () => {
-            const item = {
-                name: 'test-service',
-                description: 'Test description',
-                ark: {
-                    chartPath: 'oci://registry/test',
-                    namespace: 'test-ns',
-                    helmReleaseName: 'test-release',
-                    installArgs: ['--create-namespace'],
-                    k8sServiceName: 'test-svc',
-                    k8sServicePort: 8080,
-                    k8sDeploymentName: 'test-deploy',
-                },
-            };
-            const result = mapMarketplaceItemToArkService(item);
-            expect(result).toEqual({
-                name: 'test-service',
-                helmReleaseName: 'test-release',
-                description: 'Test description',
-                enabled: true,
-                category: 'marketplace',
-                namespace: 'test-ns',
-                chartPath: 'oci://registry/test',
-                installArgs: ['--create-namespace'],
-                k8sServiceName: 'test-svc',
-                k8sServicePort: 8080,
-                k8sDeploymentName: 'test-deploy',
-            });
-        });
-        it('uses defaults when ark fields are missing', () => {
-            const item = {
-                name: 'simple-service',
-                description: 'Simple service',
-                ark: {},
-            };
-            const result = mapMarketplaceItemToArkService(item);
-            expect(result.name).toBe('simple-service');
-            expect(result.helmReleaseName).toBe('simple-service');
-            expect(result.namespace).toBe('simple-service');
-            expect(result.chartPath).toContain('simple-service');
-        });
-        it('sanitizes service name', () => {
-            const item = {
-                name: 'Test Service 123!',
-                description: 'Test',
-                ark: {},
-            };
-            const result = mapMarketplaceItemToArkService(item);
-            expect(result.name).toBe('test-service-123');
-        });
-    });
-    describe('getMarketplaceServicesFromManifest', () => {
-        it('converts manifest items to service collection', async () => {
-            const mockManifest = {
-                version: '1.0.0',
-                marketplace: 'ARK Marketplace',
-                items: [
-                    {
-                        name: 'service1',
-                        description: 'Service 1',
-                        type: 'service',
-                        ark: {
-                            chartPath: 'oci://registry/service1',
-                            namespace: 'ns1',
-                        },
-                    },
-                    {
-                        name: 'service2',
-                        description: 'Service 2',
-                        type: 'service',
-                        ark: {
-                            chartPath: 'oci://registry/service2',
-                            namespace: 'ns2',
-                        },
-                    },
-                ],
-            };
-            mockAxiosGet.mockResolvedValue({
-                data: mockManifest,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {},
-            });
-            const result = await getMarketplaceServicesFromManifest();
-            expect(result).not.toBeNull();
-            expect(result?.['service1']).toBeDefined();
-            expect(result?.['service2']).toBeDefined();
-            expect(result?.['service1']?.description).toBe('Service 1');
-            expect(result?.['service2']?.description).toBe('Service 2');
-        });
-        it('filters out items without ark field', async () => {
-            const mockManifest = {
-                version: '1.0.0',
-                marketplace: 'ARK Marketplace',
-                items: [
-                    {
-                        name: 'service1',
-                        description: 'Service 1',
-                        type: 'service',
-                        ark: {
-                            chartPath: 'oci://registry/service1',
-                        },
-                    },
-                    {
-                        name: 'service2',
-                        description: 'Service 2',
-                        type: 'service',
-                    },
-                ],
-            };
-            mockAxiosGet.mockResolvedValue({
-                data: mockManifest,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {},
-            });
-            const result = await getMarketplaceServicesFromManifest();
-            expect(result).not.toBeNull();
-            expect(result?.['service1']).toBeDefined();
-            expect(result?.['service2']).toBeUndefined();
-        });
-        it('returns null when manifest fetch fails', async () => {
-            const networkError = new Error('Network error');
-            networkError.code = 'ENOTFOUND';
-            networkError.isAxiosError = true;
-            mockAxiosGet.mockRejectedValue(networkError);
-            const result = await getMarketplaceServicesFromManifest();
-            expect(result).toBeNull();
-        });
-        it('returns null when manifest has no items', async () => {
-            const mockManifest = {
-                version: '1.0.0',
-                marketplace: 'ARK Marketplace',
-                items: [],
-            };
-            mockAxiosGet.mockResolvedValue({
-                data: mockManifest,
-                status: 200,
-                statusText: 'OK',
-                headers: {},
-                config: {},
-            });
-            const result = await getMarketplaceServicesFromManifest();
-            expect(result).toBeNull();
-        });
-    });
-});

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

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

package/dist/lib/nextSteps.spec.js

@@ -1,59 +0,0 @@
-import { jest } from '@jest/globals';
-import { printNextSteps } from './nextSteps.js';
-describe('printNextSteps', () => {
-    let consoleLogSpy;
-    let output = [];
-    beforeEach(() => {
-        output = [];
-        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation((...args) => {
-            output.push(args.join(' '));
-        });
-    });
-    afterEach(() => {
-        consoleLogSpy.mockRestore();
-    });
-    it('prints successful installation message', () => {
-        printNextSteps();
-        const fullOutput = output.join('\n');
-        expect(fullOutput).toContain('✓ Installation complete');
-    });
-    it('includes all required commands', () => {
-        printNextSteps();
-        const fullOutput = output.join('\n');
-        // Check for each command
-        expect(fullOutput).toContain('ark models create default');
-        expect(fullOutput).toContain('ark dashboard');
-        expect(fullOutput).toContain('kubectl get agents');
-        expect(fullOutput).toContain('ark query model/default "What are large language models?"');
-        expect(fullOutput).toContain('ark');
-        expect(fullOutput).toContain("# then choose 'Chat'");
-        expect(fullOutput).toContain('ark generate project my-agents');
-    });
-    it('includes all required links', () => {
-        printNextSteps();
-        const fullOutput = output.join('\n');
-        // Check for documentation links
-        expect(fullOutput).toContain('https://mckinsey.github.io/agents-at-scale-ark/');
-        expect(fullOutput).toContain('https://mckinsey.github.io/agents-at-scale-ark/developer-guide/cli-tools/');
-    });
-    it('includes all section labels', () => {
-        printNextSteps();
-        const fullOutput = output.join('\n');
-        // Check for labels
-        expect(fullOutput).toContain('Next steps:');
-        expect(fullOutput).toContain('docs:');
-        expect(fullOutput).toContain('create model:');
-        expect(fullOutput).toContain('open dashboard:');
-        expect(fullOutput).toContain('show agents:');
-        expect(fullOutput).toContain('run a query:');
-        expect(fullOutput).toContain('interactive chat:');
-        expect(fullOutput).toContain('new project:');
-        expect(fullOutput).toContain('install fark:');
-    });
-    it('has correct structure with empty lines', () => {
-        printNextSteps();
-        // Should have empty lines for formatting
-        expect(output[0]).toBe('');
-        expect(output[output.length - 1]).toBe('');
-    });
-});

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

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

package/dist/lib/startup.spec.js

@@ -1,152 +0,0 @@
-import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
-// Mock chalk to avoid ANSI codes in tests
-jest.unstable_mockModule('chalk', () => ({
-    default: {
-        red: (str) => str,
-        yellow: (str) => str,
-        gray: (str) => str,
-        blue: (str) => str,
-    },
-}));
-// Mock commands module
-jest.unstable_mockModule('./commands.js', () => ({
-    checkCommandExists: jest.fn(),
-}));
-// Mock config module
-jest.unstable_mockModule('./config.js', () => ({
-    loadConfig: jest.fn(),
-}));
-// Mock execa module
-jest.unstable_mockModule('execa', () => ({
-    execa: jest.fn(),
-}));
-// Dynamic imports after mocks
-const { checkCommandExists } = await import('./commands.js');
-const { loadConfig } = await import('./config.js');
-const { execa } = await import('execa');
-const { startup } = await import('./startup.js');
-// Type the mocks
-const mockCheckCommandExists = checkCommandExists;
-const mockLoadConfig = loadConfig;
-const mockExeca = execa;
-describe('startup', () => {
-    let mockExit;
-    let mockConsoleError;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Mock execa to reject by default (no kubectl context)
-        mockExeca.mockRejectedValue(new Error('No context'));
-        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
-            throw new Error('process.exit');
-        });
-        mockConsoleError = jest
-            .spyOn(console, 'error')
-            .mockImplementation(() => { });
-    });
-    afterEach(() => {
-        mockExit.mockRestore();
-        mockConsoleError.mockRestore();
-    });
-    it('returns config when all required commands are installed', async () => {
-        const expectedConfig = {
-            chat: {
-                streaming: true,
-                outputFormat: 'text',
-            },
-        };
-        // Mock all commands as available
-        mockCheckCommandExists.mockResolvedValue(true);
-        mockLoadConfig.mockReturnValue(expectedConfig);
-        const config = await startup();
-        expect(config).toEqual(expectedConfig);
-        expect(mockCheckCommandExists).toHaveBeenCalledWith('kubectl', [
-            'version',
-            '--client',
-        ]);
-        expect(mockCheckCommandExists).toHaveBeenCalledWith('helm', [
-            'version',
-            '--short',
-        ]);
-        expect(mockLoadConfig).toHaveBeenCalledTimes(1);
-        expect(mockExit).not.toHaveBeenCalled();
-    });
-    it('exits with error when kubectl is missing', async () => {
-        // Mock kubectl as missing, helm as available
-        mockCheckCommandExists
-            .mockResolvedValueOnce(false) // kubectl
-            .mockResolvedValueOnce(true); // helm
-        await expect(startup()).rejects.toThrow('process.exit');
-        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
-        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('exits with error when helm is missing', async () => {
-        // Mock kubectl as available, helm as missing
-        mockCheckCommandExists
-            .mockResolvedValueOnce(true) // kubectl
-            .mockResolvedValueOnce(false); // helm
-        await expect(startup()).rejects.toThrow('process.exit');
-        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
-        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('exits with error when both commands are missing', async () => {
-        // Mock both commands as missing
-        mockCheckCommandExists.mockResolvedValue(false);
-        await expect(startup()).rejects.toThrow('process.exit');
-        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
-        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
-        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
-        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
-        expect(mockExit).toHaveBeenCalledWith(1);
-    });
-    it('checks commands with correct arguments', async () => {
-        mockCheckCommandExists.mockResolvedValue(true);
-        mockLoadConfig.mockReturnValue({ chat: {} });
-        await startup();
-        expect(mockCheckCommandExists).toHaveBeenCalledTimes(2);
-        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(1, 'kubectl', [
-            'version',
-            '--client',
-        ]);
-        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(2, 'helm', [
-            'version',
-            '--short',
-        ]);
-    });
-    it('loads config after checking requirements', async () => {
-        mockCheckCommandExists.mockResolvedValue(true);
-        const expectedConfig = { chat: { streaming: false } };
-        mockLoadConfig.mockReturnValue(expectedConfig);
-        const config = await startup();
-        // Verify order - checkCommandExists should be called before loadConfig
-        const checkCallOrder = mockCheckCommandExists.mock.invocationCallOrder[0];
-        const loadCallOrder = mockLoadConfig.mock.invocationCallOrder[0];
-        expect(checkCallOrder).toBeLessThan(loadCallOrder);
-        expect(config).toEqual(expectedConfig);
-    });
-    it('includes cluster context when available', async () => {
-        mockCheckCommandExists.mockResolvedValue(true);
-        mockLoadConfig.mockReturnValue({ chat: { streaming: true } });
-        // Mock successful kubectl context check
-        mockExeca.mockResolvedValue({
-            stdout: 'minikube',
-            stderr: '',
-        });
-        const config = await startup();
-        expect(config.clusterInfo).toEqual({
-            type: 'unknown',
-            context: 'minikube',
-        });
-        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context'], { timeout: 5000 });
-    });
-    it('handles missing kubectl context gracefully', async () => {
-        mockCheckCommandExists.mockResolvedValue(true);
-        const expectedConfig = { chat: { streaming: false } };
-        mockLoadConfig.mockReturnValue(expectedConfig);
-        // mockExeca already mocked to reject in beforeEach
-        const config = await startup();
-        expect(config).toEqual(expectedConfig);
-        expect(config.clusterInfo).toBeUndefined();
-    });
-});

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

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

package/dist/lib/stdin.spec.js

@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { readStdin } from './stdin.js';
-import { Readable } from 'stream';
-describe('readStdin', () => {
-    let originalStdin;
-    let mockStdin;
-    beforeEach(() => {
-        originalStdin = process.stdin;
-        mockStdin = new Readable({
-            read() { },
-        });
-        Object.defineProperty(process, 'stdin', {
-            value: mockStdin,
-            writable: true,
-            configurable: true,
-        });
-    });
-    afterEach(() => {
-        Object.defineProperty(process, 'stdin', {
-            value: originalStdin,
-            writable: true,
-            configurable: true,
-        });
-        jest.clearAllMocks();
-    });
-    it('should return empty string when stdin is TTY', async () => {
-        mockStdin.isTTY = true;
-        const result = await readStdin();
-        expect(result).toBe('');
-    });
-    it('should read single chunk from stdin', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push('test-query');
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('test-query');
-    });
-    it('should read multiple chunks from stdin', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push('test-');
-        mockStdin.push('query-');
-        mockStdin.push('name');
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('test-query-name');
-    });
-    it('should trim whitespace from stdin input', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push('  test-query  \n');
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('test-query');
-    });
-    it('should handle empty stdin input', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('');
-    });
-    it('should handle stdin with only whitespace', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push('   \n\n  ');
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('');
-    });
-    it('should handle multiline input', async () => {
-        mockStdin.isTTY = false;
-        const promise = readStdin();
-        mockStdin.push('line1\n');
-        mockStdin.push('line2\n');
-        mockStdin.push('line3');
-        mockStdin.push(null);
-        const result = await promise;
-        expect(result).toBe('line1\nline2\nline3');
-    });
-});

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

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

package/dist/lib/timeout.spec.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { parseTimeoutToSeconds } from './timeout.js';
-describe('parseTimeoutToSeconds', () => {
-    it('should parse time units correctly', () => {
-        expect(parseTimeoutToSeconds('30s')).toBe(30);
-        expect(parseTimeoutToSeconds('2m')).toBe(120);
-        expect(parseTimeoutToSeconds('1h')).toBe(3600);
-        expect(parseTimeoutToSeconds('60')).toBe(60);
-    });
-    it('should throw error for invalid formats', () => {
-        expect(() => parseTimeoutToSeconds('abc')).toThrow('Invalid timeout format');
-        expect(() => parseTimeoutToSeconds('-5s')).toThrow('Invalid timeout format');
-    });
-});