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

package/dist/arkServices.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Centralized ARK service definitions used by both install and status commands
+ */
+export interface ArkService {
+    name: string;
+    helmReleaseName: string;
+    description: string;
+    namespace: string;
+    healthPath?: string;
+    gatewayUrl?: string;
+    chartPath?: string;
+    installArgs?: string[];
+    k8sServiceName?: string;
+    k8sServicePort?: number;
+    k8sPortForwardLocalPort?: number;
+    k8sDeploymentName?: string;
+}
+export interface ServiceCollection {
+    [key: string]: ArkService;
+}
+export interface ArkDependency {
+    name: string;
+    command: string;
+    args: string[];
+    description: string;
+}
+export interface DependencyCollection {
+    [key: string]: ArkDependency;
+}
+/**
+ * Dependencies that should be installed before ARK services
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export declare const arkDependencies: DependencyCollection;
+/**
+ * Core ARK services with their installation and status check configurations
+ */
+export declare const arkServices: ServiceCollection;
+/**
+ * Get services that can be installed via Helm charts
+ */
+export declare function getInstallableServices(): ServiceCollection;
+/**
+ * Get services that can be checked for status
+ */
+export declare function getStatusCheckableServices(): Record<string, string>;
+/**
+ * Get health check path for a specific service
+ */
+export declare function getHealthPath(serviceName: string): string;

package/dist/arkServices.js

@@ -0,0 +1,153 @@
+/**
+ * Centralized ARK service definitions used by both install and status commands
+ */
+const LOCALHOST_GATEWAY_PORT = 8080;
+const REGISTRY_BASE = 'oci://ghcr.io/mckinsey/agents-at-scale-ark/charts';
+/**
+ * Dependencies that should be installed before ARK services
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export const arkDependencies = {
+    'cert-manager-repo': {
+        name: 'cert-manager-repo',
+        command: 'helm',
+        args: [
+            'repo',
+            'add',
+            'jetstack',
+            'https://charts.jetstack.io',
+            '--force-update',
+        ],
+        description: 'Add Jetstack Helm repository',
+    },
+    'helm-repo-update': {
+        name: 'helm-repo-update',
+        command: 'helm',
+        args: ['repo', 'update'],
+        description: 'Update Helm repositories',
+    },
+    'cert-manager': {
+        name: 'cert-manager',
+        command: 'helm',
+        args: [
+            'upgrade',
+            '--install',
+            'cert-manager',
+            'jetstack/cert-manager',
+            '--namespace',
+            'cert-manager',
+            '--create-namespace',
+            '--set',
+            'crds.enabled=true',
+        ],
+        description: 'Certificate management for Kubernetes',
+    },
+    'gateway-api-crds': {
+        name: 'gateway-api-crds',
+        command: 'kubectl',
+        args: [
+            'apply',
+            '-f',
+            'https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml',
+        ],
+        description: 'Gateway API CRDs',
+    },
+};
+/**
+ * Core ARK services with their installation and status check configurations
+ */
+export const arkServices = {
+    'ark-controller': {
+        name: 'ark-controller',
+        helmReleaseName: 'ark-controller',
+        description: 'Core ARK controller for managing AI resources',
+        namespace: 'ark-system',
+        chartPath: `${REGISTRY_BASE}/ark-controller`,
+        installArgs: ['--create-namespace', '--set', 'rbac.enable=true'],
+        k8sDeploymentName: 'ark-controller',
+    },
+    'ark-api': {
+        name: 'ark-api',
+        helmReleaseName: 'ark-api',
+        description: 'ARK API service for interacting with ARK resources',
+        namespace: 'default',
+        healthPath: '/health',
+        gatewayUrl: `http://ark-api.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        chartPath: `${REGISTRY_BASE}/ark-api`,
+        installArgs: [],
+        k8sServiceName: 'ark-api',
+        k8sServicePort: 80,
+        k8sPortForwardLocalPort: 34780,
+        k8sDeploymentName: 'ark-api',
+    },
+    'ark-dashboard': {
+        name: 'ark-dashboard',
+        helmReleaseName: 'ark-dashboard',
+        description: 'Web-based dashboard for ARK',
+        namespace: 'default',
+        healthPath: '',
+        gatewayUrl: `http://dashboard.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        chartPath: `${REGISTRY_BASE}/ark-dashboard`,
+        installArgs: [],
+        k8sServiceName: 'ark-dashboard',
+        k8sServicePort: 3000,
+        k8sPortForwardLocalPort: 3274,
+        k8sDeploymentName: 'ark-dashboard',
+    },
+    'ark-api-a2a': {
+        name: 'ark-api-a2a',
+        helmReleaseName: 'ark-api-a2a',
+        description: 'ARK API agent-to-agent communication service',
+        namespace: 'default',
+        healthPath: '/health',
+        gatewayUrl: `http://ark-api-a2a.127.0.0.1.nip.io:${LOCALHOST_GATEWAY_PORT}`,
+        // Note: This service might be installed as part of ark-api or separately
+    },
+    'ark-mcp': {
+        name: 'ark-mcp',
+        helmReleaseName: 'ark-mcp',
+        description: 'MCP (Model Context Protocol) services for ARK',
+        namespace: 'default',
+        chartPath: `${REGISTRY_BASE}/ark-mcp`,
+        installArgs: [],
+    },
+    'localhost-gateway': {
+        name: 'localhost-gateway',
+        helmReleaseName: 'localhost-gateway',
+        description: 'Gateway for local cluster access',
+        namespace: 'ark-system',
+        chartPath: `${REGISTRY_BASE}/localhost-gateway`,
+        installArgs: [],
+    },
+};
+/**
+ * Get services that can be installed via Helm charts
+ */
+export function getInstallableServices() {
+    const installable = {};
+    for (const [key, service] of Object.entries(arkServices)) {
+        if (service.chartPath) {
+            installable[key] = service;
+        }
+    }
+    return installable;
+}
+/**
+ * Get services that can be checked for status
+ */
+export function getStatusCheckableServices() {
+    const statusServices = {};
+    for (const [key, service] of Object.entries(arkServices)) {
+        if (service.gatewayUrl) {
+            statusServices[key] = service.gatewayUrl;
+        }
+    }
+    return statusServices;
+}
+/**
+ * Get health check path for a specific service
+ */
+export function getHealthPath(serviceName) {
+    const service = arkServices[serviceName];
+    return service?.healthPath || '';
+}

package/dist/charts/charts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use arkServices.ts instead. This file is kept for backward compatibility.
+ * Charts are now defined in arkServices.ts with comprehensive service definitions.
+ */
+export declare const charts: import("../arkServices.js").ServiceCollection;

package/dist/charts/charts.js

@@ -0,0 +1,6 @@
+import { getInstallableServices } from '../arkServices.js';
+/**
+ * @deprecated Use arkServices.ts instead. This file is kept for backward compatibility.
+ * Charts are now defined in arkServices.ts with comprehensive service definitions.
+ */
+export const charts = getInstallableServices();

package/dist/charts/dependencies.d.ts

@@ -0,0 +1,6 @@
+import { DependencyCollection } from './types.js';
+/**
+ * Dependencies that should be installed before ARK charts
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export declare const dependencies: DependencyCollection;

package/dist/charts/dependencies.js

@@ -0,0 +1,50 @@
+/**
+ * Dependencies that should be installed before ARK charts
+ * Note: Dependencies will be installed in the order they are defined here
+ */
+export const dependencies = {
+    'cert-manager-repo': {
+        name: 'cert-manager-repo',
+        command: 'helm',
+        args: [
+            'repo',
+            'add',
+            'jetstack',
+            'https://charts.jetstack.io',
+            '--force-update',
+        ],
+        description: 'Add Jetstack Helm repository',
+    },
+    'helm-repo-update': {
+        name: 'helm-repo-update',
+        command: 'helm',
+        args: ['repo', 'update'],
+        description: 'Update Helm repositories',
+    },
+    'cert-manager': {
+        name: 'cert-manager',
+        command: 'helm',
+        args: [
+            'upgrade',
+            '--install',
+            'cert-manager',
+            'jetstack/cert-manager',
+            '--namespace',
+            'cert-manager',
+            '--create-namespace',
+            '--set',
+            'crds.enabled=true',
+        ],
+        description: 'Certificate management for Kubernetes',
+    },
+    'gateway-api-crds': {
+        name: 'gateway-api-crds',
+        command: 'kubectl',
+        args: [
+            'apply',
+            '-f',
+            'https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.3.0/standard-install.yaml',
+        ],
+        description: 'Gateway API CRDs',
+    },
+};

package/dist/charts/types.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Represents a Helm chart configuration for ARK components
+ */
+export interface ArkChart {
+    /** Name of the chart (used as release name) */
+    name: string;
+    /** Full chart path (OCI registry or local path) */
+    chartPath: string;
+    /** Kubernetes namespace to install into */
+    namespace: string;
+    /** Additional arguments to pass to helm (e.g., --create-namespace, --wait, --timeout 300s, --set key=value) */
+    args?: string[];
+    /** Description of what this chart provides */
+    description?: string;
+}
+/**
+ * Collection of ARK charts
+ */
+export interface ChartCollection {
+    [key: string]: ArkChart;
+}
+/**
+ * Represents a dependency that needs to be installed
+ */
+export interface Dependency {
+    /** Name of the dependency */
+    name: string;
+    /** Command to execute (helm, kubectl, etc.) */
+    command: string;
+    /** Arguments to pass to the command */
+    args: string[];
+    /** Description of what this dependency provides */
+    description?: string;
+}
+/**
+ * Collection of dependencies
+ */
+export interface DependencyCollection {
+    [key: string]: Dependency;
+}

package/dist/charts/types.js

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

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

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

package/dist/commands/agents/index.js

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import output from '../../lib/output.js';
+async function listAgents(options) {
+    try {
+        // Use kubectl to get agents
+        const result = await execa('kubectl', ['get', 'agents', '-o', 'json'], {
+            stdio: 'pipe',
+        });
+        const data = JSON.parse(result.stdout);
+        const agents = data.items || [];
+        if (options.output === 'json') {
+            // Output the raw items for JSON format
+            console.log(JSON.stringify(agents, null, 2));
+        }
+        else {
+            if (agents.length === 0) {
+                output.warning('no agents available');
+                return;
+            }
+            // Simple list output - just agent names
+            agents.forEach((agent) => {
+                console.log(agent.metadata.name);
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('the server doesn\'t have a resource type')) {
+            output.error('Agent CRDs not installed. Is the ARK controller running?');
+        }
+        else {
+            output.error('fetching agents:', error instanceof Error ? error.message : error);
+        }
+        process.exit(1);
+    }
+}
+export function createAgentsCommand() {
+    const agentsCommand = new Command('agents');
+    agentsCommand
+        .description('list available agents')
+        .alias('agent')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    // Add list subcommand (same as default action)
+    agentsCommand
+        .command('list')
+        .alias('ls')
+        .description('list all available agents')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    return agentsCommand;
+}

package/dist/commands/agents/selector.d.ts

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

package/dist/commands/agents/selector.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+export function AgentSelector({ arkApiClient, onSelect, onExit, }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [agents, setAgents] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        arkApiClient
+            .getAgents()
+            .then((fetchedAgents) => {
+            setAgents(fetchedAgents);
+            setLoading(false);
+        })
+            .catch((err) => {
+            setError(err.message || 'Failed to fetch agents');
+            setLoading(false);
+        });
+    }, [arkApiClient]);
+    useInput((input, key) => {
+        if (key.escape) {
+            onExit();
+        }
+        else if (key.upArrow || input === 'k') {
+            setSelectedIndex((prev) => (prev === 0 ? agents.length - 1 : prev - 1));
+        }
+        else if (key.downArrow || input === 'j') {
+            setSelectedIndex((prev) => (prev === agents.length - 1 ? 0 : prev + 1));
+        }
+        else if (key.return) {
+            onSelect(agents[selectedIndex]);
+        }
+        else {
+            // Handle number keys for quick selection
+            const num = parseInt(input, 10);
+            if (!isNaN(num) && num >= 1 && num <= agents.length) {
+                onSelect(agents[num - 1]);
+            }
+        }
+    });
+    if (loading) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "Loading agents..." }) }));
+    }
+    if (error) {
+        return (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", error] }) }));
+    }
+    if (agents.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { children: "No agents available" }) }));
+    }
+    const selectedAgent = agents[selectedIndex];
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 2, paddingY: 1, children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Select Agent" }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { dimColor: true, children: "Choose an agent to start a conversation with" }) }), _jsx(Box, { flexDirection: "column", children: agents.map((agent, index) => (_jsx(Box, { marginBottom: 0, children: _jsxs(Text, { color: index === selectedIndex ? 'green' : undefined, children: [index === selectedIndex ? '❯ ' : '  ', index + 1, ". ", agent.name] }) }, agent.name))) }), selectedAgent.description && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: selectedAgent.description }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter to confirm \u00B7 Number to select \u00B7 Esc to exit" }) })] }));
+}

package/dist/commands/agents.d.ts

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

package/dist/commands/agents.js

@@ -0,0 +1,53 @@
+import { Command } from 'commander';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+import output from '../lib/output.js';
+async function listAgents(options) {
+    let proxy;
+    try {
+        proxy = new ArkApiProxy();
+        const arkApiClient = await proxy.start();
+        const agents = await arkApiClient.getAgents();
+        if (options.output === 'json') {
+            console.log(JSON.stringify(agents, null, 2));
+        }
+        else {
+            if (agents.length === 0) {
+                output.warning('no agents available');
+                return;
+            }
+            // Simple list output - just agent names with namespace prefix
+            agents.forEach(agent => {
+                console.log(`agent/${agent.name}`);
+            });
+        }
+    }
+    catch (error) {
+        output.error('fetching agents:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+    finally {
+        if (proxy) {
+            proxy.stop();
+        }
+    }
+}
+export function createAgentsCommand() {
+    const agentsCommand = new Command('agents');
+    agentsCommand
+        .description('list available agents')
+        .alias('agent')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    // Add list subcommand (same as default action)
+    agentsCommand
+        .command('list')
+        .alias('ls')
+        .description('list all available agents')
+        .option('-o, --output <format>', 'output format (json or text)', 'text')
+        .action(async (options) => {
+        await listAgents(options);
+    });
+    return agentsCommand;
+}

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

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

package/dist/commands/chat/index.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from 'commander';
+import { render } from 'ink';
+import ChatUI from '../../components/ChatUI.js';
+import { ArkApiProxy } from '../../lib/arkApiProxy.js';
+import { loadConfig } from '../../lib/config.js';
+import output from '../../lib/output.js';
+export function createChatCommand() {
+    const chatCommand = new Command('chat');
+    chatCommand
+        .description('Start an interactive chat session with ARK agents or models')
+        .argument('[target]', 'Target to connect to (e.g., agent/sample-agent, model/default)')
+        .option('-a, --agent <name>', 'Connect directly to a specific agent')
+        .option('-m, --model <name>', 'Connect directly to a specific model')
+        .action(async (targetArg, options) => {
+        // Determine initial target from argument or options
+        let initialTargetId;
+        if (targetArg) {
+            // Direct target argument (e.g., "agent/sample-agent")
+            initialTargetId = targetArg;
+        }
+        else if (options.agent) {
+            // Agent option
+            initialTargetId = `agent/${options.agent}`;
+        }
+        else if (options.model) {
+            // Model option
+            initialTargetId = `model/${options.model}`;
+        }
+        // Load config
+        const config = loadConfig();
+        // Initialize proxy first - no spinner, just let ChatUI handle loading state
+        try {
+            const proxy = new ArkApiProxy();
+            const arkApiClient = await proxy.start();
+            // Pass the initialized client and config to ChatUI
+            render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
+        }
+        catch (error) {
+            output.error(error instanceof Error ? error.message : 'ARK API connection failed');
+            process.exit(1);
+        }
+    });
+    return chatCommand;
+}

package/dist/commands/chat.d.ts

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

package/dist/commands/chat.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Command } from 'commander';
+import { render } from 'ink';
+import ChatUI from '../components/ChatUI.js';
+import { ArkApiProxy } from '../lib/arkApiProxy.js';
+import { loadConfig } from '../lib/config.js';
+import output from '../lib/output.js';
+export function createChatCommand() {
+    const chatCommand = new Command('chat');
+    chatCommand
+        .description('Start an interactive chat session with ARK agents or models')
+        .argument('[target]', 'Target to connect to (e.g., agent/sample-agent, model/default)')
+        .option('-a, --agent <name>', 'Connect directly to a specific agent')
+        .option('-m, --model <name>', 'Connect directly to a specific model')
+        .action(async (targetArg, options) => {
+        // Determine initial target from argument or options
+        let initialTargetId;
+        if (targetArg) {
+            // Direct target argument (e.g., "agent/sample-agent")
+            initialTargetId = targetArg;
+        }
+        else if (options.agent) {
+            // Agent option
+            initialTargetId = `agent/${options.agent}`;
+        }
+        else if (options.model) {
+            // Model option
+            initialTargetId = `model/${options.model}`;
+        }
+        // Load config
+        const config = loadConfig();
+        // Initialize proxy first - no spinner, just let ChatUI handle loading state
+        try {
+            const proxy = new ArkApiProxy();
+            const arkApiClient = await proxy.start();
+            // Pass the initialized client and config to ChatUI
+            render(_jsx(ChatUI, { initialTargetId: initialTargetId, arkApiClient: arkApiClient, arkApiProxy: proxy, config: config }));
+        }
+        catch (error) {
+            output.error(error instanceof Error ? error.message : 'ARK API connection failed');
+            process.exit(1);
+        }
+    });
+    return chatCommand;
+}

package/dist/commands/cluster/get.d.ts

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

package/dist/commands/cluster/get.js

@@ -0,0 +1,39 @@
+import { Command } from 'commander';
+import output from '../../lib/output.js';
+import { getClusterInfo } from '../../lib/cluster.js';
+export function createGetCommand() {
+    const get = new Command('get');
+    get
+        .description('get current kubernetes cluster information')
+        .option('-c, --context <context>', 'kubernetes context to use')
+        .option('-o, --output <format>', 'output format (text|json)', 'text')
+        .action(async (options) => {
+        try {
+            const clusterInfo = await getClusterInfo(options.context);
+            if (clusterInfo.error) {
+                output.error('getting cluster info:', clusterInfo.error);
+                process.exit(1);
+            }
+            if (options.output === 'json') {
+                console.log(JSON.stringify({
+                    context: clusterInfo.context,
+                    namespace: clusterInfo.namespace,
+                    type: clusterInfo.type,
+                    ip: clusterInfo.ip,
+                }, null, 2));
+            }
+            else {
+                // Text format (default)
+                console.log(`context: ${clusterInfo.context}`);
+                console.log(`namespace: ${clusterInfo.namespace}`);
+                console.log(`type: ${clusterInfo.type}`);
+                console.log(`ip: ${clusterInfo.ip || 'unknown'}`);
+            }
+        }
+        catch (error) {
+            output.error('failed to get cluster info:', error instanceof Error ? error.message : 'Unknown error');
+            process.exit(1);
+        }
+    });
+    return get;
+}

package/dist/commands/cluster/index.js

@@ -1,10 +1,8 @@
 import { Command } from 'commander';
-import { createGetIpCommand } from './get-ip.js';
-import { createGetTypeCommand } from './get-type.js';
+import { createGetCommand } from './get.js';
 export function createClusterCommand() {
     const cluster = new Command('cluster');
     cluster.description('Cluster management commands');
-    cluster.addCommand(createGetTypeCommand());
-    cluster.addCommand(createGetIpCommand());
+    cluster.addCommand(createGetCommand());
     return cluster;
 }

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

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