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

package/dist/components/StatusView.d.ts

@@ -1,10 +0,0 @@
-import * as React from 'react';
-import { StatusData } from '../lib/types.js';
-interface StatusViewProps {
-    statusData: StatusData | null;
-    isLoading: boolean;
-    error: string | null;
-    onBack: () => void;
-}
-declare const StatusView: React.FC<StatusViewProps>;
-export default StatusView;

package/dist/components/StatusView.js

@@ -1,39 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text, useInput } from 'ink';
-const StatusView = ({ statusData, isLoading, error, onBack, }) => {
-    useInput((input, key) => {
-        if (key.escape || input === 'q' || key.return) {
-            onBack();
-        }
-    });
-    const renderServiceStatus = (service) => {
-        const statusColor = service.status === 'healthy'
-            ? 'green'
-            : service.status === 'unhealthy'
-                ? 'red'
-                : 'yellow';
-        const statusIcon = service.status === 'healthy'
-            ? '✓'
-            : service.status === 'unhealthy'
-                ? '✗'
-                : '?';
-        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [service.name, ": "] }), _jsx(Text, { color: statusColor, children: service.status })] }), service.url && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["URL: ", service.url] }) })), service.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: service.details }) }))] }, service.name));
-    };
-    const renderDependencyStatus = (dep) => {
-        const statusColor = dep.installed ? 'green' : 'red';
-        const statusIcon = dep.installed ? '✓' : '✗';
-        const statusText = dep.installed ? 'installed' : 'missing';
-        return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsxs(Text, { bold: true, children: [dep.name, ": "] }), _jsx(Text, { color: statusColor, children: statusText })] }), dep.version && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "gray", children: ["Version: ", dep.version] }) })), dep.details && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", children: dep.details }) }))] }, dep.name));
-    };
-    if (isLoading) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "yellow", children: "\uD83D\uDD0D Checking ARK system status..." }), _jsx(Text, { color: "gray", children: "Please wait while we verify services and dependencies." })] }));
-    }
-    if (error) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u274C Error checking status:" }), _jsx(Text, { color: "red", children: error }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
-    }
-    if (!statusData) {
-        return null;
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDD0D ARK System Status" }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDCE1 ARK Services:" }) }), statusData.services.map(renderServiceStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "cyan", bold: true, children: "\uD83D\uDEE0\uFE0F System Dependencies:" }) }), statusData.dependencies.map(renderDependencyStatus), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Press ESC, 'q', or Enter to return to menu..." }) })] }));
-};
-export default StatusView;

package/dist/lib/arkApiClient.d.ts

@@ -1,53 +0,0 @@
-import OpenAI from 'openai';
-export interface QueryTarget {
-    id: string;
-    name: string;
-    type: 'agent' | 'model' | 'tool' | string;
-    description?: string;
-}
-export interface Agent {
-    name: string;
-    namespace: string;
-    description?: string;
-    model_ref?: string;
-    prompt?: string;
-    status?: string;
-    annotations?: Record<string, string>;
-}
-export interface Model {
-    name: string;
-    namespace: string;
-    type: string;
-    model: string;
-    status: string;
-    annotations?: Record<string, string>;
-}
-export interface Tool {
-    name: string;
-    namespace: string;
-    description?: string;
-    labels?: Record<string, string>;
-    annotations?: Record<string, string>;
-}
-export interface Team {
-    name: string;
-    namespace: string;
-    description?: string;
-    strategy?: string;
-    members_count?: number;
-    status?: string;
-}
-export declare class ArkApiClient {
-    private openai;
-    private baseUrl;
-    private namespace;
-    constructor(arkApiUrl: string, namespace?: string);
-    getBaseUrl(): string;
-    getQueryTargets(): Promise<QueryTarget[]>;
-    getAgents(): Promise<Agent[]>;
-    getModels(): Promise<Model[]>;
-    getTools(): Promise<Tool[]>;
-    getTeams(): Promise<Team[]>;
-    createChatCompletion(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): Promise<OpenAI.Chat.Completions.ChatCompletion>;
-    createChatCompletionStream(params: OpenAI.Chat.Completions.ChatCompletionCreateParams): AsyncIterable<OpenAI.Chat.Completions.ChatCompletionChunk>;
-}

package/dist/lib/arkApiClient.js

@@ -1,102 +0,0 @@
-import OpenAI from 'openai';
-export class ArkApiClient {
-    constructor(arkApiUrl, namespace = 'default') {
-        this.baseUrl = arkApiUrl;
-        this.namespace = namespace;
-        this.openai = new OpenAI({
-            baseURL: `${arkApiUrl}/openai/v1`,
-            apiKey: 'dummy', // ark-api doesn't require an API key
-            dangerouslyAllowBrowser: false,
-        });
-    }
-    getBaseUrl() {
-        return this.baseUrl;
-    }
-    async getQueryTargets() {
-        try {
-            const models = await this.openai.models.list();
-            const targets = models.data.map((model) => {
-                const parts = model.id.split('/');
-                const type = parts[0] || 'model';
-                const name = parts.slice(1).join('/') || model.id;
-                return {
-                    id: model.id,
-                    name,
-                    type,
-                    description: model.id,
-                };
-            });
-            return targets;
-        }
-        catch (error) {
-            throw new Error(`Failed to get query targets: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async getAgents() {
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/agents`);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = (await response.json());
-            return data.items || [];
-        }
-        catch (error) {
-            throw new Error(`Failed to get agents: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async getModels() {
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/models`);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = (await response.json());
-            return data.items || [];
-        }
-        catch (error) {
-            throw new Error(`Failed to get models: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async getTools() {
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/tools`);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = (await response.json());
-            return data.items || [];
-        }
-        catch (error) {
-            throw new Error(`Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async getTeams() {
-        try {
-            const response = await fetch(`${this.baseUrl}/v1/namespaces/${this.namespace}/teams`);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const data = (await response.json());
-            return data.items || [];
-        }
-        catch (error) {
-            throw new Error(`Failed to get teams: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    async createChatCompletion(params) {
-        return (await this.openai.chat.completions.create({
-            ...params,
-            stream: false,
-        }));
-    }
-    async *createChatCompletionStream(params) {
-        const stream = await this.openai.chat.completions.create({
-            ...params,
-            stream: true,
-        });
-        for await (const chunk of stream) {
-            yield chunk;
-        }
-    }
-}

package/dist/lib/arkApiProxy.d.ts

@@ -1,9 +0,0 @@
-import { ArkApiClient } from './arkApiClient.js';
-export declare class ArkApiProxy {
-    private serviceProxy;
-    constructor(localPort?: number);
-    start(): Promise<ArkApiClient>;
-    stop(): void;
-    isRunning(): boolean;
-    getLocalUrl(): string;
-}

package/dist/lib/arkApiProxy.js

@@ -1,22 +0,0 @@
-import { ArkApiClient } from './arkApiClient.js';
-import { ArkServiceProxy } from './arkServiceProxy.js';
-import { arkServices } from '../arkServices.js';
-export class ArkApiProxy {
-    constructor(localPort) {
-        const arkApiService = arkServices['ark-api'];
-        this.serviceProxy = new ArkServiceProxy(arkApiService, localPort);
-    }
-    async start() {
-        const arkApiUrl = await this.serviceProxy.start();
-        return new ArkApiClient(arkApiUrl);
-    }
-    stop() {
-        this.serviceProxy.stop();
-    }
-    isRunning() {
-        return this.serviceProxy.isRunning();
-    }
-    getLocalUrl() {
-        return this.serviceProxy.getLocalUrl();
-    }
-}

package/dist/lib/arkServiceProxy.d.ts

@@ -1,14 +0,0 @@
-import { ArkService } from '../arkServices.js';
-export declare class ArkServiceProxy {
-    private kubectlProcess?;
-    private localPort;
-    private isReady;
-    private service;
-    constructor(service: ArkService, localPort?: number);
-    private getRandomPort;
-    start(): Promise<string>;
-    stop(): void;
-    isRunning(): boolean;
-    getLocalUrl(): string;
-    getService(): ArkService;
-}

package/dist/lib/arkServiceProxy.js

@@ -1,95 +0,0 @@
-import { spawn } from 'child_process';
-export class ArkServiceProxy {
-    constructor(service, localPort) {
-        this.isReady = false;
-        this.service = service;
-        this.localPort =
-            localPort || service.k8sPortForwardLocalPort || this.getRandomPort();
-    }
-    getRandomPort() {
-        return Math.floor(Math.random() * (65535 - 1024) + 1024);
-    }
-    async start() {
-        if (!this.service.k8sServiceName || !this.service.k8sServicePort) {
-            throw new Error(`${this.service.name} service configuration missing k8sServiceName or k8sServicePort`);
-        }
-        return new Promise((resolve, reject) => {
-            const args = [
-                'port-forward',
-                `service/${this.service.k8sServiceName}`,
-                `${this.localPort}:${this.service.k8sServicePort}`,
-            ];
-            // Add namespace flag only if namespace is defined
-            if (this.service.namespace) {
-                args.push('--namespace', this.service.namespace);
-            }
-            this.kubectlProcess = spawn('kubectl', args, {
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let setupComplete = false;
-            const setupTimeout = setTimeout(() => {
-                if (!setupComplete) {
-                    this.stop();
-                    reject(new Error(`${this.service.name} port forward setup timeout`));
-                }
-            }, 10000);
-            this.kubectlProcess.stdout?.on('data', (data) => {
-                const output = data.toString();
-                if (output.includes('Forwarding from') && !setupComplete) {
-                    setupComplete = true;
-                    clearTimeout(setupTimeout);
-                    this.isReady = true;
-                    const localUrl = `http://localhost:${this.localPort}`;
-                    resolve(localUrl);
-                }
-            });
-            this.kubectlProcess.stderr?.on('data', (data) => {
-                const errorOutput = data.toString();
-                if (!setupComplete) {
-                    setupComplete = true;
-                    clearTimeout(setupTimeout);
-                    this.stop();
-                    reject(new Error(`${this.service.name} port forward failed: ${errorOutput.trim()}`));
-                }
-            });
-            this.kubectlProcess.on('error', (error) => {
-                if (!setupComplete) {
-                    setupComplete = true;
-                    clearTimeout(setupTimeout);
-                    reject(new Error(`Failed to start ${this.service.name} port forward: ${error.message}`));
-                }
-            });
-            this.kubectlProcess.on('exit', (code) => {
-                this.isReady = false;
-                if (!setupComplete && code !== 0) {
-                    setupComplete = true;
-                    clearTimeout(setupTimeout);
-                    reject(new Error(`${this.service.name} port forward exited with code ${code}`));
-                }
-            });
-        });
-    }
-    stop() {
-        if (this.kubectlProcess) {
-            // Use SIGTERM for graceful shutdown
-            this.kubectlProcess.kill('SIGTERM');
-            // Give it a second to clean up, then force kill if needed
-            setTimeout(() => {
-                if (this.kubectlProcess && !this.kubectlProcess.killed) {
-                    this.kubectlProcess.kill('SIGKILL');
-                }
-            }, 1000);
-            this.kubectlProcess = undefined;
-        }
-        this.isReady = false;
-    }
-    isRunning() {
-        return this.isReady && this.kubectlProcess !== undefined;
-    }
-    getLocalUrl() {
-        return `http://localhost:${this.localPort}`;
-    }
-    getService() {
-        return this.service;
-    }
-}

package/dist/lib/arkStatus.d.ts

@@ -1,10 +0,0 @@
-/**
- * Get current installed ARK version
- * @returns version string if found, undefined otherwise
- */
-export declare function getArkVersion(): Promise<string | undefined>;
-/**
- * Check if ARK is ready by verifying the ark-controller is running
- * @returns true if ark-controller deployment exists and has ready replicas
- */
-export declare function isArkReady(): Promise<boolean>;

package/dist/lib/arkStatus.js

@@ -1,79 +0,0 @@
-import { execa } from 'execa';
-import { arkServices } from '../arkServices.js';
-/**
- * Get current installed ARK version
- * @returns version string if found, undefined otherwise
- */
-export async function getArkVersion() {
-    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;
-    }
-}
-/**
- * Check if ARK is ready by verifying the ark-controller is running
- * @returns true if ark-controller deployment exists and has ready replicas
- */
-export async function isArkReady() {
-    try {
-        // Check if ark-controller deployment exists and get its status
-        const result = await execa('kubectl', ['get', 'deployment', 'ark-controller', '-n', 'ark-system', '-o', 'json'], { stdio: 'pipe' });
-        const deployment = JSON.parse(result.stdout);
-        const readyReplicas = deployment.status?.readyReplicas || 0;
-        const replicas = deployment.spec?.replicas || 0;
-        // If main deployment has 0 replicas, check devspace deployment
-        if (replicas === 0) {
-            try {
-                const devResult = await execa('kubectl', [
-                    'get',
-                    'deployment',
-                    'ark-controller-devspace',
-                    '-n',
-                    'ark-system',
-                    '-o',
-                    'json',
-                ], { stdio: 'pipe' });
-                const devDeployment = JSON.parse(devResult.stdout);
-                const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
-                const devReplicas = devDeployment.spec?.replicas || 0;
-                // ARK is ready if devspace deployment has ready replicas
-                return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
-            }
-            catch {
-                // Devspace deployment doesn't exist
-                return false;
-            }
-        }
-        // ARK is ready if deployment exists and has at least one ready replica
-        return readyReplicas > 0 && readyReplicas === replicas;
-    }
-    catch {
-        // Main deployment doesn't exist, try devspace deployment
-        try {
-            const devResult = await execa('kubectl', [
-                'get',
-                'deployment',
-                'ark-controller-devspace',
-                '-n',
-                'ark-system',
-                '-o',
-                'json',
-            ], { stdio: 'pipe' });
-            const devDeployment = JSON.parse(devResult.stdout);
-            const devReadyReplicas = devDeployment.status?.readyReplicas || 0;
-            const devReplicas = devDeployment.spec?.replicas || 0;
-            // ARK is ready if devspace deployment has ready replicas
-            return devReadyReplicas > 0 && devReadyReplicas === devReplicas;
-        }
-        catch {
-            // Neither deployment exists or kubectl failed
-            return false;
-        }
-    }
-}

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

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

package/dist/lib/arkStatus.spec.js

@@ -1,49 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals';
-// Mock execa using unstable_mockModule
-jest.unstable_mockModule('execa', () => ({
-    execa: jest.fn(),
-}));
-// Dynamic imports after mock
-const { execa } = await import('execa');
-const { isArkReady } = await import('./arkStatus.js');
-describe('arkStatus with __mocks__', () => {
-    describe('isArkReady', () => {
-        beforeEach(() => {
-            jest.clearAllMocks();
-        });
-        it('should return true when ark-controller is deployed and ready', async () => {
-            // Mock successful kubectl response with ready deployment
-            const mockDeployment = {
-                metadata: { name: 'ark-controller' },
-                spec: { replicas: 3 },
-                status: {
-                    readyReplicas: 3,
-                    availableReplicas: 3,
-                },
-            };
-            execa.mockResolvedValue({
-                stdout: JSON.stringify(mockDeployment),
-                stderr: '',
-                exitCode: 0,
-                failed: false,
-            });
-            const result = await isArkReady();
-            expect(result).toBe(true);
-            expect(execa).toHaveBeenCalledWith('kubectl', [
-                'get',
-                'deployment',
-                'ark-controller',
-                '-n',
-                'ark-system',
-                '-o',
-                'json',
-            ], { stdio: 'pipe' });
-        });
-        it('should return false when kubectl fails', async () => {
-            // Mock kubectl failure
-            execa.mockRejectedValue(new Error('kubectl not found'));
-            const result = await isArkReady();
-            expect(result).toBe(false);
-        });
-    });
-});

package/dist/lib/chatClient.d.ts

@@ -1,33 +0,0 @@
-import { ArkApiClient, QueryTarget } from './arkApiClient.js';
-export { QueryTarget };
-export interface ChatConfig {
-    streamingEnabled: boolean;
-    currentTarget?: QueryTarget;
-}
-export interface ToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-export interface ArkMetadata {
-    agent?: string;
-    team?: string;
-    model?: string;
-    query?: string;
-    target?: string;
-}
-export declare class ChatClient {
-    private arkApiClient;
-    constructor(arkApiClient: ArkApiClient);
-    getQueryTargets(): Promise<QueryTarget[]>;
-    /**
-     * Send a chat completion request
-     */
-    sendMessage(targetId: string, messages: Array<{
-        role: 'user' | 'assistant' | 'system';
-        content: string;
-    }>, config: ChatConfig, onChunk?: (chunk: string, toolCalls?: ToolCall[], arkMetadata?: ArkMetadata) => void, signal?: AbortSignal): Promise<string>;
-}

package/dist/lib/chatClient.js

@@ -1,99 +0,0 @@
-export class ChatClient {
-    constructor(arkApiClient) {
-        this.arkApiClient = arkApiClient;
-    }
-    async getQueryTargets() {
-        return await this.arkApiClient.getQueryTargets();
-    }
-    /**
-     * Send a chat completion request
-     */
-    async sendMessage(targetId, messages, config, onChunk, signal) {
-        const shouldStream = config.streamingEnabled && !!onChunk;
-        try {
-            const params = {
-                model: targetId,
-                messages: messages,
-                signal: signal,
-            };
-            if (shouldStream) {
-                let fullResponse = '';
-                const toolCallsById = new Map();
-                const stream = this.arkApiClient.createChatCompletionStream(params);
-                for await (const chunk of stream) {
-                    if (signal?.aborted) {
-                        break;
-                    }
-                    const delta = chunk.choices[0]?.delta;
-                    // Extract ARK metadata if present
-                    const arkMetadata = chunk.ark;
-                    // Handle regular content
-                    const content = delta?.content || '';
-                    if (content) {
-                        fullResponse += content;
-                        if (onChunk) {
-                            onChunk(content, undefined, arkMetadata);
-                        }
-                    }
-                    // Handle tool calls
-                    if (delta?.tool_calls) {
-                        for (const toolCallDelta of delta.tool_calls) {
-                            const index = toolCallDelta.index;
-                            // Initialize tool call if this is the first chunk for this index
-                            if (!toolCallsById.has(index)) {
-                                toolCallsById.set(index, {
-                                    id: toolCallDelta.id || '',
-                                    type: toolCallDelta.type || 'function',
-                                    function: {
-                                        name: toolCallDelta.function?.name || '',
-                                        arguments: '',
-                                    },
-                                });
-                            }
-                            // Accumulate function arguments
-                            const toolCall = toolCallsById.get(index);
-                            if (toolCallDelta.function?.arguments) {
-                                toolCall.function.arguments += toolCallDelta.function.arguments;
-                            }
-                            // Send the current state of all tool calls
-                            if (onChunk) {
-                                const toolCallsArray = Array.from(toolCallsById.values());
-                                onChunk('', toolCallsArray, arkMetadata);
-                            }
-                        }
-                    }
-                }
-                return fullResponse;
-            }
-            else {
-                const response = await this.arkApiClient.createChatCompletion(params);
-                const message = response.choices[0]?.message;
-                const content = message?.content || '';
-                // Handle tool calls in non-streaming mode
-                if (message?.tool_calls && message.tool_calls.length > 0) {
-                    const toolCalls = message.tool_calls.map((tc) => ({
-                        id: tc.id,
-                        type: tc.type || 'function',
-                        function: {
-                            name: tc.function?.name || '',
-                            arguments: tc.function?.arguments || '',
-                        },
-                    }));
-                    // Send tool calls first
-                    if (onChunk) {
-                        onChunk('', toolCalls);
-                    }
-                }
-                // Send content after tool calls
-                if (content && onChunk) {
-                    onChunk(content);
-                }
-                return content;
-            }
-        }
-        catch (error) {
-            // Don't log here - error will be displayed in the message thread
-            throw error;
-        }
-    }
-}

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

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