@agents-at-scale/ark 0.1.41 → 0.1.43

package/dist/commands/memory/index.spec.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, jest, beforeEach, afterEach, beforeAll, } from '@jest/globals';
+// ESM-safe mocking: declare variables to hold dynamically imported modules
+let createMemoryCommand;
+let deleteSession;
+let deleteQuery;
+let deleteAll;
+let ArkApiProxy;
+let output;
+// Mock dependencies
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: {
+        info: jest.fn(),
+        success: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+// Mock ArkApiProxy with a simpler approach
+jest.unstable_mockModule('../../lib/arkApiProxy.js', () => ({
+    __esModule: true,
+    ArkApiProxy: jest.fn().mockImplementation(() => ({
+        start: jest.fn(),
+        stop: jest.fn(),
+    })),
+}));
+beforeAll(async () => {
+    // After mocks are registered, dynamically import modules
+    ({ ArkApiProxy } = await import('../../lib/arkApiProxy.js'));
+    ({ default: output } = await import('../../lib/output.js'));
+    ({ createMemoryCommand, deleteSession, deleteQuery, deleteAll } = await import('./index.js'));
+});
+describe('Memory Command', () => {
+    let mockConfig;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockConfig = {};
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('Command Structure', () => {
+        it('should create memory command with correct structure', () => {
+            const command = createMemoryCommand(mockConfig);
+            expect(command.name()).toBe('memory');
+            expect(command.alias()).toBe('mem');
+            expect(command.description()).toBe('Manage memory sessions and queries');
+        });
+        it('should have list subcommand', () => {
+            const command = createMemoryCommand(mockConfig);
+            const subcommands = command.commands.map((cmd) => cmd.name());
+            expect(subcommands).toContain('list');
+        });
+        it('should have delete subcommand with nested commands and flags', () => {
+            const command = createMemoryCommand(mockConfig);
+            const deleteCommand = command.commands.find((cmd) => cmd.name() === 'delete');
+            expect(deleteCommand).toBeDefined();
+            expect(deleteCommand?.description()).toBe('Delete memory data');
+            const deleteSubcommands = deleteCommand?.commands.map((cmd) => cmd.name()) || [];
+            expect(deleteSubcommands).toContain('session');
+            expect(deleteSubcommands).toContain('query');
+            // --all flag is supported on the delete root instead of an 'all' subcommand
+        });
+    });
+    describe('Command Creation', () => {
+        it('should create command without errors', () => {
+            expect(() => createMemoryCommand(mockConfig)).not.toThrow();
+        });
+        it('should return a command object', () => {
+            const command = createMemoryCommand(mockConfig);
+            expect(command).toBeDefined();
+            expect(typeof command.name).toBe('function');
+            expect(typeof command.description).toBe('function');
+        });
+    });
+    describe('Error Scenarios', () => {
+        let exitSpy;
+        beforeEach(async () => {
+            exitSpy = jest
+                .spyOn(process, 'exit')
+                .mockImplementation(((..._args) => undefined));
+        });
+        afterEach(() => {
+            exitSpy.mockRestore();
+        });
+        it('deleteSession handles 500 error', async () => {
+            const err = new Error('Internal Server Error');
+            const fakeClient = {
+                deleteSession: jest.fn().mockRejectedValue(err),
+            };
+            ArkApiProxy.mockImplementation(() => ({
+                start: jest.fn().mockResolvedValue(fakeClient),
+                stop: jest.fn(),
+            }));
+            await deleteSession('sess-1', { output: 'text' }).catch(() => { });
+            expect(output.error).toHaveBeenCalled();
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('deleteQuery handles network timeout', async () => {
+            const err = new Error('Network timeout');
+            const fakeClient = {
+                deleteQueryMessages: jest.fn().mockRejectedValue(err),
+            };
+            ArkApiProxy.mockImplementation(() => ({
+                start: jest.fn().mockResolvedValue(fakeClient),
+                stop: jest.fn(),
+            }));
+            await deleteQuery('sess-2', 'query-9', { output: 'text' }).catch(() => { });
+            expect(output.error).toHaveBeenCalled();
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('deleteAll handles no memory services reachable', async () => {
+            const err = new Error('No memory services reachable');
+            const fakeClient = {
+                deleteAllSessions: jest.fn().mockRejectedValue(err),
+            };
+            ArkApiProxy.mockImplementation(() => ({
+                start: jest.fn().mockResolvedValue(fakeClient),
+                stop: jest.fn(),
+            }));
+            await deleteAll({ output: 'text' }).catch(() => { });
+            expect(output.error).toHaveBeenCalled();
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+    });
+});

package/dist/commands/models/create.d.ts

@@ -1,9 +1,8 @@
-export interface CreateModelOptions {
-    type?: string;
-    model?: string;
-    baseUrl?: string;
-    apiKey?: string;
-    apiVersion?: string;
+import { BaseCollectorOptions } from './providers/index.js';
+/**
+ * Common options for model creation.
+ */
+export interface CreateModelOptions extends BaseCollectorOptions {
     yes?: boolean;
 }
 export declare function createModel(modelName?: string, options?: CreateModelOptions): Promise<boolean>;

package/dist/commands/models/create.js

@@ -1,6 +1,9 @@
 import { execa } from 'execa';
 import inquirer from 'inquirer';
 import output from '../../lib/output.js';
+import { ProviderConfigCollectorFactory, } from './providers/index.js';
+import { KubernetesSecretManager } from './kubernetes/secret-manager.js';
+import { KubernetesModelManifestBuilder } from './kubernetes/manifest-builder.js';
 export async function createModel(modelName, options = {}) {
     // Step 1: Get model name if not provided
     if (!modelName) {
@@ -56,6 +59,7 @@ export async function createModel(modelName, options = {}) {
                 choices: [
                     { name: 'Azure OpenAI', value: 'azure' },
                     { name: 'OpenAI', value: 'openai' },
+                    { name: 'AWS Bedrock', value: 'bedrock' },
                 ],
                 default: 'azure',
             },
@@ -75,133 +79,24 @@ export async function createModel(modelName, options = {}) {
         ]);
         model = answer.model;
     }
-    // Step 4: Get base URL
-    let baseUrl = options.baseUrl;
-    if (!baseUrl) {
-        const answer = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'baseUrl',
-                message: 'base URL:',
-                validate: (input) => {
-                    if (!input)
-                        return 'base URL is required';
-                    try {
-                        new URL(input);
-                        return true;
-                    }
-                    catch {
-                        return 'please enter a valid URL';
-                    }
-                },
-            },
-        ]);
-        baseUrl = answer.baseUrl;
-    }
-    // Validate and clean base URL
-    if (!baseUrl) {
-        output.error('base URL is required');
-        return false;
-    }
-    baseUrl = baseUrl.replace(/\/$/, '');
-    // Step 5: Get API version (Azure only)
-    let apiVersion = options.apiVersion || '';
-    if (modelType === 'azure' && !options.apiVersion) {
-        const answer = await inquirer.prompt([
-            {
-                type: 'input',
-                name: 'apiVersion',
-                message: 'Azure API version:',
-                default: '2024-12-01-preview',
-            },
-        ]);
-        apiVersion = answer.apiVersion;
-    }
-    // Step 6: Get API key
-    let apiKey = options.apiKey;
-    if (!apiKey) {
-        const answer = await inquirer.prompt([
-            {
-                type: 'password',
-                name: 'apiKey',
-                message: 'API key:',
-                mask: '*',
-                validate: (input) => {
-                    if (!input)
-                        return 'API key is required';
-                    return true;
-                },
-            },
-        ]);
-        apiKey = answer.apiKey;
-    }
-    // Step 6: Create the Kubernetes secret
-    const secretName = `${modelName}-model-api-key`;
+    // Step 4: Collect provider-specific configuration
+    const collector = ProviderConfigCollectorFactory.create(modelType);
+    const config = await collector.collectConfig({ ...options, model });
+    config.secretName = `${modelName}-model-secret`;
+    // Step 5: Create the Kubernetes secret
     try {
-        await execa('kubectl', [
-            'create',
-            'secret',
-            'generic',
-            secretName,
-            `--from-literal=api-key=${apiKey}`,
-        ], { stdio: 'pipe' });
-        output.success(`created secret ${secretName}`);
+        const secretManager = new KubernetesSecretManager();
+        await secretManager.createSecret(config);
     }
     catch (error) {
         output.error('failed to create secret');
         console.error(error);
         return false;
     }
-    // Step 7: Create the Model resource
+    // Step 6: Create the Model resource
     output.info(`creating model ${modelName}...`);
-    const modelManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Model',
-        metadata: {
-            name: modelName,
-        },
-        spec: {
-            type: modelType,
-            model: {
-                value: model,
-            },
-            config: {},
-        },
-    };
-    // Add provider-specific config
-    if (modelType === 'azure') {
-        modelManifest.spec.config.azure = {
-            apiKey: {
-                valueFrom: {
-                    secretKeyRef: {
-                        name: secretName,
-                        key: 'api-key',
-                    },
-                },
-            },
-            baseUrl: {
-                value: baseUrl,
-            },
-            apiVersion: {
-                value: apiVersion,
-            },
-        };
-    }
-    else {
-        modelManifest.spec.config.openai = {
-            apiKey: {
-                valueFrom: {
-                    secretKeyRef: {
-                        name: secretName,
-                        key: 'api-key',
-                    },
-                },
-            },
-            baseUrl: {
-                value: baseUrl,
-            },
-        };
-    }
+    const manifestBuilder = new KubernetesModelManifestBuilder(modelName);
+    const modelManifest = manifestBuilder.build(config);
     try {
         // Apply the model manifest using kubectl
         const manifestJson = JSON.stringify(modelManifest);

package/dist/commands/models/create.spec.js

@@ -25,6 +25,57 @@ describe('createModel', () => {
     beforeEach(() => {
         jest.clearAllMocks();
     });
+    it('creates new model for type aws bedrock', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'bedrock' }) // user selects from list
+            .mockResolvedValueOnce({ model: 'anthropic.claude-3-sonnet-20240229-v1:0' })
+            .mockResolvedValueOnce({ region: 'us-east-1' })
+            .mockResolvedValueOnce({ accessKeyId: 'AKIAIOSFODNN7EXAMPLE' })
+            .mockResolvedValueOnce({
+            secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
+        })
+            .mockResolvedValueOnce({ sessionToken: 'optional-session-token' })
+            .mockResolvedValueOnce({
+            modelArn: 'arn:aws:bedrock:us-east-1:123456789012:model/anthropic.claude-3-sonnet-20240229-v1:0',
+        });
+        mockExeca.mockResolvedValue({}); // kubectl ops succeed
+        await createModel('test-model');
+        // Verify that model type prompt was called
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                type: 'list',
+                name: 'modelType',
+                message: 'select model provider:',
+                choices: expect.arrayContaining([
+                    { name: 'Azure OpenAI', value: 'azure' },
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'AWS Bedrock', value: 'bedrock' },
+                ]),
+            }),
+        ]);
+        // Verify Bedrock-specific prompts were called
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                name: 'region',
+                message: 'AWS region:',
+            }),
+        ]);
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                name: 'accessKeyId',
+                message: 'AWS access key ID:',
+            }),
+        ]);
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                name: 'secretAccessKey',
+                message: 'AWS secret access key:',
+                type: 'password',
+            }),
+        ]);
+        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created');
+    });
     it('creates new model with provided name', async () => {
         // Model doesn't exist
         mockExeca.mockRejectedValueOnce(new Error('not found'));

package/dist/commands/models/kubernetes/manifest-builder.d.ts

@@ -0,0 +1,11 @@
+import { ProviderConfig } from '../providers/index.js';
+export interface ModelManifestBuilder {
+    build(config: ProviderConfig): Record<string, unknown>;
+}
+export declare class KubernetesModelManifestBuilder implements ModelManifestBuilder {
+    private modelName;
+    constructor(modelName: string);
+    build(config: ProviderConfig): Record<string, unknown>;
+    private buildProviderConfig;
+    private buildBedrockConfig;
+}

package/dist/commands/models/kubernetes/manifest-builder.js

@@ -0,0 +1,109 @@
+// Kubernetes model manifest builder
+export class KubernetesModelManifestBuilder {
+    constructor(modelName) {
+        this.modelName = modelName;
+    }
+    build(config) {
+        const manifest = {
+            apiVersion: 'ark.mckinsey.com/v1alpha1',
+            kind: 'Model',
+            metadata: {
+                name: this.modelName,
+            },
+            spec: {
+                type: config.type,
+                model: {
+                    value: config.modelValue,
+                },
+                config: {},
+            },
+        };
+        manifest.spec.config = this.buildProviderConfig(config);
+        return manifest;
+    }
+    buildProviderConfig(config) {
+        if (config.type === 'azure') {
+            return {
+                azure: {
+                    apiKey: {
+                        valueFrom: {
+                            secretKeyRef: {
+                                name: config.secretName,
+                                key: 'api-key',
+                            },
+                        },
+                    },
+                    baseUrl: {
+                        value: config.baseUrl,
+                    },
+                    apiVersion: {
+                        value: config.apiVersion,
+                    },
+                },
+            };
+        }
+        if (config.type === 'bedrock') {
+            return this.buildBedrockConfig(config);
+        }
+        if (config.type === 'openai') {
+            return {
+                openai: {
+                    apiKey: {
+                        valueFrom: {
+                            secretKeyRef: {
+                                name: config.secretName,
+                                key: 'api-key',
+                            },
+                        },
+                    },
+                    baseUrl: {
+                        value: config.baseUrl,
+                    },
+                },
+            };
+        }
+        throw new Error(`Unknown provider type: ${config.type}`);
+    }
+    buildBedrockConfig(config) {
+        const bedrockConfig = {
+            bedrock: {
+                region: {
+                    value: config.region,
+                },
+                accessKeyId: {
+                    valueFrom: {
+                        secretKeyRef: {
+                            name: config.secretName,
+                            key: 'access-key-id',
+                        },
+                    },
+                },
+                secretAccessKey: {
+                    valueFrom: {
+                        secretKeyRef: {
+                            name: config.secretName,
+                            key: 'secret-access-key',
+                        },
+                    },
+                },
+            },
+        };
+        const bedrock = bedrockConfig.bedrock;
+        if (config.sessionToken) {
+            bedrock.sessionToken = {
+                valueFrom: {
+                    secretKeyRef: {
+                        name: config.secretName,
+                        key: 'session-token',
+                    },
+                },
+            };
+        }
+        if (config.modelArn) {
+            bedrock.modelArn = {
+                value: config.modelArn,
+            };
+        }
+        return bedrockConfig;
+    }
+}

package/dist/commands/models/kubernetes/secret-manager.d.ts

@@ -0,0 +1,7 @@
+import { ProviderConfig } from '../providers/index.js';
+export interface SecretManager {
+    createSecret(config: ProviderConfig): Promise<void>;
+}
+export declare class KubernetesSecretManager implements SecretManager {
+    createSecret(config: ProviderConfig): Promise<void>;
+}

package/dist/commands/models/kubernetes/secret-manager.js

@@ -0,0 +1,20 @@
+import { execa } from 'execa';
+import output from '../../../lib/output.js';
+// Kubernetes secret manager implementation
+export class KubernetesSecretManager {
+    async createSecret(config) {
+        const secretArgs = ['create', 'secret', 'generic', config.secretName];
+        if (config.type === 'bedrock') {
+            secretArgs.push(`--from-literal=access-key-id=${config.accessKeyId}`);
+            secretArgs.push(`--from-literal=secret-access-key=${config.secretAccessKey}`);
+            if (config.sessionToken) {
+                secretArgs.push(`--from-literal=session-token=${config.sessionToken}`);
+            }
+        }
+        else {
+            secretArgs.push(`--from-literal=api-key=${config.apiKey}`);
+        }
+        await execa('kubectl', secretArgs, { stdio: 'pipe' });
+        output.success(`created secret ${config.secretName}`);
+    }
+}

package/dist/commands/models/providers/azure.d.ts

@@ -0,0 +1,31 @@
+import { BaseProviderConfig, BaseCollectorOptions, ProviderConfigCollector } from './types.js';
+/**
+ * Configuration for Azure OpenAI models.
+ */
+export interface AzureConfig extends BaseProviderConfig {
+    type: 'azure';
+    baseUrl: string;
+    apiKey: string;
+    apiVersion: string;
+}
+/**
+ * Options specific to Azure collector.
+ */
+export interface AzureCollectorOptions extends BaseCollectorOptions {
+    baseUrl?: string;
+    apiKey?: string;
+    apiVersion?: string;
+}
+/**
+ * Configuration collector for Azure OpenAI models.
+ *
+ * Collects the necessary configuration to connect to Azure OpenAI Service:
+ * - baseUrl: The Azure OpenAI endpoint URL (e.g., https://<resource>.openai.azure.com)
+ * - apiVersion: The API version to use (defaults to 2024-12-01-preview)
+ * - apiKey: The authentication key for the Azure OpenAI resource
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export declare class AzureConfigCollector implements ProviderConfigCollector {
+    collectConfig(options: BaseCollectorOptions): Promise<AzureConfig>;
+}

package/dist/commands/models/providers/azure.js

@@ -0,0 +1,82 @@
+import inquirer from 'inquirer';
+/**
+ * Configuration collector for Azure OpenAI models.
+ *
+ * Collects the necessary configuration to connect to Azure OpenAI Service:
+ * - baseUrl: The Azure OpenAI endpoint URL (e.g., https://<resource>.openai.azure.com)
+ * - apiVersion: The API version to use (defaults to 2024-12-01-preview)
+ * - apiKey: The authentication key for the Azure OpenAI resource
+ *
+ * Values can be provided via command-line options or will be prompted interactively.
+ */
+export class AzureConfigCollector {
+    async collectConfig(options) {
+        const azureOptions = options;
+        let baseUrl = azureOptions.baseUrl;
+        if (!baseUrl) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'baseUrl',
+                    message: 'base URL:',
+                    validate: (input) => {
+                        if (!input)
+                            return 'base URL is required';
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'please enter a valid URL';
+                        }
+                    },
+                },
+            ]);
+            baseUrl = answer.baseUrl;
+        }
+        if (!baseUrl) {
+            throw new Error('base URL is required');
+        }
+        baseUrl = baseUrl.replace(/\/$/, '');
+        let apiVersion = azureOptions.apiVersion || '';
+        if (!azureOptions.apiVersion) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'apiVersion',
+                    message: 'Azure API version:',
+                    default: '2024-12-01-preview',
+                },
+            ]);
+            apiVersion = answer.apiVersion;
+        }
+        let apiKey = azureOptions.apiKey;
+        if (!apiKey) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'apiKey',
+                    message: 'API key:',
+                    mask: '*',
+                    validate: (input) => {
+                        if (!input)
+                            return 'API key is required';
+                        return true;
+                    },
+                },
+            ]);
+            apiKey = answer.apiKey;
+        }
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        return {
+            type: 'azure',
+            modelValue: options.model,
+            secretName: '',
+            baseUrl,
+            apiKey,
+            apiVersion,
+        };
+    }
+}

package/dist/commands/models/providers/azure.spec.d.ts

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