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

package/dist/lib/executeQuery.js

@@ -0,0 +1,135 @@
+/**
+ * Shared query execution logic for both universal and resource-specific query commands
+ */
+import { execa } from 'execa';
+import ora from 'ora';
+import output from './output.js';
+/**
+ * Execute a query against any ARK target (model, agent, team)
+ * This is the shared implementation used by all query commands
+ */
+export async function executeQuery(options) {
+    const spinner = ora('Creating query...').start();
+    // Generate a unique query name
+    const timestamp = Date.now();
+    const queryName = `cli-query-${timestamp}`;
+    // Create the Query resource
+    const queryManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Query',
+        metadata: {
+            name: queryName,
+        },
+        spec: {
+            input: options.message,
+            targets: [
+                {
+                    type: options.targetType,
+                    name: options.targetName,
+                },
+            ],
+        },
+    };
+    try {
+        // Apply the query
+        spinner.text = 'Submitting query...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(queryManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Watch for query completion
+        spinner.text = 'Query status: initializing';
+        let queryComplete = false;
+        let attempts = 0;
+        const maxAttempts = 300; // 5 minutes with 1 second intervals
+        while (!queryComplete && attempts < maxAttempts) {
+            attempts++;
+            try {
+                const { stdout } = await execa('kubectl', ['get', 'query', queryName, '-o', 'json'], { stdio: 'pipe' });
+                const query = JSON.parse(stdout);
+                const phase = query.status?.phase;
+                // Update spinner with current phase
+                if (phase) {
+                    spinner.text = `Query status: ${phase}`;
+                }
+                // Check if query is complete based on phase
+                if (phase === 'done') {
+                    queryComplete = true;
+                    spinner.succeed('Query completed');
+                    // Extract and display the response from responses array
+                    if (query.status?.responses && query.status.responses.length > 0) {
+                        const response = query.status.responses[0];
+                        console.log('\n' + (response.content || response));
+                    }
+                    else {
+                        output.warning('No response received');
+                    }
+                }
+                else if (phase === 'error') {
+                    queryComplete = true;
+                    spinner.fail('Query failed');
+                    // Try to get error message from conditions or status
+                    const errorCondition = query.status?.conditions?.find((c) => {
+                        return c.type === 'Complete' && c.status === 'False';
+                    });
+                    if (errorCondition?.message) {
+                        output.error(errorCondition.message);
+                    }
+                    else if (query.status?.error) {
+                        output.error(query.status.error);
+                    }
+                    else {
+                        output.error('Query failed with unknown error');
+                    }
+                }
+                else if (phase === 'canceled') {
+                    queryComplete = true;
+                    spinner.warn('Query canceled');
+                    // Try to get cancellation reason if available
+                    if (query.status?.message) {
+                        output.warning(query.status.message);
+                    }
+                }
+            }
+            catch {
+                // Query might not exist yet, continue waiting
+                spinner.text = 'Query status: waiting for query to be created';
+            }
+            if (!queryComplete) {
+                await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second
+            }
+        }
+        if (!queryComplete) {
+            spinner.fail('Query timed out');
+            output.error('Query did not complete within 5 minutes');
+        }
+    }
+    catch (error) {
+        spinner.fail('Query failed');
+        output.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+    finally {
+        // Clean up the query resource
+        try {
+            await execa('kubectl', ['delete', 'query', queryName], { stdio: 'pipe' });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Parse a target string like "model/default" or "agent/weather"
+ * Returns QueryTarget or null if invalid
+ */
+export function parseTarget(target) {
+    const parts = target.split('/');
+    if (parts.length !== 2) {
+        return null;
+    }
+    return {
+        type: parts[0],
+        name: parts[1],
+    };
+}

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

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

package/dist/lib/executeQuery.spec.js

@@ -0,0 +1,170 @@
+import { jest } from '@jest/globals';
+const mockExeca = jest.fn();
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockSpinner = {
+    start: jest.fn(),
+    succeed: jest.fn(),
+    fail: jest.fn(),
+    warn: jest.fn(),
+    text: '',
+};
+const mockOra = jest.fn(() => mockSpinner);
+jest.unstable_mockModule('ora', () => ({
+    default: mockOra,
+}));
+const mockOutput = {
+    warning: jest.fn(),
+    error: jest.fn(),
+};
+jest.unstable_mockModule('./output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { executeQuery, parseTarget } = await import('./executeQuery.js');
+describe('executeQuery', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSpinner.start.mockReturnValue(mockSpinner);
+    });
+    describe('parseTarget', () => {
+        it('should parse valid target strings', () => {
+            expect(parseTarget('model/default')).toEqual({
+                type: 'model',
+                name: 'default',
+            });
+            expect(parseTarget('agent/weather-agent')).toEqual({
+                type: 'agent',
+                name: 'weather-agent',
+            });
+            expect(parseTarget('team/my-team')).toEqual({
+                type: 'team',
+                name: 'my-team',
+            });
+        });
+        it('should return null for invalid target strings', () => {
+            expect(parseTarget('invalid')).toBeNull();
+            expect(parseTarget('')).toBeNull();
+            expect(parseTarget('model/default/extra')).toBeNull();
+        });
+    });
+    describe('executeQuery', () => {
+        it('should create and apply a query manifest', async () => {
+            const mockQueryResponse = {
+                status: {
+                    phase: 'done',
+                    responses: [{ content: 'Test response' }],
+                },
+            };
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('get') && args.includes('query')) {
+                    return {
+                        stdout: JSON.stringify(mockQueryResponse),
+                        stderr: '',
+                        exitCode: 0,
+                    };
+                }
+                if (args.includes('delete')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            });
+            expect(mockSpinner.start).toHaveBeenCalled();
+            expect(mockSpinner.succeed).toHaveBeenCalledWith('Query completed');
+            expect(mockConsoleLog).toHaveBeenCalledWith('\nTest response');
+        });
+        it('should handle query error phase', async () => {
+            const mockQueryResponse = {
+                status: {
+                    phase: 'error',
+                    error: 'Query failed with test error',
+                },
+            };
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('get') && args.includes('query')) {
+                    return {
+                        stdout: JSON.stringify(mockQueryResponse),
+                        stderr: '',
+                        exitCode: 0,
+                    };
+                }
+                if (args.includes('delete')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            await executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            });
+            expect(mockSpinner.fail).toHaveBeenCalledWith('Query failed');
+            expect(mockOutput.error).toHaveBeenCalledWith('Query failed with test error');
+        });
+        it('should handle query canceled phase', async () => {
+            const mockQueryResponse = {
+                status: {
+                    phase: 'canceled',
+                    message: 'Query was canceled',
+                },
+            };
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                if (args.includes('get') && args.includes('query')) {
+                    return {
+                        stdout: JSON.stringify(mockQueryResponse),
+                        stderr: '',
+                        exitCode: 0,
+                    };
+                }
+                if (args.includes('delete')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            await executeQuery({
+                targetType: 'agent',
+                targetName: 'test-agent',
+                message: 'Hello',
+            });
+            expect(mockSpinner.warn).toHaveBeenCalledWith('Query canceled');
+            expect(mockOutput.warning).toHaveBeenCalledWith('Query was canceled');
+        });
+        it('should clean up query resource even on failure', async () => {
+            mockExeca.mockImplementation(async (command, args) => {
+                if (args.includes('apply')) {
+                    throw new Error('Failed to apply');
+                }
+                if (args.includes('delete')) {
+                    return { stdout: '', stderr: '', exitCode: 0 };
+                }
+                return { stdout: '', stderr: '', exitCode: 0 };
+            });
+            await expect(executeQuery({
+                targetType: 'model',
+                targetName: 'default',
+                message: 'Hello',
+            })).rejects.toThrow('process.exit called');
+            expect(mockSpinner.fail).toHaveBeenCalledWith('Query failed');
+            expect(mockOutput.error).toHaveBeenCalledWith('Failed to apply');
+            expect(mockExit).toHaveBeenCalledWith(1);
+        });
+    });
+});

package/dist/lib/nextSteps.js

@@ -13,7 +13,7 @@ export function printNextSteps() {
     console.log(`  ${chalk.gray('open dashboard:')}    ${chalk.white.bold('ark dashboard')}`);
     console.log(`  ${chalk.gray('show agents:')}       ${chalk.white.bold('kubectl get agents')}`);
     console.log(`  ${chalk.gray('run a query:')}       ${chalk.white.bold('ark query model/default "What are large language models?"')}`);
-    console.log(`  ${chalk.gray('interactive chat:')}  ${chalk.white.bold('ark')} ${chalk.gray('# then choose \'Chat\'')}`);
+    console.log(`  ${chalk.gray('interactive chat:')}  ${chalk.white.bold('ark')} ${chalk.gray("# then choose 'Chat'")}`);
     console.log(`  ${chalk.gray('new project:')}       ${chalk.white.bold('ark generate project my-agents')}`);
     console.log(`  ${chalk.gray('install fark:')}      ${chalk.blue('https://mckinsey.github.io/agents-at-scale-ark/developer-guide/cli-tools/')}`);
     console.log();

package/dist/lib/queryRunner.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared query execution logic for both universal and resource-specific query commands
+ */
+export interface QueryOptions {
+    targetType: string;
+    targetName: string;
+    message: string;
+    verbose?: boolean;
+}
+/**
+ * Execute a query against any ARK target (model, agent, team)
+ * This is the shared implementation used by all query commands
+ */
+export declare function executeQuery(options: QueryOptions): Promise<void>;
+/**
+ * Parse a target string like "model/default" or "agent/weather"
+ * Returns { targetType, targetName } or null if invalid
+ */
+export declare function parseTarget(target: string): {
+    targetType: string;
+    targetName: string;
+} | null;

package/dist/lib/queryRunner.js

@@ -0,0 +1,142 @@
+/**
+ * Shared query execution logic for both universal and resource-specific query commands
+ */
+import { execa } from 'execa';
+import ora from 'ora';
+import output from './output.js';
+/**
+ * Execute a query against any ARK target (model, agent, team)
+ * This is the shared implementation used by all query commands
+ */
+export async function executeQuery(options) {
+    const spinner = ora('Creating query...').start();
+    // Generate a unique query name
+    const timestamp = Date.now();
+    const queryName = `cli-query-${timestamp}`;
+    // Create the Query resource
+    const queryManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Query',
+        metadata: {
+            name: queryName,
+        },
+        spec: {
+            input: options.message,
+            targets: [
+                {
+                    type: options.targetType,
+                    name: options.targetName,
+                },
+            ],
+        },
+    };
+    try {
+        // Apply the query
+        spinner.text = 'Submitting query...';
+        await execa('kubectl', ['apply', '-f', '-'], {
+            input: JSON.stringify(queryManifest),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Watch for query completion
+        spinner.text = 'Query status: initializing';
+        let queryComplete = false;
+        let attempts = 0;
+        const maxAttempts = 300; // 5 minutes with 1 second intervals
+        while (!queryComplete && attempts < maxAttempts) {
+            attempts++;
+            try {
+                const { stdout } = await execa('kubectl', [
+                    'get',
+                    'query',
+                    queryName,
+                    '-o',
+                    'json',
+                ], { stdio: 'pipe' });
+                const query = JSON.parse(stdout);
+                const phase = query.status?.phase;
+                // Update spinner with current phase
+                if (phase) {
+                    spinner.text = `Query status: ${phase}`;
+                }
+                // Check if query is complete based on phase
+                if (phase === 'done') {
+                    queryComplete = true;
+                    spinner.succeed('Query completed');
+                    // Extract and display the response from responses array
+                    if (query.status?.responses && query.status.responses.length > 0) {
+                        const response = query.status.responses[0];
+                        console.log('\n' + (response.content || response));
+                    }
+                    else {
+                        output.warning('No response received');
+                    }
+                }
+                else if (phase === 'error') {
+                    queryComplete = true;
+                    spinner.fail('Query failed');
+                    // Try to get error message from conditions or status
+                    const errorCondition = query.status?.conditions?.find((c) => {
+                        const condition = c;
+                        return condition.type === 'Complete' && condition.status === 'False';
+                    });
+                    if (errorCondition?.message) {
+                        output.error(errorCondition.message);
+                    }
+                    else if (query.status?.error) {
+                        output.error(query.status.error);
+                    }
+                    else {
+                        output.error('Query failed with unknown error');
+                    }
+                }
+                else if (phase === 'canceled') {
+                    queryComplete = true;
+                    spinner.warn('Query canceled');
+                    // Try to get cancellation reason if available
+                    if (query.status?.message) {
+                        output.warning(query.status.message);
+                    }
+                }
+            }
+            catch {
+                // Query might not exist yet, continue waiting
+                spinner.text = 'Query status: waiting for query to be created';
+            }
+            if (!queryComplete) {
+                await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second
+            }
+        }
+        if (!queryComplete) {
+            spinner.fail('Query timed out');
+            output.error('Query did not complete within 5 minutes');
+        }
+    }
+    catch (error) {
+        spinner.fail('Query failed');
+        output.error(error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+    finally {
+        // Clean up the query resource
+        try {
+            await execa('kubectl', ['delete', 'query', queryName], { stdio: 'pipe' });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Parse a target string like "model/default" or "agent/weather"
+ * Returns { targetType, targetName } or null if invalid
+ */
+export function parseTarget(target) {
+    const parts = target.split('/');
+    if (parts.length !== 2) {
+        return null;
+    }
+    return {
+        targetType: parts[0],
+        targetName: parts[1],
+    };
+}

package/dist/lib/startup.d.ts

@@ -4,6 +4,6 @@ import type { ArkConfig } from './config.js';
  */
 export declare function showNoClusterError(): void;
 /**
- * Initialize the CLI by checking requirements and loading config
+ * Initialize the CLI with minimal checks for fast startup
  */
 export declare function startup(): Promise<ArkConfig>;

package/dist/lib/startup.js

@@ -1,8 +1,7 @@
 import chalk from 'chalk';
+import { execa } from 'execa';
 import { checkCommandExists } from './commands.js';
 import { loadConfig } from './config.js';
-import { getArkVersion } from './arkStatus.js';
-import { getClusterInfo } from './cluster.js';
 const REQUIRED_COMMANDS = [
     {
         name: 'kubectl',
@@ -48,46 +47,41 @@ export function showNoClusterError() {
     console.log(chalk.blue('  https://mckinsey.github.io/agents-at-scale-ark/quickstart/'));
 }
 /**
- * Fetch version information (non-blocking)
+ * Check if a Kubernetes context is configured
+ * This is a fast local check that doesn't hit the cluster
  */
-async function fetchVersionInfo(config) {
-    // Fetch latest version from GitHub
+async function hasKubernetesContext() {
     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;
-        }
+        const { stdout } = await execa('kubectl', ['config', 'current-context']);
+        return stdout.trim().length > 0;
     }
     catch {
-        // Silently fail - currentVersion will remain undefined
+        return false;
     }
 }
 /**
- * Initialize the CLI by checking requirements and loading config
+ * Initialize the CLI with minimal checks for fast startup
  */
 export async function startup() {
-    // Check required commands
+    // Check required commands (kubectl, helm) - fast local checks
     await checkRequirements();
-    // Load config
+    // Load config from disk (fast - just file I/O)
     const config = loadConfig();
-    // Get cluster info - if no error, we have cluster access
-    const clusterInfo = await getClusterInfo();
-    if (!clusterInfo.error) {
-        config.clusterInfo = clusterInfo;
+    // Check if we have a kubernetes context configured (fast local check)
+    // We don't check cluster connectivity here - that's expensive
+    const hasContext = await hasKubernetesContext();
+    if (hasContext) {
+        try {
+            const { stdout } = await execa('kubectl', ['config', 'current-context']);
+            config.clusterInfo = {
+                type: 'unknown', // We don't detect cluster type here - too slow
+                context: stdout.trim(),
+                // We don't fetch namespace or cluster details here - too slow
+            };
+        }
+        catch {
+            // Ignore - no context
+        }
     }
-    // Fetch version info synchronously so it's available immediately
-    await fetchVersionInfo(config);
     return config;
 }

package/dist/lib/startup.spec.js

@@ -16,21 +16,26 @@ jest.unstable_mockModule('./commands.js', () => ({
 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;
-// Mock fetch globally
-globalThis.fetch = jest.fn();
+const mockExeca = execa;
 describe('startup', () => {
     let mockExit;
     let mockConsoleError;
     beforeEach(() => {
         jest.clearAllMocks();
-        globalThis.fetch.mockClear();
+        // 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');
         });
@@ -120,49 +125,28 @@ describe('startup', () => {
         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('0.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('includes cluster context when available', async () => {
+        mockCheckCommandExists.mockResolvedValue(true);
+        mockLoadConfig.mockReturnValue({ chat: { streaming: true } });
+        // Mock successful kubectl context check
+        mockExeca.mockResolvedValue({
+            stdout: 'minikube',
+            stderr: '',
         });
-        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();
+        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();
     });
 });