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

package/dist/lib/startup.spec.js

@@ -0,0 +1,152 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+// Mock chalk to avoid ANSI codes in tests
+jest.unstable_mockModule('chalk', () => ({
+    default: {
+        red: (str) => str,
+        yellow: (str) => str,
+        gray: (str) => str,
+        blue: (str) => str,
+    },
+}));
+// Mock commands module
+jest.unstable_mockModule('./commands.js', () => ({
+    checkCommandExists: jest.fn(),
+}));
+// Mock config module
+jest.unstable_mockModule('./config.js', () => ({
+    loadConfig: jest.fn(),
+}));
+// Mock execa module
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mocks
+const { checkCommandExists } = await import('./commands.js');
+const { loadConfig } = await import('./config.js');
+const { execa } = await import('execa');
+const { startup } = await import('./startup.js');
+// Type the mocks
+const mockCheckCommandExists = checkCommandExists;
+const mockLoadConfig = loadConfig;
+const mockExeca = execa;
+describe('startup', () => {
+    let mockExit;
+    let mockConsoleError;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock execa to reject by default (no kubectl context)
+        mockExeca.mockRejectedValue(new Error('No context'));
+        mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+            throw new Error('process.exit');
+        });
+        mockConsoleError = jest
+            .spyOn(console, 'error')
+            .mockImplementation(() => { });
+    });
+    afterEach(() => {
+        mockExit.mockRestore();
+        mockConsoleError.mockRestore();
+    });
+    it('returns config when all required commands are installed', async () => {
+        const expectedConfig = {
+            chat: {
+                streaming: true,
+                outputFormat: 'text',
+            },
+        };
+        // Mock all commands as available
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue(expectedConfig);
+        const config = await startup();
+        expect(config).toEqual(expectedConfig);
+        expect(mockCheckCommandExists).toHaveBeenCalledWith('kubectl', [
+            'version',
+            '--client',
+        ]);
+        expect(mockCheckCommandExists).toHaveBeenCalledWith('helm', [
+            'version',
+            '--short',
+        ]);
+        expect(mockLoadConfig).toHaveBeenCalledTimes(1);
+        expect(mockExit).not.toHaveBeenCalled();
+    });
+    it('exits with error when kubectl is missing', async () => {
+        // Mock kubectl as missing, helm as available
+        mockCheckCommandExists
+            .mockResolvedValueOnce(false) // kubectl
+            .mockResolvedValueOnce(true); // helm
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits with error when helm is missing', async () => {
+        // Mock kubectl as available, helm as missing
+        mockCheckCommandExists
+            .mockResolvedValueOnce(true) // kubectl
+            .mockResolvedValueOnce(false); // helm
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('exits with error when both commands are missing', async () => {
+        // Mock both commands as missing
+        mockCheckCommandExists.mockResolvedValue(false);
+        await expect(startup()).rejects.toThrow('process.exit');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: kubectl is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://kubernetes.io/docs/tasks/tools/');
+        expect(mockConsoleError).toHaveBeenCalledWith('error: helm is required');
+        expect(mockConsoleError).toHaveBeenCalledWith('  https://helm.sh/docs/intro/install/');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('checks commands with correct arguments', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue({ chat: {} });
+        await startup();
+        expect(mockCheckCommandExists).toHaveBeenCalledTimes(2);
+        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(1, 'kubectl', [
+            'version',
+            '--client',
+        ]);
+        expect(mockCheckCommandExists).toHaveBeenNthCalledWith(2, 'helm', [
+            'version',
+            '--short',
+        ]);
+    });
+    it('loads config after checking requirements', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        const expectedConfig = { chat: { streaming: false } };
+        mockLoadConfig.mockReturnValue(expectedConfig);
+        const config = await startup();
+        // Verify order - checkCommandExists should be called before loadConfig
+        const checkCallOrder = mockCheckCommandExists.mock.invocationCallOrder[0];
+        const loadCallOrder = mockLoadConfig.mock.invocationCallOrder[0];
+        expect(checkCallOrder).toBeLessThan(loadCallOrder);
+        expect(config).toEqual(expectedConfig);
+    });
+    it('includes cluster context when available', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue({ chat: { streaming: true } });
+        // Mock successful kubectl context check
+        mockExeca.mockResolvedValue({
+            stdout: 'minikube',
+            stderr: '',
+        });
+        const config = await startup();
+        expect(config.clusterInfo).toEqual({
+            type: 'unknown',
+            context: 'minikube',
+        });
+        expect(mockExeca).toHaveBeenCalledWith('kubectl', ['config', 'current-context']);
+    });
+    it('handles missing kubectl context gracefully', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        const expectedConfig = { chat: { streaming: false } };
+        mockLoadConfig.mockReturnValue(expectedConfig);
+        // mockExeca already mocked to reject in beforeEach
+        const config = await startup();
+        expect(config).toEqual(expectedConfig);
+        expect(config.clusterInfo).toBeUndefined();
+    });
+});

package/dist/lib/types.d.ts

@@ -13,25 +13,109 @@ export interface KubernetesConfig {
     namespace?: string;
     inCluster: boolean;
 }
-export interface ServiceStatus {
+export type DeploymentStatus = 'available' | 'progressing' | 'replicafailure' | 'failed' | 'not found' | 'unknown';
+export type ServiceStatus = {
     name: string;
-    status: 'healthy' | 'unhealthy' | 'not installed';
+    status: 'healthy' | 'warning' | 'unhealthy' | 'not installed' | 'not ready';
+    deploymentStatus?: DeploymentStatus;
     url?: string;
     version?: string;
+    revision?: string;
     details?: string;
-}
+    isDev?: boolean;
+    namespace?: string;
+};
 export interface DependencyStatus {
     name: string;
     installed: boolean;
     version?: string;
     details?: string;
 }
+export interface ModelStatus {
+    exists: boolean;
+    available?: boolean;
+    provider?: string;
+    details?: string;
+}
 export interface StatusData {
     services: ServiceStatus[];
     dependencies: DependencyStatus[];
+    arkReady?: boolean;
+    defaultModelExists?: boolean;
+    defaultModel?: ModelStatus;
 }
 export interface CommandVersionConfig {
     command: string;
     versionArgs: string;
     versionExtract: (_output: string) => string;
 }
+export interface K8sMetadata {
+    name: string;
+    namespace?: string;
+}
+export interface K8sCondition {
+    type: string;
+    status: string;
+    message?: string;
+}
+export interface K8sListResource<T> {
+    items: T[];
+}
+export interface HelmRelease {
+    name: string;
+    app_version?: string;
+    revision?: string;
+}
+export interface K8sDeployment {
+    metadata: K8sMetadata;
+    spec?: {
+        replicas?: number;
+    };
+    status?: {
+        readyReplicas?: number;
+        availableReplicas?: number;
+        conditions?: K8sCondition[];
+    };
+}
+export interface Model {
+    metadata: K8sMetadata;
+    status?: ModelStatus;
+}
+export interface Agent {
+    metadata: K8sMetadata;
+}
+export interface Team {
+    metadata: K8sMetadata;
+}
+export interface QueryTarget {
+    type: string;
+    name: string;
+}
+export interface QueryResponse {
+    content?: string;
+}
+export interface Query {
+    apiVersion: string;
+    kind: 'Query';
+    metadata: K8sMetadata;
+    spec?: {
+        input: string;
+        targets: QueryTarget[];
+    };
+    status?: {
+        phase?: 'initializing' | 'running' | 'done' | 'error' | 'canceled';
+        conditions?: K8sCondition[];
+        responses?: QueryResponse[];
+        message?: string;
+        error?: string;
+    };
+}
+export interface Tool {
+    metadata: K8sMetadata;
+}
+export interface ClusterInfo {
+    context?: string;
+    cluster?: string;
+    user?: string;
+    namespace?: string;
+}

package/dist/lib/versions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Version information for ARK
+ */
+export interface ArkVersionInfo {
+    current?: string;
+    latest?: string;
+    updateAvailable?: boolean;
+}
+/**
+ * Fetch the latest ARK version from GitHub releases
+ * @returns Latest version string or undefined if fetch fails
+ */
+export declare function fetchLatestVersion(): Promise<string | undefined>;
+/**
+ * Get current installed ARK version from Helm
+ * @returns Current version string or undefined if not found
+ */
+export declare function fetchCurrentVersion(): Promise<string | undefined>;
+/**
+ * Fetch both current and latest versions in parallel
+ * @returns Version information
+ */
+export declare function fetchVersionInfo(): Promise<ArkVersionInfo>;

package/dist/lib/versions.js

@@ -0,0 +1,51 @@
+import { execa } from 'execa';
+import { arkServices } from '../arkServices.js';
+/**
+ * Fetch the latest ARK version from GitHub releases
+ * @returns Latest version string or undefined if fetch fails
+ */
+export async function fetchLatestVersion() {
+    try {
+        const response = await fetch('https://api.github.com/repos/mckinsey/agents-at-scale-ark/releases/latest');
+        if (response.ok) {
+            const data = (await response.json());
+            // Remove 'v' prefix if present for consistent comparison
+            return data.tag_name.replace(/^v/, '');
+        }
+    }
+    catch {
+        // Silently fail
+    }
+    return undefined;
+}
+/**
+ * Get current installed ARK version from Helm
+ * @returns Current version string or undefined if not found
+ */
+export async function fetchCurrentVersion() {
+    try {
+        const controller = arkServices['ark-controller'];
+        const { stdout } = await execa('helm', ['list', '-n', controller.namespace, '-o', 'json'], { stdio: 'pipe' });
+        const releases = JSON.parse(stdout);
+        const arkController = releases.find((r) => r.name === controller.helmReleaseName);
+        return arkController?.app_version;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fetch both current and latest versions in parallel
+ * @returns Version information
+ */
+export async function fetchVersionInfo() {
+    const [current, latest] = await Promise.all([
+        fetchCurrentVersion(),
+        fetchLatestVersion(),
+    ]);
+    return {
+        current,
+        latest,
+        updateAvailable: current && latest ? current !== latest : undefined,
+    };
+}

package/dist/types/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/types/types.js

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

package/dist/ui/AgentSelector.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/ui/AgentSelector.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/ui/MainMenu.d.ts

@@ -1,3 +1,7 @@
 import * as React from 'react';
-declare const MainMenu: React.FC;
+import type { ArkConfig } from '../lib/config.js';
+interface MainMenuProps {
+    config: ArkConfig;
+}
+declare const MainMenu: React.FC<MainMenuProps>;
 export default MainMenu;