@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/commands/models/create.js

@@ -0,0 +1,213 @@
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import output from '../../lib/output.js';
+export async function createModel(modelName) {
+    // Step 1: Get model name if not provided
+    if (!modelName) {
+        const nameAnswer = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'modelName',
+                message: 'model name:',
+                default: 'default',
+                validate: (input) => {
+                    if (!input)
+                        return 'model name is required';
+                    // Kubernetes name validation
+                    if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input)) {
+                        return 'model name must be a valid Kubernetes resource name';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        modelName = nameAnswer.modelName;
+    }
+    // Check if model already exists
+    try {
+        await execa('kubectl', ['get', 'model', modelName], { stdio: 'pipe' });
+        output.warning(`model ${modelName} already exists`);
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `overwrite existing model ${modelName}?`,
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            output.info('model creation cancelled');
+            return false;
+        }
+    }
+    catch {
+        // Model doesn't exist, continue
+    }
+    // Step 2: Choose model type
+    const { modelType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'modelType',
+            message: 'select model provider:',
+            choices: [
+                { name: 'Azure OpenAI', value: 'azure' },
+                { name: 'OpenAI', value: 'openai' },
+            ],
+            default: 'azure',
+        },
+    ]);
+    // Step 3: Get common parameters
+    const commonAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'modelVersion',
+            message: 'model version:',
+            default: 'gpt-4o-mini',
+        },
+        {
+            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';
+                }
+            },
+        },
+    ]);
+    // Remove trailing slash from base URL
+    const baseUrl = commonAnswers.baseUrl.replace(/\/$/, '');
+    // Step 4: Get provider-specific parameters
+    let apiVersion = '';
+    if (modelType === 'azure') {
+        const azureAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'apiVersion',
+                message: 'Azure API version:',
+                default: '2024-12-01-preview',
+            },
+        ]);
+        apiVersion = azureAnswers.apiVersion;
+    }
+    // Step 5: Get API key (password input)
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'apiKey',
+            message: 'API key:',
+            mask: '*',
+            validate: (input) => {
+                if (!input)
+                    return 'API key is required';
+                return true;
+            },
+        },
+    ]);
+    // Step 6: Create the Kubernetes secret
+    const secretName = `${modelName}-model-api-key`;
+    output.info(`creating secret ${secretName}...`);
+    try {
+        // Delete existing secret if it exists (update scenario)
+        await execa('kubectl', ['delete', 'secret', secretName], {
+            stdio: 'pipe',
+        }).catch(() => {
+            // Ignore error if secret doesn't exist
+        });
+        // Create the secret
+        await execa('kubectl', [
+            'create',
+            'secret',
+            'generic',
+            secretName,
+            `--from-literal=api-key=${apiKey}`,
+        ], { stdio: 'pipe' });
+        output.success(`secret ${secretName} created`);
+    }
+    catch (error) {
+        output.error('failed to create secret');
+        console.error(error);
+        return false;
+    }
+    // Step 7: 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: commonAnswers.modelVersion,
+            },
+            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,
+            },
+        };
+    }
+    try {
+        // Apply the model manifest using kubectl
+        const manifestJson = JSON.stringify(modelManifest);
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: manifestJson,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        output.success(`model ${modelName} created successfully`);
+        console.log();
+        output.info('you can now use this model with ARK agents and queries');
+        return true;
+    }
+    catch (error) {
+        output.error('failed to create model');
+        console.error(error);
+        // Try to clean up the secret if model creation failed
+        try {
+            await execa('kubectl', ['delete', 'secret', secretName], { stdio: 'pipe' });
+            output.info(`cleaned up secret ${secretName}`);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,125 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockInquirer = {
+    prompt: jest.fn(),
+};
+jest.unstable_mockModule('inquirer', () => ({
+    default: mockInquirer,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    warning: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createModel } = await import('./create.js');
+describe('createModel', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates new model with provided name', async () => {
+        // Model doesn't exist
+        mockExeca.mockRejectedValueOnce(new Error('not found'));
+        // Prompts for model details
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com/',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret-key' });
+        // Secret operations succeed
+        mockExeca.mockResolvedValueOnce({}); // delete secret (may not exist)
+        mockExeca.mockResolvedValueOnce({}); // create secret
+        mockExeca.mockResolvedValueOnce({}); // apply model
+        const result = await createModel('test-model');
+        expect(result).toBe(true);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'model', 'test-model'], { stdio: 'pipe' });
+        expect(mockOutput.success).toHaveBeenCalledWith('model test-model created successfully');
+    });
+    it('prompts for name when not provided', async () => {
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelName: 'prompted-model' })
+            .mockResolvedValueOnce({ modelType: 'azure' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://azure.com',
+        })
+            .mockResolvedValueOnce({ apiVersion: '2024-12-01' })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockExeca.mockResolvedValue({}); // all kubectl ops succeed
+        const result = await createModel();
+        expect(result).toBe(true);
+        expect(mockInquirer.prompt).toHaveBeenCalledWith([
+            expect.objectContaining({
+                name: 'modelName',
+                message: 'model name:',
+            }),
+        ]);
+    });
+    it('handles overwrite confirmation when model exists', async () => {
+        // Model exists
+        mockExeca.mockResolvedValueOnce({});
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ overwrite: true })
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockResolvedValue({}); // remaining kubectl ops
+        const result = await createModel('existing-model');
+        expect(result).toBe(true);
+        expect(mockOutput.warning).toHaveBeenCalledWith('model existing-model already exists');
+    });
+    it('cancels when user declines overwrite', async () => {
+        mockExeca.mockResolvedValueOnce({}); // model exists
+        mockInquirer.prompt.mockResolvedValueOnce({ overwrite: false });
+        const result = await createModel('existing-model');
+        expect(result).toBe(false);
+        expect(mockOutput.info).toHaveBeenCalledWith('model creation cancelled');
+    });
+    it('handles secret creation failure', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockRejectedValueOnce(new Error('delete failed')); // delete secret may fail
+        mockExeca.mockRejectedValueOnce(new Error('secret creation failed')); // create secret fails
+        const result = await createModel('test-model');
+        expect(result).toBe(false);
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to create secret');
+    });
+    it('cleans up secret if model creation fails', async () => {
+        mockExeca.mockRejectedValueOnce(new Error('not found')); // model doesn't exist
+        mockInquirer.prompt
+            .mockResolvedValueOnce({ modelType: 'openai' })
+            .mockResolvedValueOnce({
+            modelVersion: 'gpt-4',
+            baseUrl: 'https://api.openai.com',
+        })
+            .mockResolvedValueOnce({ apiKey: 'secret' });
+        mockExeca.mockResolvedValueOnce({}); // delete secret
+        mockExeca.mockResolvedValueOnce({}); // create secret
+        mockExeca.mockRejectedValueOnce(new Error('apply failed')); // apply model fails
+        mockExeca.mockResolvedValueOnce({}); // cleanup secret
+        const result = await createModel('test-model');
+        expect(result).toBe(false);
+        expect(mockOutput.error).toHaveBeenCalledWith('failed to create model');
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['delete', 'secret', 'test-model-model-api-key'], { stdio: 'pipe' });
+    });
+});

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createModelsCommand(_: ArkConfig): Command;

package/dist/commands/models/index.js

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+import { createModel } from './create.js';
+import { executeQuery } from '../../lib/executeQuery.js';
+async function listModels(options) {
+    try {
+        // Use kubectl to get models
+        const result = await execa('kubectl', ['get', 'models', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const models = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(models, null, 2));
+        }
+        else {
+            if (models.length === 0) {
+                output.info('No models found');
+                return;
+            }
+            // Just output the model names
+            models.forEach((model) => {
+                console.log(model.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching models:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+export function createModelsCommand(_) {
+    const modelsCommand = new Command('models');
+    modelsCommand
+        .description('List available models')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listModels(options);
+    });
+    const listCommand = new Command('list');
+    listCommand
+        .alias('ls')
+        .description('List available models')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(async (options) => {
+        await listModels(options);
+    });
+    modelsCommand.addCommand(listCommand);
+    // Add create command
+    const createCommand = new Command('create');
+    createCommand
+        .description('Create a new model')
+        .argument('[name]', 'Model name (optional)')
+        .action(async (name) => {
+        await createModel(name);
+    });
+    modelsCommand.addCommand(createCommand);
+    // Add query command
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Query a model')
+        .argument('<name>', 'Model name (e.g., default)')
+        .argument('<message>', 'Message to send')
+        .action(async (name, message) => {
+        await executeQuery({
+            targetType: 'model',
+            targetName: name,
+            message,
+        });
+    });
+    modelsCommand.addCommand(queryCommand);
+    return modelsCommand;
+}

package/dist/commands/models/index.spec.d.ts

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

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

@@ -0,0 +1,96 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockOutput = {
+    info: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockCreateModel = jest.fn();
+jest.unstable_mockModule('./create.js', () => ({
+    createModel: mockCreateModel,
+}));
+const mockExecuteQuery = jest.fn();
+jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
+    executeQuery: mockExecuteQuery,
+    parseTarget: jest.fn(),
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createModelsCommand } = await import('./index.js');
+describe('models command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createModelsCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('models');
+    });
+    it('lists models in text format', async () => {
+        const mockModels = {
+            items: [{ metadata: { name: 'gpt-4' } }, { metadata: { name: 'claude-3' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
+        const command = createModelsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'models', '-o', 'json'], { stdio: 'pipe' });
+        expect(mockConsoleLog).toHaveBeenCalledWith('gpt-4');
+        expect(mockConsoleLog).toHaveBeenCalledWith('claude-3');
+    });
+    it('lists models in json format', async () => {
+        const mockModels = {
+            items: [{ metadata: { name: 'gpt-4' } }],
+        };
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify(mockModels) });
+        const command = createModelsCommand({});
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockModels.items, null, 2));
+    });
+    it('shows info when no models', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createModelsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.info).toHaveBeenCalledWith('No models found');
+    });
+    it('handles errors', async () => {
+        mockExeca.mockRejectedValue(new Error('kubectl failed'));
+        const command = createModelsCommand({});
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('fetching models:', 'kubectl failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('list subcommand works', async () => {
+        mockExeca.mockResolvedValue({ stdout: JSON.stringify({ items: [] }) });
+        const command = createModelsCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(mockExeca).toHaveBeenCalled();
+    });
+    it('create subcommand works', async () => {
+        const command = createModelsCommand({});
+        await command.parseAsync(['node', 'test', 'create', 'my-model']);
+        expect(mockCreateModel).toHaveBeenCalledWith('my-model');
+    });
+    it('query subcommand works', async () => {
+        const command = createModelsCommand({});
+        await command.parseAsync([
+            'node',
+            'test',
+            'query',
+            'default',
+            'Hello world',
+        ]);
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'model',
+            targetName: 'default',
+            message: 'Hello world',
+        });
+    });
+});

package/dist/commands/query/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createQueryCommand(_: ArkConfig): Command;

package/dist/commands/query/index.js

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { executeQuery, parseTarget } from '../../lib/executeQuery.js';
+export function createQueryCommand(_) {
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Execute a single query against a model or agent')
+        .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
+        .argument('<message>', 'Message to send')
+        .action(async (target, message) => {
+        // Parse and validate target format
+        const parsed = parseTarget(target);
+        if (!parsed) {
+            output.error('Invalid target format. Use: model/name or agent/name etc');
+            process.exit(1);
+        }
+        await executeQuery({
+            targetType: parsed.type,
+            targetName: parsed.name,
+            message,
+        });
+    });
+    return queryCommand;
+}

package/dist/commands/query/index.spec.d.ts

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

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

@@ -0,0 +1,53 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExecuteQuery = jest.fn();
+const mockParseTarget = jest.fn();
+jest.unstable_mockModule('../../lib/executeQuery.js', () => ({
+    executeQuery: mockExecuteQuery,
+    parseTarget: mockParseTarget,
+}));
+const mockOutput = {
+    error: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const { createQueryCommand } = await import('./index.js');
+describe('createQueryCommand', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should create a query command', () => {
+        const command = createQueryCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('query');
+        expect(command.description()).toBe('Execute a single query against a model or agent');
+    });
+    it('should parse and execute query with valid target', async () => {
+        mockParseTarget.mockReturnValue({
+            type: 'model',
+            name: 'default',
+        });
+        mockExecuteQuery.mockResolvedValue(undefined);
+        const command = createQueryCommand({});
+        await command.parseAsync(['node', 'test', 'model/default', 'Hello world']);
+        expect(mockParseTarget).toHaveBeenCalledWith('model/default');
+        expect(mockExecuteQuery).toHaveBeenCalledWith({
+            targetType: 'model',
+            targetName: 'default',
+            message: 'Hello world',
+        });
+    });
+    it('should error on invalid target format', async () => {
+        mockParseTarget.mockReturnValue(null);
+        const command = createQueryCommand({});
+        await expect(command.parseAsync(['node', 'test', 'invalid-target', 'Hello'])).rejects.toThrow('process.exit called');
+        expect(mockParseTarget).toHaveBeenCalledWith('invalid-target');
+        expect(mockExecuteQuery).not.toHaveBeenCalled();
+        expect(mockOutput.error).toHaveBeenCalledWith('Invalid target format. Use: model/name or agent/name etc');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createRoutesCommand(_: ArkConfig): Command;