@agents-at-scale/ark 0.1.41 → 0.1.43

package/dist/lib/kubectl.spec.js

@@ -0,0 +1,176 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const { getResource, listResources, deleteResource } = await import('./kubectl.js');
+describe('kubectl', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('getResource', () => {
+        it('should get a specific resource by name', async () => {
+            const mockResource = {
+                metadata: {
+                    name: 'test-query',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+                spec: {
+                    value: 'test',
+                },
+            };
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify(mockResource),
+            });
+            const result = await getResource('queries', 'test-query');
+            expect(result).toEqual(mockResource);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'queries', 'test-query', '-o', 'json'], { stdio: 'pipe' });
+        });
+        it('should get latest resource when name is @latest', async () => {
+            const mockResources = [
+                {
+                    metadata: {
+                        name: 'query-1',
+                        creationTimestamp: '2024-01-01T00:00:00Z',
+                    },
+                },
+                {
+                    metadata: {
+                        name: 'query-2',
+                        creationTimestamp: '2024-01-02T00:00:00Z',
+                    },
+                },
+                {
+                    metadata: {
+                        name: 'query-3',
+                        creationTimestamp: '2024-01-03T00:00:00Z',
+                    },
+                },
+            ];
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify({ items: mockResources }),
+            });
+            const result = await getResource('queries', '@latest');
+            expect(result).toEqual(mockResources[2]);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'get',
+                'queries',
+                '--sort-by=.metadata.creationTimestamp',
+                '-o',
+                'json',
+            ], { stdio: 'pipe' });
+        });
+        it('should throw error when @latest finds no resources', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify({ items: [] }),
+            });
+            await expect(getResource('queries', '@latest')).rejects.toThrow('No queries found');
+        });
+        it('should handle kubectl errors', async () => {
+            mockExeca.mockRejectedValue(new Error('kubectl error'));
+            await expect(getResource('queries', 'test-query')).rejects.toThrow('kubectl error');
+        });
+        it('should work with different resource types', async () => {
+            const mockAgent = {
+                metadata: {
+                    name: 'test-agent',
+                    creationTimestamp: '2024-01-01T00:00:00Z',
+                },
+            };
+            mockExeca.mockResolvedValue({
+                stdout: JSON.stringify(mockAgent),
+            });
+            const result = await getResource('agents', 'test-agent');
+            expect(result).toEqual(mockAgent);
+            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/lib/stdin.d.ts

@@ -0,0 +1 @@
+export declare function readStdin(): Promise<string>;

package/dist/lib/stdin.js

@@ -0,0 +1,16 @@
+export async function readStdin() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            resolve('');
+            return;
+        }
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => {
+            resolve(data.trim());
+        });
+    });
+}

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

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

package/dist/lib/stdin.spec.js

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

@@ -52,6 +52,7 @@ export interface CommandVersionConfig {
 export interface K8sMetadata {
     name: string;
     namespace?: string;
+    creationTimestamp?: string;
 }
 export interface K8sCondition {
     type: string;
@@ -119,3 +120,41 @@ export interface ClusterInfo {
     user?: string;
     namespace?: string;
 }
+export interface EvaluationManifest {
+    apiVersion: string;
+    kind: 'Evaluation';
+    metadata: {
+        name: string;
+    };
+    spec: {
+        type: 'direct' | 'query';
+        evaluator: {
+            name: string;
+        };
+        config: {
+            input?: string;
+            output?: string;
+            queryRef?: {
+                name: string;
+            };
+            responseTarget?: {
+                type: string;
+                name: string;
+            };
+        };
+        timeout?: string;
+        ttl?: string;
+    };
+}
+export interface EvaluationStatus {
+    phase?: 'pending' | 'running' | 'done' | 'error';
+    score?: string;
+    passed?: boolean;
+    message?: string;
+}
+export interface Evaluation {
+    metadata: {
+        name: string;
+    };
+    status?: EvaluationStatus;
+}

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.41",
+  "version": "0.1.43",
   "description": "Ark CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",
@@ -67,6 +67,7 @@
     "@types/debug": "^4.1.12",
     "@types/inquirer": "^9.0.7",
     "@types/jest": "^30.0.0",
+    "@types/marked-terminal": "^6.1.1",
     "@types/node": "^22.10.2",
     "@types/react": "^19.1.13",
     "@typescript-eslint/eslint-plugin": "^8.20.0",