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

package/dist/lib/arkStatus.js

@@ -0,0 +1,79 @@
+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

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

package/dist/lib/arkStatus.spec.js

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,99 @@
+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.d.ts

@@ -2,7 +2,8 @@ export interface ClusterInfo {
     type: 'minikube' | 'kind' | 'k3s' | 'docker-desktop' | 'cloud' | 'unknown';
     ip?: string;
     context?: string;
+    namespace?: string;
     error?: string;
 }
 export declare function detectClusterType(): Promise<ClusterInfo>;
-export declare function getClusterIp(_context?: string): Promise<ClusterInfo>;
+export declare function getClusterInfo(context?: string): Promise<ClusterInfo>;

package/dist/lib/cluster.js

@@ -1,10 +1,7 @@
-import { executeCommand } from './exec.js';
+import { execa } from 'execa';
 export async function detectClusterType() {
     try {
-        const { stdout } = await executeCommand('kubectl', [
-            'config',
-            'current-context',
-        ]);
+        const { stdout } = await execa('kubectl', ['config', 'current-context']);
         const context = stdout.trim();
         if (context.includes('minikube')) {
             return { type: 'minikube', context };
@@ -28,12 +25,33 @@ export async function detectClusterType() {
         }
     }
     catch (error) {
-        return { type: 'unknown', error: error.message };
+        return {
+            type: 'unknown',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
     }
 }
-export async function getClusterIp(_context) {
+export async function getClusterInfo(context) {
     try {
+        // If context is provided, use it
+        const contextArgs = context ? ['--context', context] : [];
+        // Get all config info in one command
+        const { stdout: configJson } = await execa('kubectl', [
+            'config',
+            'view',
+            '--minify',
+            '-o',
+            'json',
+            ...contextArgs,
+        ]);
+        const config = JSON.parse(configJson);
+        const currentContext = config['current-context'] || '';
+        const contextData = config.contexts?.find((c) => c.name === currentContext);
+        const namespace = contextData?.context?.namespace || 'default';
+        // Detect cluster type from context name
         const clusterInfo = await detectClusterType();
+        clusterInfo.context = currentContext;
+        clusterInfo.namespace = namespace;
         if (clusterInfo.error) {
             return clusterInfo;
         }
@@ -41,12 +59,12 @@ export async function getClusterIp(_context) {
         switch (clusterInfo.type) {
             case 'minikube':
                 try {
-                    const { stdout } = await executeCommand('minikube', ['ip']);
+                    const { stdout } = await execa('minikube', ['ip']);
                     ip = stdout.trim();
                 }
                 catch {
                     // Fallback to kubectl if minikube command fails
-                    const { stdout } = await executeCommand('kubectl', [
+                    const { stdout } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -56,7 +74,7 @@ export async function getClusterIp(_context) {
                 }
                 break;
             case 'kind': {
-                const { stdout: kindOutput } = await executeCommand('kubectl', [
+                const { stdout: kindOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -69,7 +87,7 @@ export async function getClusterIp(_context) {
                 ip = 'localhost';
                 break;
             case 'k3s': {
-                const { stdout: k3sOutput } = await executeCommand('kubectl', [
+                const { stdout: k3sOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -81,7 +99,7 @@ export async function getClusterIp(_context) {
             case 'cloud':
                 // For cloud clusters, try to get the external IP or load balancer IP
                 try {
-                    const { stdout: lbOutput } = await executeCommand('kubectl', [
+                    const { stdout: lbOutput } = await execa('kubectl', [
                         'get',
                         'svc',
                         '-n',
@@ -92,7 +110,7 @@ export async function getClusterIp(_context) {
                     ]);
                     ip = lbOutput.trim();
                     if (!ip) {
-                        const { stdout: hostnameOutput } = await executeCommand('kubectl', [
+                        const { stdout: hostnameOutput } = await execa('kubectl', [
                             'get',
                             'svc',
                             '-n',
@@ -106,7 +124,7 @@ export async function getClusterIp(_context) {
                 }
                 catch {
                     // Fallback to node IP
-                    const { stdout: nodeOutput } = await executeCommand('kubectl', [
+                    const { stdout: nodeOutput } = await execa('kubectl', [
                         'get',
                         'nodes',
                         '-o',
@@ -116,7 +134,7 @@ export async function getClusterIp(_context) {
                 }
                 break;
             default: {
-                const { stdout: defaultOutput } = await executeCommand('kubectl', [
+                const { stdout: defaultOutput } = await execa('kubectl', [
                     'get',
                     'nodes',
                     '-o',
@@ -129,6 +147,9 @@ export async function getClusterIp(_context) {
         return { ...clusterInfo, ip };
     }
     catch (error) {
-        return { type: 'unknown', error: error.message };
+        return {
+            type: 'unknown',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
     }
 }

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

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