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

package/dist/lib/output.spec.js

@@ -0,0 +1,123 @@
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import chalk from 'chalk';
+import output from './output.js';
+describe('output', () => {
+    let consoleErrorSpy;
+    let consoleLogSpy;
+    beforeEach(() => {
+        consoleErrorSpy = jest
+            .spyOn(console, 'error')
+            .mockImplementation(() => undefined);
+        consoleLogSpy = jest
+            .spyOn(console, 'log')
+            .mockImplementation(() => undefined);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('error', () => {
+        it('should output error message with red cross and prefix', () => {
+            output.error('Something went wrong');
+            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('error:'), 'Something went wrong');
+        });
+        it('should handle additional arguments', () => {
+            const error = new Error('Test error');
+            output.error('Failed to connect', error, 123);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('error:'), 'Failed to connect', error, 123);
+        });
+    });
+    describe('success', () => {
+        it('should output success message with green checkmark', () => {
+            output.success('Operation completed');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Operation completed');
+        });
+        it('should handle additional arguments', () => {
+            output.success('Deployed', 'v1.0.0', { status: 'ok' });
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Deployed', 'v1.0.0', { status: 'ok' });
+        });
+    });
+    describe('info', () => {
+        it('should output info message in gray', () => {
+            output.info('Processing request...');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.gray('Processing request...'));
+        });
+        it('should handle additional arguments', () => {
+            output.info('Status:', 'running', 42);
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.gray('Status:'), 'running', 42);
+        });
+    });
+    describe('warning', () => {
+        it('should output warning message with yellow exclamation and prefix', () => {
+            output.warning('Resource limit approaching');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('warning:'), 'Resource limit approaching');
+        });
+        it('should handle additional arguments', () => {
+            const details = { cpu: '85%', memory: '92%' };
+            output.warning('High resource usage', details);
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('warning:'), 'High resource usage', details);
+        });
+    });
+    describe('statusCheck', () => {
+        it('should display found status with value and details', () => {
+            output.statusCheck('found', 'platform', 'python3', 'v3.10');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('platform')} ${chalk.bold.white('python3')}${chalk.gray(' v3.10')}`);
+        });
+        it('should display found status with value only', () => {
+            output.statusCheck('found', 'fastmcp', 'v0.1.0');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('fastmcp')} ${chalk.bold.white('v0.1.0')}`);
+        });
+        it('should display found status with label only', () => {
+            output.statusCheck('found', '3 tools');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.green('✓')} ${chalk.green('3 tools')}`);
+        });
+        it('should display missing status with details', () => {
+            output.statusCheck('missing', 'fastmcp', undefined, 'not in dependencies');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.yellow('?')} ${chalk.yellow('fastmcp')}${chalk.gray(' not in dependencies')}`);
+        });
+        it('should display warning status', () => {
+            output.statusCheck('warning', 'version', '0.0.1', 'pre-release');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.yellow('!')} ${chalk.yellow('version')} ${chalk.bold.white('0.0.1')}${chalk.gray(' pre-release')}`);
+        });
+        it('should display error status', () => {
+            output.statusCheck('error', 'tools', undefined, 'discovery failed');
+            expect(consoleLogSpy).toHaveBeenCalledWith(`  ${chalk.red('✗')} ${chalk.red('tools')}${chalk.gray(' discovery failed')}`);
+        });
+    });
+    describe('section', () => {
+        it('should display section header with colon', () => {
+            output.section('dev-tests');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.cyan.bold('dev-tests:'));
+        });
+        it('should display section header with custom text', () => {
+            output.section('ark services');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.cyan.bold('ark services:'));
+        });
+    });
+    describe('statusMessage', () => {
+        it('should output success status with title and message', () => {
+            output.statusMessage('success', 'fastmcp', 'installed (v0.1.0)');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), chalk.green('fastmcp:'), 'installed (v0.1.0)');
+        });
+        it('should output warning status with title and message', () => {
+            output.statusMessage('warning', 'virtual environment', 'not found');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.yellow.bold('!'), chalk.yellow('virtual environment:'), 'not found');
+        });
+        it('should output error status with title and message', () => {
+            output.statusMessage('error', 'fastmcp', 'not found in dependencies');
+            expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red('✗'), chalk.red('fastmcp:'), 'not found in dependencies');
+        });
+        it('should output info status with title and message', () => {
+            output.statusMessage('info', 'platform', 'python3');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.blue('ℹ'), chalk.blue('platform:'), 'python3');
+        });
+        it('should handle title-only messages', () => {
+            output.statusMessage('success', 'Operation completed');
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.green('✓'), 'Operation completed');
+        });
+        it('should handle additional arguments', () => {
+            const extra = { version: '1.0' };
+            output.statusMessage('info', 'status', 'running', extra, 42);
+            expect(consoleLogSpy).toHaveBeenCalledWith(chalk.blue('ℹ'), chalk.blue('status:'), 'running', extra, 42);
+        });
+    });
+});

package/dist/lib/portUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if a port is available
+ */
+export declare function isPortAvailable(port: number): Promise<boolean>;
+/**
+ * Find an available port, starting from the preferred port
+ */
+export declare function findAvailablePort(preferredPort: number, maxAttempts?: number): Promise<number>;

package/dist/lib/portUtils.js

@@ -0,0 +1,39 @@
+import net from 'net';
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                resolve(false);
+            }
+            else {
+                resolve(false);
+            }
+        });
+        server.once('listening', () => {
+            server.close();
+            resolve(true);
+        });
+        server.listen(port, '127.0.0.1');
+    });
+}
+/**
+ * Find an available port, starting from the preferred port
+ */
+export async function findAvailablePort(preferredPort, maxAttempts = 10) {
+    // First try the preferred port
+    if (await isPortAvailable(preferredPort)) {
+        return preferredPort;
+    }
+    // Try random ports
+    for (let i = 0; i < maxAttempts; i++) {
+        const randomPort = Math.floor(Math.random() * (65535 - 1024) + 1024);
+        if (await isPortAvailable(randomPort)) {
+            return randomPort;
+        }
+    }
+    throw new Error(`Could not find an available port after ${maxAttempts} attempts`);
+}

package/dist/lib/startup.d.ts

@@ -0,0 +1,5 @@
+import type { ArkConfig } from './config.js';
+/**
+ * Initialize the CLI by checking requirements and loading config
+ */
+export declare function startup(): Promise<ArkConfig>;

package/dist/lib/startup.js

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { checkCommandExists } from './commands.js';
+import { loadConfig } from './config.js';
+import { getArkVersion } from './arkStatus.js';
+const REQUIRED_COMMANDS = [
+    {
+        name: 'kubectl',
+        command: 'kubectl',
+        args: ['version', '--client'],
+        installUrl: 'https://kubernetes.io/docs/tasks/tools/',
+    },
+    {
+        name: 'helm',
+        command: 'helm',
+        args: ['version', '--short'],
+        installUrl: 'https://helm.sh/docs/intro/install/',
+    },
+];
+async function checkRequirements() {
+    const missing = [];
+    for (const cmd of REQUIRED_COMMANDS) {
+        const exists = await checkCommandExists(cmd.command, cmd.args);
+        if (!exists) {
+            missing.push(cmd);
+        }
+    }
+    if (missing.length > 0) {
+        for (const cmd of missing) {
+            console.error(chalk.red('error:') + ` ${cmd.name} is required`);
+            console.error('  ' + chalk.blue(cmd.installUrl));
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Fetch version information (non-blocking)
+ */
+async function fetchVersionInfo(config) {
+    // Fetch latest version from GitHub
+    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
+            config.latestVersion = data.tag_name.replace(/^v/, '');
+        }
+    }
+    catch {
+        // Silently fail - latestVersion will remain undefined
+    }
+    // Fetch current installed version (already without 'v' from helm)
+    try {
+        const currentVersion = await getArkVersion();
+        if (currentVersion) {
+            config.currentVersion = currentVersion;
+        }
+    }
+    catch {
+        // Silently fail - currentVersion will remain undefined
+    }
+}
+/**
+ * Initialize the CLI by checking requirements and loading config
+ */
+export async function startup() {
+    // Check required commands
+    await checkRequirements();
+    // Load config
+    const config = loadConfig();
+    // Fetch version info synchronously so it's available immediately
+    await fetchVersionInfo(config);
+    return config;
+}

package/dist/lib/startup.spec.d.ts

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

package/dist/lib/startup.spec.js

@@ -0,0 +1,168 @@
+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(),
+}));
+// Dynamic imports after mocks
+const { checkCommandExists } = await import('./commands.js');
+const { loadConfig } = await import('./config.js');
+const { startup } = await import('./startup.js');
+// Type the mocks
+const mockCheckCommandExists = checkCommandExists;
+const mockLoadConfig = loadConfig;
+// Mock fetch globally
+globalThis.fetch = jest.fn();
+describe('startup', () => {
+    let mockExit;
+    let mockConsoleError;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        globalThis.fetch.mockClear();
+        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);
+    });
+    describe('version fetching', () => {
+        beforeEach(() => {
+            // Setup successful requirements check and config
+            mockCheckCommandExists.mockResolvedValue(true);
+            mockLoadConfig.mockReturnValue({ chat: { streaming: true } });
+        });
+        it('fetches latest version from GitHub API', async () => {
+            globalThis.fetch.mockResolvedValue({
+                ok: true,
+                json: async () => ({ tag_name: 'v0.1.35' }),
+            });
+            const config = await startup();
+            expect(globalThis.fetch).toHaveBeenCalledWith('https://api.github.com/repos/mckinsey/agents-at-scale-ark/releases/latest');
+            // Wait for async fetch to complete
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            expect(config.latestVersion).toBe('v0.1.35');
+        });
+        it('handles GitHub API failure gracefully', async () => {
+            globalThis.fetch.mockRejectedValue(new Error('Network error'));
+            const config = await startup();
+            // Wait for async fetch attempt
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // Should not have latestVersion set
+            expect(config.latestVersion).toBeUndefined();
+        });
+        it('handles non-OK response from GitHub API', async () => {
+            globalThis.fetch.mockResolvedValue({
+                ok: false,
+                status: 403,
+            });
+            const config = await startup();
+            // Wait for async fetch to complete
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            // Should not have latestVersion set
+            expect(config.latestVersion).toBeUndefined();
+        });
+        it('continues startup even if version fetch fails', async () => {
+            globalThis.fetch.mockRejectedValue(new Error('API Error'));
+            const config = await startup();
+            // Startup should complete successfully
+            expect(config).toBeDefined();
+            expect(config.chat).toBeDefined();
+            expect(mockExit).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/lib/types.d.ts

@@ -22,6 +22,8 @@ export type ServiceStatus = {
     version?: string;
     revision?: string;
     details?: string;
+    isDev?: boolean;
+    namespace?: string;
 };
 export interface DependencyStatus {
     name: string;

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;