@agents-at-scale/ark 0.1.35-rc.1 → 0.1.35-rc2

package/dist/commands/models/index.js

@@ -26,16 +26,11 @@ async function listModels(options) {
         }
     }
     catch (error) {
-        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
-            output.error('Model CRDs not installed. Is the ARK controller running?');
-        }
-        else {
-            output.error(`Failed to list models: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
+        output.error('fetching models:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 }
-export function createModelsCommand() {
+export function createModelsCommand(_) {
     const modelsCommand = new Command('models');
     modelsCommand
         .description('List available models')

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

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

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

@@ -0,0 +1,76 @@
+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 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');
+    });
+});

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,131 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import ora from 'ora';
+import output from '../../lib/output.js';
+async function runQuery(target, message) {
+    const spinner = ora('Creating query...').start();
+    // Generate a unique query name
+    const timestamp = Date.now();
+    const queryName = `cli-query-${timestamp}`;
+    // Parse the target format (e.g., model/default -> type: model, name: default)
+    const [targetType, targetName] = target.split('/');
+    // Create the Query resource
+    const queryManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Query',
+        metadata: {
+            name: queryName,
+        },
+        spec: {
+            input: message,
+            targets: [
+                {
+                    type: targetType,
+                    name: targetName,
+                },
+            ],
+        },
+    };
+    try {
+        // Apply the query
+        spinner.text = 'Submitting query...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(queryManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Watch for query completion
+        spinner.text = 'Query status: initializing';
+        let queryComplete = false;
+        let attempts = 0;
+        const maxAttempts = 300; // 5 minutes with 1 second intervals
+        while (!queryComplete && attempts < maxAttempts) {
+            attempts++;
+            try {
+                const { stdout } = await execa('kubectl', [
+                    'get',
+                    'query',
+                    queryName,
+                    '-o',
+                    'json',
+                ], { stdio: 'pipe' });
+                const query = JSON.parse(stdout);
+                const phase = query.status?.phase;
+                // Update spinner with current phase
+                if (phase) {
+                    spinner.text = `Query status: ${phase}`;
+                }
+                // Check if query is complete based on phase
+                if (phase === 'done') {
+                    queryComplete = true;
+                    spinner.succeed('Query completed');
+                    // Extract and display the response from responses array
+                    if (query.status?.responses && query.status.responses.length > 0) {
+                        const response = query.status.responses[0];
+                        console.log('\n' + (response.content || response));
+                    }
+                    else {
+                        output.warning('No response received');
+                    }
+                }
+                else if (phase === 'error') {
+                    queryComplete = true;
+                    spinner.fail('Query failed');
+                    // Try to get error message from conditions or status
+                    const errorCondition = query.status?.conditions?.find((c) => {
+                        const condition = c;
+                        return condition.type === 'Complete' && condition.status === 'False';
+                    });
+                    if (errorCondition?.message) {
+                        output.error(errorCondition.message);
+                    }
+                    else if (query.status?.error) {
+                        output.error(query.status.error);
+                    }
+                    else {
+                        output.error('Query failed with unknown error');
+                    }
+                }
+                else if (phase === 'canceled') {
+                    queryComplete = true;
+                    spinner.warn('Query canceled');
+                    // Try to get cancellation reason if available
+                    if (query.status?.message) {
+                        output.warning(query.status.message);
+                    }
+                }
+            }
+            catch {
+                // Query might not exist yet, continue waiting
+                spinner.text = 'Running query: waiting for query to be created';
+            }
+            if (!queryComplete) {
+                await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second
+            }
+        }
+        if (!queryComplete) {
+            spinner.fail('Query timed out');
+            output.error('Query did not complete within 5 minutes');
+        }
+    }
+    catch (error) {
+        spinner.fail('Query failed');
+        output.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+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) => {
+        // Validate target format
+        if (!target.includes('/')) {
+            output.error('Invalid target format. Use: model/name or agent/name etc');
+            process.exit(1);
+        }
+        await runQuery(target, message);
+    });
+    return queryCommand;
+}

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

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

package/dist/commands/routes/index.js

@@ -2,15 +2,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { execa } from 'execa';
 import output from '../../lib/output.js';
-import { isCommandAvailable } from '../../lib/commandUtils.js';
 async function listRoutes() {
-    // Check if kubectl is installed
-    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);
-    }
     const namespace = 'ark-system';
     const port = 8080;
     const portSuffix = `:${port}`;
@@ -90,7 +82,7 @@ async function listRoutes() {
         process.exit(1);
     }
 }
-export function createRoutesCommand() {
+export function createRoutesCommand(_) {
     const command = new Command('routes');
     command
         .description('show available gateway routes and their urls')

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

@@ -1,3 +1,4 @@
 import { Command } from 'commander';
-export declare function checkStatus(): Promise<void>;
-export declare function createStatusCommand(): Command;
+import type { ArkConfig } from '../../lib/config.js';
+export declare function checkStatus(config: ArkConfig): Promise<void>;
+export declare function createStatusCommand(config: ArkConfig): Command;

package/dist/commands/status/index.js

@@ -2,22 +2,249 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import ora from 'ora';
 import { StatusChecker } from '../../components/statusChecker.js';
-import { ConfigManager } from '../../config.js';
-import { ArkClient } from '../../lib/arkClient.js';
-import { StatusFormatter } from '../../ui/statusFormatter.js';
-export async function checkStatus() {
+import { StatusFormatter, } from '../../ui/statusFormatter.js';
+/**
+ * Enrich service with formatted details including version/revision
+ */
+function enrichServiceDetails(service, _) {
+    const statusMap = {
+        healthy: { icon: '✓', text: 'healthy', color: 'green' },
+        unhealthy: { icon: '✗', text: 'unhealthy', color: 'red' },
+        warning: { icon: '⚠', text: 'warning', color: 'yellow' },
+        'not ready': { icon: '○', text: 'not ready', color: 'yellow' },
+        'not installed': { icon: '?', text: 'not installed', color: 'yellow' },
+    };
+    const statusInfo = statusMap[service.status] || {
+        icon: '?',
+        text: service.status,
+        color: 'yellow',
+    };
+    // Build details array
+    const details = [];
+    if (service.status === 'healthy') {
+        if (service.version)
+            details.push(service.version);
+        if (service.revision)
+            details.push(`revision ${service.revision}`);
+    }
+    if (service.details)
+        details.push(service.details);
+    // Build display name with formatting
+    let displayName = chalk.bold(service.name);
+    if (service.namespace) {
+        displayName += ` ${chalk.blue(service.namespace)}`;
+    }
+    if (service.isDev) {
+        displayName += ' (dev)';
+    }
+    return {
+        statusInfo,
+        displayName,
+        details: details.join(', '),
+    };
+}
+function buildStatusSections(data, config) {
+    const sections = [];
+    // Dependencies section
+    sections.push({
+        title: 'system dependencies:',
+        lines: data.dependencies.map((dep) => ({
+            icon: dep.installed ? '✓' : '✗',
+            iconColor: (dep.installed ? 'green' : 'red'),
+            status: dep.installed ? 'installed' : 'missing',
+            statusColor: (dep.installed ? 'green' : 'red'),
+            name: chalk.bold(dep.name),
+            details: dep.version || '',
+            subtext: dep.installed ? undefined : dep.details,
+        })),
+    });
+    // Cluster access section
+    const clusterLines = [];
+    if (data.clusterAccess) {
+        const contextName = data.clusterInfo?.context || 'kubernetes cluster';
+        const namespace = data.clusterInfo?.namespace || 'default';
+        // Add bold context name with blue namespace
+        const name = `${chalk.bold(contextName)} ${chalk.blue(namespace)}`;
+        const details = [];
+        if (data.clusterInfo?.type && data.clusterInfo.type !== 'unknown') {
+            details.push(data.clusterInfo.type);
+        }
+        if (data.clusterInfo?.ip) {
+            details.push(data.clusterInfo.ip);
+        }
+        clusterLines.push({
+            icon: '✓',
+            iconColor: 'green',
+            status: 'accessible',
+            statusColor: 'green',
+            name,
+            details: details.join(', '),
+        });
+    }
+    else {
+        clusterLines.push({
+            icon: '✗',
+            iconColor: 'red',
+            status: 'unreachable',
+            statusColor: 'red',
+            name: 'kubernetes cluster',
+            subtext: 'Install minikube: https://minikube.sigs.k8s.io/docs/start',
+        });
+    }
+    sections.push({ title: 'cluster access:', lines: clusterLines });
+    // Ark services section
+    if (data.clusterAccess) {
+        const serviceLines = data.services
+            .filter((s) => s.name !== 'ark-controller')
+            .map((service) => {
+            const { statusInfo, displayName, details } = enrichServiceDetails(service, config);
+            return {
+                icon: statusInfo.icon,
+                iconColor: statusInfo.color,
+                status: statusInfo.text,
+                statusColor: statusInfo.color,
+                name: displayName,
+                details: details,
+            };
+        });
+        sections.push({ title: 'ark services:', lines: serviceLines });
+    }
+    else {
+        sections.push({
+            title: 'ark services:',
+            lines: [
+                {
+                    icon: '',
+                    status: '',
+                    name: 'Cannot check ARK services - cluster not accessible',
+                },
+            ],
+        });
+    }
+    // Ark status section
+    const arkStatusLines = [];
+    if (!data.clusterAccess) {
+        arkStatusLines.push({
+            icon: '✗',
+            iconColor: 'red',
+            status: 'no cluster access',
+            statusColor: 'red',
+            name: '',
+        });
+    }
+    else {
+        const controller = data.services?.find((s) => s.name === 'ark-controller');
+        if (!controller) {
+            arkStatusLines.push({
+                icon: '○',
+                iconColor: 'yellow',
+                status: 'not ready',
+                statusColor: 'yellow',
+                name: 'ark-controller',
+            });
+        }
+        else {
+            const { statusInfo, displayName, details } = enrichServiceDetails(controller, config);
+            // Map service status to ark status display
+            const statusText = controller.status === 'healthy'
+                ? 'ready'
+                : controller.status === 'not installed'
+                    ? 'not ready'
+                    : controller.status;
+            arkStatusLines.push({
+                icon: statusInfo.icon,
+                iconColor: statusInfo.color,
+                status: statusText,
+                statusColor: statusInfo.color,
+                name: displayName,
+                details: details,
+            });
+            // Add version update status as separate line
+            if (controller.status === 'healthy' && controller.version && config) {
+                if (config.latestVersion === undefined) {
+                    arkStatusLines.push({
+                        icon: '?',
+                        iconColor: 'yellow',
+                        status: 'version check',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'unable to check for updates',
+                    });
+                }
+                else {
+                    // Use currentVersion from config if available, otherwise use controller.version
+                    const currentVersion = config.currentVersion || controller.version;
+                    if (currentVersion === config.latestVersion) {
+                        arkStatusLines.push({
+                            icon: '✓',
+                            iconColor: 'green',
+                            status: 'up to date',
+                            statusColor: 'green',
+                            name: '',
+                            details: config.latestVersion,
+                        });
+                    }
+                    else {
+                        arkStatusLines.push({
+                            icon: '↑',
+                            iconColor: 'yellow',
+                            status: 'update available',
+                            statusColor: 'yellow',
+                            name: '',
+                            details: config.latestVersion,
+                        });
+                    }
+                }
+            }
+            // Add default model status
+            if (data.defaultModel) {
+                if (!data.defaultModel.exists) {
+                    arkStatusLines.push({
+                        icon: '○',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not configured',
+                    });
+                }
+                else if (data.defaultModel.available) {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'green',
+                        status: 'default model',
+                        statusColor: 'green',
+                        name: '',
+                        details: data.defaultModel.provider || 'configured',
+                    });
+                }
+                else {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not available',
+                    });
+                }
+            }
+        }
+    }
+    sections.push({ title: 'ark status:', lines: arkStatusLines });
+    return sections;
+}
+export async function checkStatus(config) {
     const spinner = ora('Checking system status').start();
     try {
-        const configManager = new ConfigManager();
         spinner.text = 'Checking system dependencies';
-        const apiBaseUrl = await configManager.getApiBaseUrl();
-        const arkClient = new ArkClient(apiBaseUrl);
-        const statusChecker = new StatusChecker(arkClient);
+        const statusChecker = new StatusChecker();
         spinner.text = 'Testing cluster access';
         spinner.text = 'Checking ARK services';
         const statusData = await statusChecker.checkAll();
         spinner.stop();
-        StatusFormatter.printStatus(statusData);
+        const sections = buildStatusSections(statusData, config);
+        StatusFormatter.printSections(sections);
         process.exit(0);
     }
     catch (error) {
@@ -26,8 +253,10 @@ export async function checkStatus() {
         process.exit(1);
     }
 }
-export function createStatusCommand() {
+export function createStatusCommand(config) {
     const statusCommand = new Command('status');
-    statusCommand.description('Check ARK system status').action(checkStatus);
+    statusCommand
+        .description('Check ARK system status')
+        .action(() => checkStatus(config));
     return statusCommand;
 }

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

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

package/dist/commands/targets/index.js

@@ -43,7 +43,7 @@ async function listTargets(options) {
         }
     }
 }
-export function createTargetsCommand() {
+export function createTargetsCommand(_) {
     const targets = new Command('targets');
     targets
         .description('list available query targets (agents, teams, models, tools)')

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

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

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

@@ -0,0 +1,105 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockArkApiClient = {
+    getQueryTargets: jest.fn(),
+};
+const mockStart = jest.fn();
+mockStart.mockResolvedValue(mockArkApiClient);
+const mockArkApiProxy = jest.fn();
+mockArkApiProxy.prototype = {
+    start: mockStart,
+    stop: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/arkApiProxy.js', () => ({
+    ArkApiProxy: mockArkApiProxy,
+}));
+const mockOutput = {
+    warning: jest.fn(),
+    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 mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createTargetsCommand } = await import('./index.js');
+describe('targets command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createTargetsCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('targets');
+    });
+    it('lists targets in text format', async () => {
+        const mockTargets = [
+            { id: 'agent/gpt-assistant', type: 'agent', name: 'gpt-assistant' },
+            { id: 'model/gpt-4', type: 'model', name: 'gpt-4' },
+        ];
+        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockArkApiProxy.prototype.start).toHaveBeenCalled();
+        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt-assistant');
+        expect(mockConsoleLog).toHaveBeenCalledWith('model/gpt-4');
+        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
+    });
+    it('lists targets in json format', async () => {
+        const mockTargets = [{ id: 'agent/gpt', type: 'agent', name: 'gpt' }];
+        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test', '-o', 'json']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(JSON.stringify(mockTargets, null, 2));
+    });
+    it('filters targets by type', async () => {
+        const mockTargets = [
+            { id: 'agent/gpt', type: 'agent', name: 'gpt' },
+            { id: 'model/claude', type: 'model', name: 'claude' },
+            { id: 'agent/helper', type: 'agent', name: 'helper' },
+        ];
+        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test', '-t', 'agent']);
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent/gpt');
+        expect(mockConsoleLog).toHaveBeenCalledWith('agent/helper');
+        expect(mockConsoleLog).not.toHaveBeenCalledWith('model/claude');
+    });
+    it('sorts targets by type then name', async () => {
+        const mockTargets = [
+            { id: 'model/b', type: 'model', name: 'b' },
+            { id: 'agent/z', type: 'agent', name: 'z' },
+            { id: 'agent/a', type: 'agent', name: 'a' },
+            { id: 'model/a', type: 'model', name: 'a' },
+        ];
+        mockArkApiClient.getQueryTargets.mockResolvedValue(mockTargets);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test']);
+        // Check order of calls
+        const calls = mockConsoleLog.mock.calls.map((call) => call[0]);
+        expect(calls).toEqual(['agent/a', 'agent/z', 'model/a', 'model/b']);
+    });
+    it('shows warning when no targets', async () => {
+        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockOutput.warning).toHaveBeenCalledWith('no targets available');
+    });
+    it('handles errors and stops proxy', async () => {
+        mockArkApiClient.getQueryTargets.mockRejectedValue(new Error('API failed'));
+        const command = createTargetsCommand({});
+        await expect(command.parseAsync(['node', 'test'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith('fetching targets:', 'API failed');
+        expect(mockExit).toHaveBeenCalledWith(1);
+        expect(mockArkApiProxy.prototype.stop).toHaveBeenCalled();
+    });
+    it('list subcommand works', async () => {
+        mockArkApiClient.getQueryTargets.mockResolvedValue([]);
+        const command = createTargetsCommand({});
+        await command.parseAsync(['node', 'test', 'list']);
+        expect(mockArkApiClient.getQueryTargets).toHaveBeenCalled();
+    });
+});