@agents-at-scale/ark 0.1.35-rc2 → 0.1.35

package/dist/commands/query/index.js

@@ -1,131 +0,0 @@
-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,3 +0,0 @@
-import { Command } from 'commander';
-import type { ArkConfig } from '../../lib/config.js';
-export declare function createRoutesCommand(_: ArkConfig): Command;

package/dist/commands/routes/index.js

@@ -1,93 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { execa } from 'execa';
-import output from '../../lib/output.js';
-async function listRoutes() {
-    const namespace = 'ark-system';
-    const port = 8080;
-    const portSuffix = `:${port}`;
-    try {
-        // Check if localhost-gateway is installed
-        const { stdout: gatewayCheck } = await execa('kubectl', ['get', 'gateway', 'localhost-gateway', '-n', namespace], { reject: false });
-        if (!gatewayCheck) {
-            output.error("localhost-gateway not installed in namespace 'ark-system'");
-            output.info("run 'ark install' first");
-            process.exit(1);
-        }
-        // Get HTTPRoutes
-        const { stdout: routeOutput } = await execa('kubectl', [
-            'get',
-            'httproutes',
-            '-A',
-            '-o',
-            'custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTNAMES:.spec.hostnames',
-            '--no-headers',
-        ], { reject: false });
-        if (!routeOutput || routeOutput.trim() === '') {
-            console.log(chalk.white('available localhost gateway routes: 0'));
-            output.info('no httproutes found. install services to see routes here.');
-            return;
-        }
-        // Parse routes
-        const lines = routeOutput.trim().split('\n');
-        const routes = [];
-        lines.forEach((line) => {
-            const parts = line.split(/\s+/);
-            if (parts.length >= 3) {
-                const name = parts[1];
-                // Remove brackets and split hostnames
-                const hostnamesStr = parts.slice(2).join(' ').replace(/\[|\]/g, '');
-                const hostnames = hostnamesStr
-                    .split(',')
-                    .map((h) => h.trim())
-                    .filter((h) => h && h !== '<none>');
-                if (hostnames.length > 0) {
-                    routes.push({ name, hostnames });
-                }
-            }
-        });
-        // Count total routes (each hostname counts as a route)
-        const routeCount = routes.reduce((count, r) => count + r.hostnames.length, 0);
-        console.log(chalk.white(`available localhost gateway routes: ${routeCount}`));
-        // Check port-forward status
-        const { stdout: psOutput } = await execa('pgrep', ['-f', `kubectl.*port-forward.*${port}:80`], { reject: false });
-        const portForwardActive = !!psOutput;
-        if (portForwardActive) {
-            output.info(`port-forward active on localhost${portSuffix}`);
-        }
-        else {
-            output.error(`port-forward not running on localhost${portSuffix} - routes are not exposed`);
-            console.log(chalk.blue('run:'), `kubectl port-forward -n ${namespace} service/localhost-gateway-nginx ${port}:80 > /dev/null 2>&1 &`);
-        }
-        console.log();
-        // Display routes
-        if (routes.length > 0) {
-            const maxLength = Math.max(...routes.map((r) => r.name.length));
-            routes.forEach((route) => {
-                route.hostnames.forEach((hostname) => {
-                    const url = `http://${hostname}${portSuffix}/`;
-                    const padding = ' '.repeat(maxLength - route.name.length);
-                    if (portForwardActive) {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)}`);
-                    }
-                    else {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)} ${chalk.red('(unavailable)')}`);
-                    }
-                });
-            });
-        }
-    }
-    catch (error) {
-        output.error('failed to fetch routes:', error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-}
-export function createRoutesCommand(_) {
-    const command = new Command('routes');
-    command
-        .description('show available gateway routes and their urls')
-        .action(async () => {
-        await listRoutes();
-    });
-    return command;
-}

package/dist/commands/routes.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function createRoutesCommand(): Command;

package/dist/commands/routes.js

@@ -1,101 +0,0 @@
-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}`;
-    try {
-        // Check if localhost-gateway is installed
-        const { stdout: gatewayCheck } = await execa('kubectl', ['get', 'gateway', 'localhost-gateway', '-n', namespace], { reject: false });
-        if (!gatewayCheck) {
-            output.error("localhost-gateway not installed in namespace 'ark-system'");
-            output.info("run 'ark install' first");
-            process.exit(1);
-        }
-        // Get HTTPRoutes
-        const { stdout: routeOutput } = await execa('kubectl', [
-            'get',
-            'httproutes',
-            '-A',
-            '-o',
-            'custom-columns=NAMESPACE:.metadata.namespace,NAME:.metadata.name,HOSTNAMES:.spec.hostnames',
-            '--no-headers',
-        ], { reject: false });
-        if (!routeOutput || routeOutput.trim() === '') {
-            console.log(chalk.white('available localhost gateway routes: 0'));
-            output.info('no httproutes found. install services to see routes here.');
-            return;
-        }
-        // Parse routes
-        const lines = routeOutput.trim().split('\n');
-        const routes = [];
-        lines.forEach((line) => {
-            const parts = line.split(/\s+/);
-            if (parts.length >= 3) {
-                const name = parts[1];
-                // Remove brackets and split hostnames
-                const hostnamesStr = parts.slice(2).join(' ').replace(/\[|\]/g, '');
-                const hostnames = hostnamesStr
-                    .split(',')
-                    .map((h) => h.trim())
-                    .filter((h) => h && h !== '<none>');
-                if (hostnames.length > 0) {
-                    routes.push({ name, hostnames });
-                }
-            }
-        });
-        // Count total routes (each hostname counts as a route)
-        const routeCount = routes.reduce((count, r) => count + r.hostnames.length, 0);
-        console.log(chalk.white(`available localhost gateway routes: ${routeCount}`));
-        // Check port-forward status
-        const { stdout: psOutput } = await execa('pgrep', ['-f', `kubectl.*port-forward.*${port}:80`], { reject: false });
-        const portForwardActive = !!psOutput;
-        if (portForwardActive) {
-            output.info(`port-forward active on localhost${portSuffix}`);
-        }
-        else {
-            output.error(`port-forward not running on localhost${portSuffix} - routes are not exposed`);
-            console.log(chalk.blue('run:'), `kubectl port-forward -n ${namespace} service/localhost-gateway-nginx ${port}:80 > /dev/null 2>&1 &`);
-        }
-        console.log();
-        // Display routes
-        if (routes.length > 0) {
-            const maxLength = Math.max(...routes.map((r) => r.name.length));
-            routes.forEach((route) => {
-                route.hostnames.forEach((hostname) => {
-                    const url = `http://${hostname}${portSuffix}/`;
-                    const padding = ' '.repeat(maxLength - route.name.length);
-                    if (portForwardActive) {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)}`);
-                    }
-                    else {
-                        console.log(`  ${route.name}${padding}: ${chalk.blue(url)} ${chalk.red('(unavailable)')}`);
-                    }
-                });
-            });
-        }
-    }
-    catch (error) {
-        output.error('failed to fetch routes:', error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-}
-export function createRoutesCommand() {
-    const command = new Command('routes');
-    command
-        .description('show available gateway routes and their urls')
-        .action(async () => {
-        await listRoutes();
-    });
-    return command;
-}

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

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-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

@@ -1,262 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import { StatusChecker } from '../../components/statusChecker.js';
-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 {
-        spinner.text = 'Checking system dependencies';
-        const statusChecker = new StatusChecker();
-        spinner.text = 'Testing cluster access';
-        spinner.text = 'Checking ARK services';
-        const statusData = await statusChecker.checkAll();
-        spinner.stop();
-        const sections = buildStatusSections(statusData, config);
-        StatusFormatter.printSections(sections);
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.fail('Failed to check status');
-        console.error(chalk.red('Error:'), error);
-        process.exit(1);
-    }
-}
-export function createStatusCommand(config) {
-    const statusCommand = new Command('status');
-    statusCommand
-        .description('Check ARK system status')
-        .action(() => checkStatus(config));
-    return statusCommand;
-}

package/dist/commands/status.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-export declare function checkStatus(): Promise<void>;
-export declare function createStatusCommand(): Command;

package/dist/commands/status.js

@@ -1,33 +0,0 @@
-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() {
-    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);
-        spinner.text = 'Testing cluster access';
-        spinner.text = 'Checking ARK services';
-        const statusData = await statusChecker.checkAll();
-        spinner.stop();
-        StatusFormatter.printStatus(statusData);
-        process.exit(0);
-    }
-    catch (error) {
-        spinner.fail('Failed to check status');
-        console.error(chalk.red('Error:'), error);
-        process.exit(1);
-    }
-}
-export function createStatusCommand() {
-    const statusCommand = new Command('status');
-    statusCommand.description('Check ARK system status').action(checkStatus);
-    return statusCommand;
-}

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

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