@agents-at-scale/ark 0.1.35 → 0.1.36-rc1

package/dist/commands/install.js

@@ -0,0 +1,147 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import { isCommandAvailable } from '../lib/commandUtils.js';
+import { getClusterInfo } from '../lib/cluster.js';
+import output from '../lib/output.js';
+import { getInstallableServices, arkDependencies } from '../arkServices.js';
+import { createModel } from './models/create.js';
+export async function installArk() {
+    // Check if helm is installed
+    const helmInstalled = await isCommandAvailable('helm');
+    if (!helmInstalled) {
+        output.error('helm is not installed. please install helm first:');
+        output.info('https://helm.sh/docs/intro/install/');
+        process.exit(1);
+    }
+    // Check if kubectl is installed (needed for some dependencies)
+    const kubectlInstalled = await isCommandAvailable('kubectl');
+    if (!kubectlInstalled) {
+        output.error('kubectl is not installed. please install kubectl first:');
+        output.info('https://kubernetes.io/docs/tasks/tools/');
+        process.exit(1);
+    }
+    // Check cluster connectivity
+    const clusterInfo = await getClusterInfo();
+    if (clusterInfo.error) {
+        output.error('no kubernetes cluster detected');
+        output.info('please ensure you have a running cluster and kubectl is configured.');
+        output.info('');
+        output.info('for local development, we recommend minikube:');
+        output.info('• install: https://minikube.sigs.k8s.io/docs/start');
+        output.info('• start cluster: minikube start');
+        output.info('');
+        output.info('alternatively, you can use kind or docker desktop.');
+        process.exit(1);
+    }
+    // Show cluster info
+    output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
+    output.info(`type: ${clusterInfo.type}`);
+    output.info(`namespace: ${clusterInfo.namespace}`);
+    if (clusterInfo.ip) {
+        output.info(`ip: ${clusterInfo.ip}`);
+    }
+    console.log(); // Add blank line after cluster info
+    // Ask about installing dependencies
+    const { shouldInstallDeps } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'shouldInstallDeps',
+            message: 'install required dependencies (cert-manager, gateway api)?',
+            default: true,
+        },
+    ]);
+    if (shouldInstallDeps) {
+        for (const dep of Object.values(arkDependencies)) {
+            output.info(`installing ${dep.description || dep.name}...`);
+            try {
+                await execa(dep.command, dep.args, {
+                    stdio: 'inherit',
+                });
+                output.success(`${dep.name} completed`);
+                console.log(); // Add blank line after dependency
+            }
+            catch {
+                console.log(); // Add blank line after error
+                process.exit(1);
+            }
+        }
+    }
+    // Get installable services and iterate through them
+    const services = getInstallableServices();
+    for (const service of Object.values(services)) {
+        // Ask for confirmation
+        const { shouldInstall } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldInstall',
+                message: `install ${chalk.bold(service.name)}? ${service.description ? chalk.gray(`(${service.description.toLowerCase()})`) : ''}`,
+                default: true,
+            },
+        ]);
+        if (!shouldInstall) {
+            output.warning(`skipping ${service.name}`);
+            continue;
+        }
+        try {
+            // Build helm arguments
+            const helmArgs = [
+                'upgrade',
+                '--install',
+                service.helmReleaseName,
+                service.chartPath,
+                '--namespace',
+                service.namespace,
+            ];
+            // Add any additional args from the service definition
+            if (service.installArgs) {
+                helmArgs.push(...service.installArgs);
+            }
+            // Run helm upgrade --install with streaming output
+            await execa('helm', helmArgs, {
+                stdio: 'inherit',
+            });
+            console.log(); // Add blank line after command output
+        }
+        catch {
+            // Continue with remaining services on error
+            console.log(); // Add blank line after error output
+        }
+    }
+    // Check for default model after installing services
+    output.info('checking for default model...');
+    let modelExists = false;
+    try {
+        await execa('kubectl', ['get', 'model', 'default'], { stdio: 'pipe' });
+        modelExists = true;
+        output.success('default model already configured');
+    }
+    catch {
+        output.warning('no default model found');
+    }
+    if (!modelExists) {
+        const { shouldCreateModel } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'shouldCreateModel',
+                message: 'would you like to create a default model?',
+                default: true,
+            },
+        ]);
+        if (shouldCreateModel) {
+            await createModel('default');
+        }
+        else {
+            output.warning('skipping model creation');
+            output.info('you can create a model later using ark models create or the dashboard');
+        }
+    }
+}
+export function createInstallCommand() {
+    const command = new Command('install');
+    command.description('Install ARK components using Helm').action(async () => {
+        await installArk();
+    });
+    return command;
+}

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

@@ -0,0 +1 @@
+export declare function createModel(modelName?: string): Promise<boolean>;

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/models/selector.d.ts

@@ -0,0 +1,8 @@
+import { Model, ArkApiClient } from '../../lib/arkApiClient.js';
+interface ModelSelectorProps {
+    arkApiClient: ArkApiClient;
+    onSelect: (model: Model) => void;
+    onExit: () => void;
+}
+export declare function ModelSelector({ arkApiClient, onSelect, onExit, }: ModelSelectorProps): import("react/jsx-runtime").JSX.Element;
+export {};