@agents-at-scale/ark 0.1.42 → 0.1.43

package/dist/lib/executeQuery.spec.js

@@ -10,17 +10,26 @@ const mockSpinner = {
     warn: jest.fn(),
     stop: jest.fn(),
     text: '',
+    isSpinning: false,
 };
 const mockOra = jest.fn(() => mockSpinner);
 jest.unstable_mockModule('ora', () => ({
     default: mockOra,
 }));
-const mockOutput = {
-    warning: jest.fn(),
-    error: jest.fn(),
+let mockSendMessage = jest.fn();
+const mockChatClient = jest.fn(() => ({
+    sendMessage: mockSendMessage,
+}));
+let mockArkApiProxyInstance = {
+    start: jest.fn(),
+    stop: jest.fn(),
 };
-jest.unstable_mockModule('./output.js', () => ({
-    default: mockOutput,
+const mockArkApiProxy = jest.fn(() => mockArkApiProxyInstance);
+jest.unstable_mockModule('./arkApiProxy.js', () => ({
+    ArkApiProxy: mockArkApiProxy,
+}));
+jest.unstable_mockModule('./chatClient.js', () => ({
+    ChatClient: mockChatClient,
 }));
 const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
     throw new Error('process.exit called');
@@ -29,12 +38,25 @@ const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
 const mockConsoleError = jest
     .spyOn(console, 'error')
     .mockImplementation(() => { });
+const mockStdoutWrite = jest
+    .spyOn(process.stdout, 'write')
+    .mockImplementation(() => true);
 const { executeQuery, parseTarget } = await import('./executeQuery.js');
 const { ExitCodes } = await import('./errors.js');
 describe('executeQuery', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         mockSpinner.start.mockReturnValue(mockSpinner);
+        mockSpinner.isSpinning = false;
+        mockSendMessage = jest.fn();
+        mockChatClient.mockReturnValue({ sendMessage: mockSendMessage });
+        const startMock = jest.fn();
+        startMock.mockResolvedValue({});
+        mockArkApiProxyInstance = {
+            start: startMock,
+            stop: jest.fn(),
+        };
+        mockArkApiProxy.mockReturnValue(mockArkApiProxyInstance);
     });
     describe('parseTarget', () => {
         it('should parse valid target strings', () => {
@@ -57,24 +79,107 @@ describe('executeQuery', () => {
             expect(parseTarget('model/default/extra')).toBeNull();
         });
     });
-    describe('executeQuery', () => {
-        it('should create and apply a query manifest', async () => {
-            const mockQueryResponse = {
-                status: {
-                    phase: 'done',
-                    responses: [{ content: 'Test response' }],
-                },
-            };
+    describe('executeQuery with streaming', () => {
+        it('should execute query with streaming and display chunks', async () => {
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('Hello', undefined, { agent: 'test-agent' });
+                callback(' world', undefined, { agent: 'test-agent' });
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            });
+            expect(mockArkApiProxy).toHaveBeenCalled();
+            expect(mockArkApiProxyInstance.start).toHaveBeenCalled();
+            expect(mockChatClient).toHaveBeenCalled();
+            expect(mockSendMessage).toHaveBeenCalledWith('model/default', [{ role: 'user', content: 'Hello' }], { streamingEnabled: true }, expect.any(Function));
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockArkApiProxyInstance.stop).toHaveBeenCalled();
+            expect(mockStdoutWrite).toHaveBeenCalled();
+        });
+        it('should display agent names with correct formatting', async () => {
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('Response 1', undefined, { agent: 'agent-1' });
+                callback('Response 2', undefined, { agent: 'agent-2' });
+            });
+            await executeQuery({
+                targetType: 'agent',
+                targetName: 'test-agent',
+                message: 'Hello',
+            });
+            expect(mockStdoutWrite).toHaveBeenCalled();
+            const calls = mockStdoutWrite.mock.calls.map((call) => String(call[0]));
+            expect(calls.some((call) => call.includes('agent-1'))).toBe(true);
+            expect(calls.some((call) => call.includes('agent-2'))).toBe(true);
+        });
+        it('should display team names with diamond prefix', async () => {
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('Team response', undefined, { team: 'my-team' });
+            });
+            await executeQuery({
+                targetType: 'team',
+                targetName: 'my-team',
+                message: 'Hello',
+            });
+            const calls = mockStdoutWrite.mock.calls.map((call) => String(call[0]));
+            expect(calls.some((call) => call.includes('◆'))).toBe(true);
+            expect(calls.some((call) => call.includes('my-team'))).toBe(true);
+        });
+        it('should display tool calls', async () => {
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('', [{ id: 1, function: { name: 'get_weather' } }], {
+                    agent: 'weather-agent',
+                });
+                callback('The weather is sunny', undefined, {
+                    agent: 'weather-agent',
+                });
+            });
+            await executeQuery({
+                targetType: 'agent',
+                targetName: 'weather-agent',
+                message: 'What is the weather?',
+            });
+            const calls = mockStdoutWrite.mock.calls.map((call) => String(call[0]));
+            expect(calls.some((call) => call.includes('get_weather'))).toBe(true);
+            expect(calls.some((call) => call.includes('The weather is sunny'))).toBe(true);
+        });
+        it('should handle errors and exit with CliError', async () => {
+            mockSpinner.isSpinning = true;
+            const startMock = jest.fn();
+            startMock.mockRejectedValue(new Error('Connection failed'));
+            mockArkApiProxyInstance.start = startMock;
+            await expect(executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            })).rejects.toThrow('process.exit called');
+            expect(mockSpinner.stop).toHaveBeenCalled();
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Connection failed'));
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.CliError);
+            expect(mockArkApiProxyInstance.stop).toHaveBeenCalled();
+        });
+        it('should stop spinner when first output arrives', async () => {
+            mockSpinner.isSpinning = true;
+            mockSendMessage.mockImplementation(async (targetId, messages, options, callback) => {
+                callback('First chunk', undefined, { agent: 'test-agent' });
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            });
+            expect(mockSpinner.stop).toHaveBeenCalled();
+        });
+    });
+    describe('executeQuery with output format', () => {
+        it('should create query and output name format', async () => {
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('queries')) {
-                    return {
-                        stdout: JSON.stringify(mockQueryResponse),
-                        stderr: '',
-                        exitCode: 0,
-                    };
+                if (args.includes('wait')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
                 }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
@@ -82,83 +187,67 @@ describe('executeQuery', () => {
                 targetType: 'model',
                 targetName: 'default',
                 message: 'Hello',
+                outputFormat: 'name',
             });
-            expect(mockSpinner.start).toHaveBeenCalled();
-            expect(mockSpinner.stop).toHaveBeenCalled();
-            expect(mockConsoleLog).toHaveBeenCalledWith('Test response');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['apply', '-f', '-']), expect.any(Object));
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', expect.arrayContaining(['wait', '--for=condition=Completed']), expect.any(Object));
+            expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringMatching(/cli-query-\d+/));
         });
-        it('should handle query error phase and exit with code 2', async () => {
-            const mockQueryResponse = {
-                status: {
-                    phase: 'error',
-                    responses: [{ content: 'Query failed with test error' }],
-                },
+        it('should output json format', async () => {
+            const mockQuery = {
+                apiVersion: 'ark.mckinsey.com/v1alpha1',
+                kind: 'Query',
+                metadata: { name: 'test-query' },
             };
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('queries')) {
-                    return {
-                        stdout: JSON.stringify(mockQueryResponse),
-                        stderr: '',
-                        exitCode: 0,
-                    };
+                if (args.includes('wait')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('get') && args.includes('-o')) {
+                    return { stdout: JSON.stringify(mockQuery), stderr: '', exitCode: 0 };
                 }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
-            try {
-                await executeQuery({
-                    targetType: 'model',
-                    targetName: 'default',
-                    message: 'Hello',
-                });
-            }
-            catch (error) {
-                expect(error.message).toBe('process.exit called');
-            }
-            expect(mockSpinner.stop).toHaveBeenCalled();
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Query failed with test error'));
-            expect(mockExit).toHaveBeenCalledWith(ExitCodes.OperationError);
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+                outputFormat: 'json',
+            });
+            expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockQuery));
         });
-        it('should handle query canceled phase and exit with code 2', async () => {
-            const mockQueryResponse = {
-                status: {
-                    phase: 'canceled',
-                    message: 'Query was canceled',
-                },
-            };
+        it('should output yaml format', async () => {
+            const mockYaml = 'apiVersion: ark.mckinsey.com/v1alpha1\nkind: Query';
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
                     return { stdout: '', stderr: '', exitCode: 0 };
                 }
-                if (args.includes('get') && args.includes('queries')) {
-                    return {
-                        stdout: JSON.stringify(mockQueryResponse),
-                        stderr: '',
-                        exitCode: 0,
-                    };
+                if (args.includes('wait')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('get') && args.includes('yaml')) {
+                    return { stdout: mockYaml, stderr: '', exitCode: 0 };
                 }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
-            try {
-                await executeQuery({
-                    targetType: 'agent',
-                    targetName: 'test-agent',
-                    message: 'Hello',
-                });
-            }
-            catch (error) {
-                expect(error.message).toBe('process.exit called');
-            }
-            expect(mockSpinner.warn).toHaveBeenCalledWith('Query canceled');
-            expect(mockOutput.warning).toHaveBeenCalledWith('Query was canceled');
-            expect(mockExit).toHaveBeenCalledWith(ExitCodes.OperationError);
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+                outputFormat: 'yaml',
+            });
+            expect(mockConsoleLog).toHaveBeenCalledWith(mockYaml);
         });
-        it('should handle kubectl apply failures with exit code 1', async () => {
+        it('should reject invalid output format', async () => {
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
-                    throw new Error('Failed to apply');
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('wait')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
                 }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
@@ -166,38 +255,26 @@ describe('executeQuery', () => {
                 targetType: 'model',
                 targetName: 'default',
                 message: 'Hello',
+                outputFormat: 'invalid',
             })).rejects.toThrow('process.exit called');
-            expect(mockSpinner.stop).toHaveBeenCalled();
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Failed to apply'));
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Invalid output format'));
             expect(mockExit).toHaveBeenCalledWith(ExitCodes.CliError);
         });
-        it('should handle query timeout and exit with code 3', async () => {
+        it('should handle kubectl errors', async () => {
             mockExeca.mockImplementation(async (command, args) => {
                 if (args.includes('apply')) {
-                    return { stdout: '', stderr: '', exitCode: 0 };
-                }
-                if (args.includes('wait')) {
-                    // Simulate kubectl wait timeout
-                    const error = new Error('timed out waiting for the condition');
-                    throw error;
+                    throw new Error('kubectl apply failed');
                 }
                 return { stdout: '', stderr: '', exitCode: 0 };
             });
-            try {
-                await executeQuery({
-                    targetType: 'model',
-                    targetName: 'default',
-                    message: 'Hello',
-                    timeout: '100ms',
-                    watchTimeout: '200ms',
-                });
-            }
-            catch (error) {
-                expect(error.message).toBe('process.exit called');
-            }
-            expect(mockSpinner.stop).toHaveBeenCalled();
-            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('Query did not complete within 200ms'));
-            expect(mockExit).toHaveBeenCalledWith(ExitCodes.Timeout);
+            await expect(executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+                outputFormat: 'name',
+            })).rejects.toThrow('process.exit called');
+            expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('kubectl apply failed'));
+            expect(mockExit).toHaveBeenCalledWith(ExitCodes.CliError);
         });
     });
 });

package/dist/lib/kubectl.d.ts

@@ -5,4 +5,11 @@ interface K8sResource {
     };
 }
 export declare function getResource<T extends K8sResource>(resourceType: string, name: string): Promise<T>;
+export declare function listResources<T extends K8sResource>(resourceType: string, options?: {
+    sortBy?: string;
+}): Promise<T[]>;
+export declare function deleteResource(resourceType: string, name?: string, options?: {
+    all?: boolean;
+}): Promise<void>;
+export declare function replaceResource<T extends K8sResource>(resource: T): Promise<T>;
 export {};

package/dist/lib/kubectl.js

@@ -18,3 +18,30 @@ export async function getResource(resourceType, name) {
     const result = await execa('kubectl', ['get', resourceType, name, '-o', 'json'], { stdio: 'pipe' });
     return JSON.parse(result.stdout);
 }
+export async function listResources(resourceType, options) {
+    const args = ['get', resourceType];
+    if (options?.sortBy) {
+        args.push(`--sort-by=${options.sortBy}`);
+    }
+    args.push('-o', 'json');
+    const result = await execa('kubectl', args, { stdio: 'pipe' });
+    const data = JSON.parse(result.stdout);
+    return data.items || [];
+}
+export async function deleteResource(resourceType, name, options) {
+    const args = ['delete', resourceType];
+    if (options?.all) {
+        args.push('--all');
+    }
+    else if (name) {
+        args.push(name);
+    }
+    await execa('kubectl', args, { stdio: 'pipe' });
+}
+export async function replaceResource(resource) {
+    const result = await execa('kubectl', ['replace', '-f', '-', '-o', 'json'], {
+        input: JSON.stringify(resource),
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return JSON.parse(result.stdout);
+}

package/dist/lib/kubectl.spec.js

@@ -3,7 +3,7 @@ const mockExeca = jest.fn();
 jest.unstable_mockModule('execa', () => ({
     execa: mockExeca,
 }));
-const { getResource } = await import('./kubectl.js');
+const { getResource, listResources, deleteResource } = await import('./kubectl.js');
 describe('kubectl', () => {
     beforeEach(() => {
         jest.clearAllMocks();
@@ -85,4 +85,92 @@ describe('kubectl', () => {
             expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'agents', 'test-agent', '-o', 'json'], { stdio: 'pipe' });
         });
     });
+    describe('listResources', () => {
+        it('should list all resources of a given type', async () => {
+            const mockResources = [
+                {
+                    metadata: {
+                        name: 'query-1',
+                        creationTimestamp: '2024-01-01T00:00:00Z',
+                    },
+                    spec: {
+                        value: 'test1',
+                    },
+                },
+                {
+                    metadata: {
+                        name: 'query-2',
+                        creationTimestamp: '2024-01-02T00:00:00Z',
+                    },
+                    spec: {
+                        value: 'test2',
+                    },
+                },
+            ];
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify({ items: mockResources }),
+            });
+            const result = await listResources('queries');
+            expect(result).toEqual(mockResources);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
+        });
+        it('should return an empty array when no resources exist', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify({ items: [] }),
+            });
+            const result = await listResources('queries');
+            expect(result).toEqual([]);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', '-o', 'json'], { stdio: 'pipe' });
+        });
+        it('should list resources with custom sort option', async () => {
+            const mockResources = [
+                {
+                    metadata: {
+                        name: 'query-1',
+                        creationTimestamp: '2024-01-01T00:00:00Z',
+                    },
+                },
+                {
+                    metadata: {
+                        name: 'query-2',
+                        creationTimestamp: '2024-01-02T00:00:00Z',
+                    },
+                },
+            ];
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify({ items: mockResources }),
+            });
+            const result = await listResources('queries', {
+                sortBy: '.metadata.creationTimestamp',
+            });
+            expect(result).toEqual(mockResources);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'queries',
+                '--sort-by=.metadata.creationTimestamp',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
+        it('should handle kubectl errors when listing resources', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl connection error'));
+            await expect(listResources('queries')).rejects.toThrow('kubectl connection error');
+        });
+    });
+    describe('deleteResource', () => {
+        it('should delete a resource by name', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+            });
+            await deleteResource('queries', 'test-query');
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', 'test-query'], { stdio: 'pipe' });
+        });
+        it('should delete all resources of a type when all option is true', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+            });
+            await deleteResource('queries', undefined, { all: true });
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'queries', '--all'], { stdio: 'pipe' });
+        });
+    });
 });

package/dist/marketplaceServices.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Marketplace service definitions for external ARK marketplace resources
+ * Repository: https://github.com/mckinsey/agents-at-scale-marketplace
+ * Charts are installed from the public OCI registry
+ */
+import type { ArkService, ServiceCollection } from './types/arkService.js';
+/**
+ * Available marketplace services
+ * Charts are published to: oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts
+ */
+export declare const marketplaceServices: ServiceCollection;
+export declare function getMarketplaceService(name: string): ArkService | undefined;
+export declare function getAllMarketplaceServices(): ServiceCollection;
+export declare function isMarketplaceService(name: string): boolean;
+export declare function extractMarketplaceServiceName(path: string): string;

package/dist/marketplaceServices.js

@@ -0,0 +1,51 @@
+/**
+ * Marketplace service definitions for external ARK marketplace resources
+ * Repository: https://github.com/mckinsey/agents-at-scale-marketplace
+ * Charts are installed from the public OCI registry
+ */
+const MARKETPLACE_REGISTRY = 'oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts';
+/**
+ * Available marketplace services
+ * Charts are published to: oci://ghcr.io/mckinsey/agents-at-scale-marketplace/charts
+ */
+export const marketplaceServices = {
+    phoenix: {
+        name: 'phoenix',
+        helmReleaseName: 'phoenix',
+        description: 'AI/ML observability and evaluation platform with OpenTelemetry integration',
+        enabled: true,
+        category: 'marketplace',
+        namespace: 'phoenix',
+        chartPath: `${MARKETPLACE_REGISTRY}/phoenix`,
+        installArgs: ['--create-namespace'],
+        k8sServiceName: 'phoenix',
+        k8sServicePort: 6006,
+        k8sDeploymentName: 'phoenix',
+    },
+    langfuse: {
+        name: 'langfuse',
+        helmReleaseName: 'langfuse',
+        description: 'Open-source LLM observability and analytics platform with session tracking',
+        enabled: true,
+        category: 'marketplace',
+        namespace: 'telemetry',
+        chartPath: `${MARKETPLACE_REGISTRY}/langfuse`,
+        installArgs: ['--create-namespace'],
+        k8sServiceName: 'langfuse',
+        k8sServicePort: 3000,
+        k8sDeploymentName: 'langfuse-web',
+    },
+};
+export function getMarketplaceService(name) {
+    return marketplaceServices[name];
+}
+export function getAllMarketplaceServices() {
+    return marketplaceServices;
+}
+export function isMarketplaceService(name) {
+    return name.startsWith('marketplace/services/');
+}
+export function extractMarketplaceServiceName(path) {
+    // Extract service name from marketplace/services/phoenix
+    return path.replace(/^marketplace\/services\//, '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",