@agents-at-scale/ark 0.1.53 → 0.1.56

package/dist/lib/chatClient.spec.js

@@ -1,108 +0,0 @@
-import { jest } from '@jest/globals';
-import { QUERY_ANNOTATIONS } from './constants.js';
-const mockCreateChatCompletion = jest.fn();
-const mockArkApiClient = {
-    createChatCompletion: mockCreateChatCompletion,
-    createChatCompletionStream: jest.fn(),
-    getQueryTargets: jest.fn(),
-};
-const { ChatClient } = await import('./chatClient.js');
-describe('ChatClient', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('sendMessage', () => {
-        it('should include sessionId directly in metadata when provided', async () => {
-            const client = new ChatClient(mockArkApiClient);
-            mockCreateChatCompletion.mockResolvedValue({
-                id: 'test-id',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'test-model',
-                choices: [
-                    {
-                        index: 0,
-                        message: { role: 'assistant', content: 'Hello' },
-                        finish_reason: 'stop',
-                    },
-                ],
-                usage: {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    total_tokens: 15,
-                },
-            });
-            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], { streamingEnabled: false, sessionId: 'test-session-123' });
-            expect(mockCreateChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
-                model: 'agent/test-agent',
-                messages: [{ role: 'user', content: 'Hello' }],
-                metadata: {
-                    sessionId: 'test-session-123',
-                },
-            }));
-        });
-        it('should include both sessionId in metadata and a2aContextId in queryAnnotations when both provided', async () => {
-            const client = new ChatClient(mockArkApiClient);
-            mockCreateChatCompletion.mockResolvedValue({
-                id: 'test-id',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'test-model',
-                choices: [
-                    {
-                        index: 0,
-                        message: { role: 'assistant', content: 'Hello' },
-                        finish_reason: 'stop',
-                    },
-                ],
-                usage: {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    total_tokens: 15,
-                },
-            });
-            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], {
-                streamingEnabled: false,
-                sessionId: 'test-session-123',
-                a2aContextId: 'a2a-context-456',
-            });
-            expect(mockCreateChatCompletion).toHaveBeenCalled();
-            const callArgs = mockCreateChatCompletion.mock.calls[0][0];
-            expect(callArgs.model).toBe('agent/test-agent');
-            expect(callArgs.messages).toEqual([{ role: 'user', content: 'Hello' }]);
-            expect(callArgs.metadata).toBeDefined();
-            expect(callArgs.metadata.sessionId).toBe('test-session-123');
-            expect(callArgs.metadata.queryAnnotations).toBeDefined();
-            const queryAnnotations = JSON.parse(callArgs.metadata.queryAnnotations);
-            expect(queryAnnotations[QUERY_ANNOTATIONS.A2A_CONTEXT_ID]).toBe('a2a-context-456');
-        });
-        it('should not include metadata when neither sessionId nor a2aContextId is provided', async () => {
-            const client = new ChatClient(mockArkApiClient);
-            mockCreateChatCompletion.mockResolvedValue({
-                id: 'test-id',
-                object: 'chat.completion',
-                created: 1234567890,
-                model: 'test-model',
-                choices: [
-                    {
-                        index: 0,
-                        message: { role: 'assistant', content: 'Hello' },
-                        finish_reason: 'stop',
-                    },
-                ],
-                usage: {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    total_tokens: 15,
-                },
-            });
-            await client.sendMessage('agent/test-agent', [{ role: 'user', content: 'Hello' }], { streamingEnabled: false });
-            expect(mockCreateChatCompletion).toHaveBeenCalledWith(expect.objectContaining({
-                model: 'agent/test-agent',
-                messages: [{ role: 'user', content: 'Hello' }],
-            }));
-            const callArgs = mockCreateChatCompletion.mock.calls[0];
-            expect(callArgs[0].metadata).toBeUndefined();
-        });
-    });
-});

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

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

package/dist/lib/cluster.spec.js

@@ -1,338 +0,0 @@
-import { jest } from '@jest/globals';
-const mockExeca = jest.fn();
-jest.unstable_mockModule('execa', () => ({
-    execa: mockExeca,
-}));
-const { getClusterInfo, detectClusterType } = await import('./cluster.js');
-describe('cluster', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('detectClusterType', () => {
-        it('detects minikube cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'minikube' });
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'minikube', context: 'minikube' });
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'config',
-                'current-context',
-            ]);
-        });
-        it('detects kind cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'kind-kind' });
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'kind', context: 'kind-kind' });
-        });
-        it('detects k3s cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'k3s-default' });
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'k3s', context: 'k3s-default' });
-        });
-        it('detects docker-desktop cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'docker-desktop' });
-            const result = await detectClusterType();
-            expect(result).toEqual({
-                type: 'docker-desktop',
-                context: 'docker-desktop',
-            });
-        });
-        it('detects gke cloud cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'gke_project_zone_cluster' });
-            const result = await detectClusterType();
-            expect(result).toEqual({
-                type: 'cloud',
-                context: 'gke_project_zone_cluster',
-            });
-        });
-        it('detects eks cloud cluster', async () => {
-            mockExeca.mockResolvedValue({
-                stdout: 'arn:aws:eks:region:account:cluster/name',
-            });
-            const result = await detectClusterType();
-            expect(result).toEqual({
-                type: 'cloud',
-                context: 'arn:aws:eks:region:account:cluster/name',
-            });
-        });
-        it('detects aks cloud cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'aks-cluster-name' });
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'cloud', context: 'aks-cluster-name' });
-        });
-        it('returns unknown for unrecognized cluster', async () => {
-            mockExeca.mockResolvedValue({ stdout: 'some-other-cluster' });
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'unknown', context: 'some-other-cluster' });
-        });
-        it('handles kubectl error', async () => {
-            mockExeca.mockRejectedValue(new Error('kubectl not found'));
-            const result = await detectClusterType();
-            expect(result).toEqual({ type: 'unknown', error: 'kubectl not found' });
-        });
-    });
-    describe('getClusterInfo', () => {
-        const mockConfig = {
-            'current-context': 'minikube',
-            contexts: [
-                {
-                    name: 'minikube',
-                    context: {
-                        namespace: 'default',
-                    },
-                },
-            ],
-        };
-        it('gets minikube cluster info with IP', async () => {
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
-                .mockResolvedValueOnce({ stdout: 'minikube' })
-                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'minikube',
-                context: 'minikube',
-                namespace: 'default',
-                ip: '192.168.49.2',
-            });
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'config',
-                'view',
-                '--minify',
-                '-o',
-                'json',
-            ]);
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'config',
-                'current-context',
-            ]);
-            expect(mockExeca).toHaveBeenCalledWith('minikube', ['ip']);
-        });
-        it('falls back to kubectl for minikube IP if minikube command fails', async () => {
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(mockConfig) })
-                .mockResolvedValueOnce({ stdout: 'minikube' })
-                .mockRejectedValueOnce(new Error('minikube not found'))
-                .mockResolvedValueOnce({ stdout: '192.168.49.2' });
-            const result = await getClusterInfo();
-            expect(result.ip).toBe('192.168.49.2');
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'get',
-                'nodes',
-                '-o',
-                'jsonpath={.items[0].status.addresses[?(@.type=="InternalIP")].address}',
-            ]);
-        });
-        it('gets kind cluster info with IP', async () => {
-            const kindConfig = {
-                'current-context': 'kind-kind',
-                contexts: [
-                    {
-                        name: 'kind-kind',
-                        context: {
-                            namespace: 'kube-system',
-                        },
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(kindConfig) })
-                .mockResolvedValueOnce({ stdout: 'kind-kind' })
-                .mockResolvedValueOnce({ stdout: '172.18.0.2' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'kind',
-                context: 'kind-kind',
-                namespace: 'kube-system',
-                ip: '172.18.0.2',
-            });
-        });
-        it('gets docker-desktop cluster info', async () => {
-            const dockerConfig = {
-                'current-context': 'docker-desktop',
-                contexts: [
-                    {
-                        name: 'docker-desktop',
-                        context: {},
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(dockerConfig) })
-                .mockResolvedValueOnce({ stdout: 'docker-desktop' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'docker-desktop',
-                context: 'docker-desktop',
-                namespace: 'default',
-                ip: 'localhost',
-            });
-        });
-        it('gets cloud cluster info with load balancer IP', async () => {
-            const cloudConfig = {
-                'current-context': 'gke_project_zone_cluster',
-                contexts: [
-                    {
-                        name: 'gke_project_zone_cluster',
-                        context: {
-                            namespace: 'production',
-                        },
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
-                .mockResolvedValueOnce({ stdout: 'gke_project_zone_cluster' })
-                .mockResolvedValueOnce({ stdout: '35.201.125.17' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'cloud',
-                context: 'gke_project_zone_cluster',
-                namespace: 'production',
-                ip: '35.201.125.17',
-            });
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'get',
-                'svc',
-                '-n',
-                'istio-system',
-                'istio-ingressgateway',
-                '-o',
-                'jsonpath={.status.loadBalancer.ingress[0].ip}',
-            ]);
-        });
-        it('falls back to hostname for cloud cluster if no IP', async () => {
-            const cloudConfig = {
-                'current-context': 'eks-cluster',
-                contexts: [
-                    {
-                        name: 'eks-cluster',
-                        context: {},
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
-                .mockResolvedValueOnce({ stdout: 'eks-cluster' })
-                .mockResolvedValueOnce({ stdout: '' })
-                .mockResolvedValueOnce({ stdout: 'a1234.elb.amazonaws.com' });
-            const result = await getClusterInfo();
-            expect(result.ip).toBe('a1234.elb.amazonaws.com');
-        });
-        it('falls back to external node IP for cloud cluster', async () => {
-            const cloudConfig = {
-                'current-context': 'gke-cluster',
-                contexts: [
-                    {
-                        name: 'gke-cluster',
-                        context: {},
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(cloudConfig) })
-                .mockResolvedValueOnce({ stdout: 'gke-cluster' })
-                .mockRejectedValueOnce(new Error('service not found'))
-                .mockResolvedValueOnce({ stdout: '35.201.125.18' });
-            const result = await getClusterInfo();
-            expect(result.ip).toBe('35.201.125.18');
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'get',
-                'nodes',
-                '-o',
-                'jsonpath={.items[0].status.addresses[?(@.type=="ExternalIP")].address}',
-            ]);
-        });
-        it('gets k3s cluster info', async () => {
-            const k3sConfig = {
-                'current-context': 'k3s-default',
-                contexts: [
-                    {
-                        name: 'k3s-default',
-                        context: {},
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(k3sConfig) })
-                .mockResolvedValueOnce({ stdout: 'k3s-default' })
-                .mockResolvedValueOnce({ stdout: '10.0.0.5' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'k3s',
-                context: 'k3s-default',
-                namespace: 'default',
-                ip: '10.0.0.5',
-            });
-        });
-        it('uses provided context parameter', async () => {
-            const multiConfig = {
-                'current-context': 'kind-staging',
-                contexts: [
-                    {
-                        name: 'kind-staging',
-                        context: {
-                            namespace: 'staging-ns',
-                        },
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(multiConfig) })
-                .mockResolvedValueOnce({ stdout: 'kind-staging' })
-                .mockResolvedValueOnce({ stdout: '172.18.0.3' });
-            const result = await getClusterInfo('kind-staging');
-            expect(result.context).toBe('kind-staging');
-            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
-                'config',
-                'view',
-                '--minify',
-                '-o',
-                'json',
-                '--context',
-                'kind-staging',
-            ]);
-        });
-        it('handles unknown cluster type', async () => {
-            const unknownConfig = {
-                'current-context': 'custom-cluster',
-                contexts: [
-                    {
-                        name: 'custom-cluster',
-                        context: {},
-                    },
-                ],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(unknownConfig) })
-                .mockResolvedValueOnce({ stdout: 'custom-cluster' })
-                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'unknown',
-                context: 'custom-cluster',
-                namespace: 'default',
-                ip: '10.0.0.1',
-            });
-        });
-        it('handles kubectl config error', async () => {
-            mockExeca.mockRejectedValue(new Error('kubectl not configured'));
-            const result = await getClusterInfo();
-            expect(result).toEqual({
-                type: 'unknown',
-                error: 'kubectl not configured',
-            });
-        });
-        it('handles missing context in config', async () => {
-            const emptyConfig = {
-                contexts: [],
-            };
-            mockExeca
-                .mockResolvedValueOnce({ stdout: JSON.stringify(emptyConfig) })
-                .mockResolvedValueOnce({ stdout: '' })
-                .mockResolvedValueOnce({ stdout: '10.0.0.1' });
-            const result = await getClusterInfo();
-            expect(result.context).toBe('');
-            expect(result.namespace).toBe('default');
-        });
-    });
-});

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

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

package/dist/lib/commands.spec.js

@@ -1,146 +0,0 @@
-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.spec.d.ts

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