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

package/dist/lib/arkApiProxy.js

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

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

@@ -0,0 +1,93 @@
+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}`,
+                '--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

@@ -0,0 +1,5 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+import { execa } from 'execa';
+/**
+ * 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;
+        // ARK is ready if deployment exists and has at least one ready replica
+        return readyReplicas > 0 && readyReplicas === replicas;
+    }
+    catch {
+        // Deployment doesn't exist or kubectl failed
+        return 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,101 @@
+import output from './output.js';
+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) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            output.error('failed to call openai api:', errorMessage);
+            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

@@ -28,12 +28,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 executeCommand('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;
         }
@@ -129,6 +150,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/commandUtils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if a command is available in the system
+ */
+export declare function isCommandAvailable(command: string): Promise<boolean>;

package/dist/lib/commandUtils.js

@@ -0,0 +1,18 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+/**
+ * Check if a command is available in the system
+ */
+export async function isCommandAvailable(command) {
+    try {
+        const checkCommand = process.platform === 'win32'
+            ? `where ${command}`
+            : `command -v ${command}`;
+        await execAsync(checkCommand);
+        return true;
+    }
+    catch (_error) {
+        return false;
+    }
+}

package/dist/lib/commandUtils.test.d.ts

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

package/dist/lib/commandUtils.test.js

@@ -0,0 +1,44 @@
+import { exec } from 'child_process';
+import { isCommandAvailable } from './commandUtils';
+jest.mock('child_process');
+describe('commandUtils', () => {
+    describe('isCommandAvailable', () => {
+        const mockedExec = exec;
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('should return true when command exists on unix', async () => {
+            const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+            Object.defineProperty(process, 'platform', { value: 'darwin' });
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(null, '/usr/local/bin/helm', '');
+            });
+            const result = await isCommandAvailable('helm');
+            expect(result).toBe(true);
+            expect(mockedExec).toHaveBeenCalledWith('command -v helm', expect.any(Function));
+            if (originalPlatform) {
+                Object.defineProperty(process, 'platform', originalPlatform);
+            }
+        });
+        it('should return true when command exists on windows', async () => {
+            const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(null, 'C:\\Program Files\\helm\\helm.exe', '');
+            });
+            const result = await isCommandAvailable('helm');
+            expect(result).toBe(true);
+            expect(mockedExec).toHaveBeenCalledWith('where helm', expect.any(Function));
+            if (originalPlatform) {
+                Object.defineProperty(process, 'platform', originalPlatform);
+            }
+        });
+        it('should return false when command does not exist', async () => {
+            mockedExec.mockImplementation((cmd, callback) => {
+                callback(new Error('command not found'), null, 'command not found');
+            });
+            const result = await isCommandAvailable('nonexistent');
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/lib/config.d.ts

@@ -1,82 +1,26 @@
-/**
- * Configuration management for ARK CLI
- */
-export interface ArkConfig {
-    defaultProjectType: 'empty' | 'with-samples';
-    defaultDestination: string;
-    skipGitByDefault: boolean;
-    skipModelsbyDefault: boolean;
-    preferredEditor: string;
-    colorOutput: boolean;
-    verboseOutput: boolean;
-    defaultModelProvider: 'azure' | 'openai' | 'claude' | 'gemini' | 'custom';
-    templateDirectory?: string;
-    customTemplates: Record<string, string>;
-    parallelOperations: boolean;
-    maxConcurrentFiles: number;
-    fileWatchingEnabled: boolean;
-    telemetryEnabled: boolean;
-    errorReporting: boolean;
+export interface ChatConfig {
+    streaming?: boolean;
+    outputFormat?: 'text' | 'markdown';
 }
-export declare const DEFAULT_CONFIG: ArkConfig;
-export declare class ConfigManager {
-    private configPath;
-    private config;
-    constructor();
-    /**
-     * Get the path to the configuration file
-     */
-    private getConfigPath;
-    /**
-     * Load configuration from file or create with defaults
-     */
-    private loadConfig;
-    /**
-     * Save configuration to file
-     */
-    private saveConfig;
-    /**
-     * Get the current configuration
-     */
-    getConfig(): ArkConfig;
-    /**
-     * Update configuration
-     */
-    updateConfig(updates: Partial<ArkConfig>): void;
-    /**
-     * Reset configuration to defaults
-     */
-    resetConfig(): void;
-    /**
-     * Get a specific configuration value
-     */
-    get<K extends keyof ArkConfig>(key: K): ArkConfig[K];
-    /**
-     * Set a specific configuration value
-     */
-    set<K extends keyof ArkConfig>(key: K, value: ArkConfig[K]): void;
-    /**
-     * Validate configuration values
-     */
-    validateConfig(): void;
-    /**
-     * Get environment variable overrides
-     */
-    getEnvironmentOverrides(): Partial<ArkConfig>;
-    /**
-     * Get merged configuration with environment overrides
-     */
-    getMergedConfig(): ArkConfig;
-    /**
-     * Export configuration for backup
-     */
-    exportConfig(): string;
-    /**
-     * Import configuration from backup
-     */
-    importConfig(configJson: string): void;
-    /**
-     * Get configuration file path for CLI display
-     */
-    getConfigFilePath(): string;
+export interface ArkConfig {
+    chat?: ChatConfig;
 }
+/**
+ * Load configuration from multiple sources with proper precedence:
+ * 1. Defaults
+ * 2. ~/.arkrc.yaml (user config)
+ * 3. .arkrc.yaml (project config)
+ * 4. Environment variables (override all)
+ */
+export declare function loadConfig(): ArkConfig;
+/**
+ * Get the paths checked for config files
+ */
+export declare function getConfigPaths(): {
+    user: string;
+    project: string;
+};
+/**
+ * Format config as YAML for display
+ */
+export declare function formatConfig(config: ArkConfig): string;