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

package/dist/commands/completion/index.js

@@ -28,7 +28,7 @@ _ark_completion() {
   
   case \${COMP_CWORD} in
     1)
-      opts="agents chat cluster completion config dashboard dev generate install models routes status targets teams tools uninstall help"
+      opts="agents chat cluster completion config dashboard dev docs generate install models query routes status targets teams tools uninstall help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -95,6 +95,17 @@ _ark_completion() {
           COMPREPLY=( $(compgen -W "\${targets}" -- \${cur}) )
           return 0
           ;;
+        query)
+          # Dynamically fetch available targets for query command
+          local targets
+          targets=$(ark targets list 2>/dev/null)
+          if [ -z "$targets" ]; then
+            # Fallback to common targets if API is not available
+            targets="model/default agent/sample-agent"
+          fi
+          COMPREPLY=( $(compgen -W "\${targets}" -- \${cur}) )
+          return 0
+          ;;
       esac
       ;;
     3)
@@ -159,9 +170,11 @@ _ark() {
         'config[Configuration management]' \\
         'dashboard[Open ARK dashboard]' \\
         'dev[Development tools for ARK]' \\
+        'docs[Open ARK documentation]' \\
         'generate[Generate ARK resources]' \\
         'install[Install ARK services]' \\
         'models[List available models]' \\
+        'query[Execute a single query]' \\
         'routes[List available routes]' \\
         'status[Check system status]' \\
         'targets[List available query targets]' \\
@@ -234,6 +247,15 @@ _ark() {
           fi
           _values 'available targets' \${targets[@]}
           ;;
+        query)
+          # Get available targets dynamically for query
+          local -a targets
+          targets=($(ark targets list 2>/dev/null))
+          if [ \${#targets[@]} -eq 0 ]; then
+            targets=('model/default' 'agent/sample-agent')
+          fi
+          _values 'available targets' \${targets[@]}
+          ;;
       esac
       ;;
     args)

package/dist/commands/docs/index.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function openDocs(): Promise<void>;
+export declare function createDocsCommand(_: ArkConfig): Command;

package/dist/commands/docs/index.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import open from 'open';
+const DOCS_URL = 'https://mckinsey.github.io/agents-at-scale-ark/';
+export async function openDocs() {
+    console.log(`Opening ARK documentation: ${chalk.blue(DOCS_URL)}`);
+    // Brief pause before opening browser
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    // Open browser
+    await open(DOCS_URL);
+}
+export function createDocsCommand(_) {
+    const docsCommand = new Command('docs');
+    docsCommand
+        .description('Open the ARK documentation in your browser')
+        .action(openDocs);
+    return docsCommand;
+}

package/dist/commands/install/index.d.ts

@@ -1,8 +1,8 @@
 import { Command } from 'commander';
 import type { ArkConfig } from '../../lib/config.js';
-export declare function installArk(serviceName?: string, options?: {
+export declare function installArk(config: ArkConfig, serviceName?: string, options?: {
     yes?: boolean;
     waitForReady?: string;
     verbose?: boolean;
 }): Promise<void>;
-export declare function createInstallCommand(_: ArkConfig): Command;
+export declare function createInstallCommand(config: ArkConfig): Command;

package/dist/commands/install/index.js

@@ -2,10 +2,11 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { execute } from '../../lib/commands.js';
 import inquirer from 'inquirer';
-import { getClusterInfo } from '../../lib/cluster.js';
+import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices, arkDependencies } from '../../arkServices.js';
 import { isArkReady } from '../../lib/arkStatus.js';
+import { printNextSteps } from '../../lib/nextSteps.js';
 import ora from 'ora';
 async function installService(service, verbose = false) {
     const helmArgs = [
@@ -22,25 +23,18 @@ async function installService(service, verbose = false) {
     helmArgs.push(...(service.installArgs || []));
     await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
 }
-export async function installArk(serviceName, options = {}) {
+export async function installArk(config, serviceName, options = {}) {
     // Validate that --wait-for-ready requires -y
     if (options.waitForReady && !options.yes) {
         output.error('--wait-for-ready requires -y flag for non-interactive mode');
         process.exit(1);
     }
-    // Check cluster connectivity
-    const clusterInfo = await getClusterInfo();
-    if (clusterInfo.error) {
-        output.error('no kubernetes cluster detected');
-        output.info('please ensure you have a running cluster and kubectl is configured.');
-        output.info('');
-        output.info('for local development, we recommend minikube:');
-        output.info('• install: https://minikube.sigs.k8s.io/docs/start');
-        output.info('• start cluster: minikube start');
-        output.info('');
-        output.info('alternatively, you can use kind or docker desktop.');
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
         process.exit(1);
     }
+    const clusterInfo = config.clusterInfo;
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
     output.info(`type: ${clusterInfo.type}`);
@@ -250,6 +244,10 @@ export async function installArk(serviceName, options = {}) {
             }
         }
     }
+    // Show next steps after successful installation
+    if (!serviceName || serviceName === 'all') {
+        printNextSteps();
+    }
     // Wait for Ark to be ready if requested
     if (options.waitForReady) {
         // Parse timeout value (e.g., '30s', '2m', '60')
@@ -287,7 +285,7 @@ export async function installArk(serviceName, options = {}) {
         }
     }
 }
-export function createInstallCommand(_) {
+export function createInstallCommand(config) {
     const command = new Command('install');
     command
         .description('Install ARK components using Helm')
@@ -296,7 +294,7 @@ export function createInstallCommand(_) {
         .option('--wait-for-ready <timeout>', 'wait for Ark to be ready after installation (e.g., 30s, 2m)')
         .option('-v, --verbose', 'show commands being executed')
         .action(async (service, options) => {
-        await installArk(service, options);
+        await installArk(config, service, options);
     });
     return command;
 }

package/dist/commands/install/index.spec.js

@@ -9,9 +9,11 @@ jest.unstable_mockModule('../../lib/cluster.js', () => ({
     getClusterInfo: mockGetClusterInfo,
 }));
 const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
 const mockArkDependencies = {};
 jest.unstable_mockModule('../../arkServices.js', () => ({
     getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
     arkDependencies: mockArkDependencies,
 }));
 const mockOutput = {
@@ -30,6 +32,13 @@ jest.spyOn(console, 'log').mockImplementation(() => { });
 jest.spyOn(console, 'error').mockImplementation(() => { });
 const { createInstallCommand } = await import('./index.js');
 describe('install command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
     beforeEach(() => {
         jest.clearAllMocks();
         mockGetClusterInfo.mockResolvedValue({
@@ -39,7 +48,7 @@ describe('install command', () => {
         });
     });
     it('creates command with correct structure', () => {
-        const command = createInstallCommand({});
+        const command = createInstallCommand(mockConfig);
         expect(command).toBeInstanceOf(Command);
         expect(command.name()).toBe('install');
     });
@@ -54,7 +63,7 @@ describe('install command', () => {
         mockGetInstallableServices.mockReturnValue({
             'ark-api': mockService,
         });
-        const command = createInstallCommand({});
+        const command = createInstallCommand(mockConfig);
         await command.parseAsync(['node', 'test', 'ark-api']);
         expect(mockExeca).toHaveBeenCalledWith('helm', [
             'upgrade',
@@ -73,7 +82,7 @@ describe('install command', () => {
             'ark-api': { name: 'ark-api' },
             'ark-controller': { name: 'ark-controller' },
         });
-        const command = createInstallCommand({});
+        const command = createInstallCommand(mockConfig);
         await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
         expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
         expect(mockOutput.info).toHaveBeenCalledWith('available services:');
@@ -92,7 +101,7 @@ describe('install command', () => {
         mockGetInstallableServices.mockReturnValue({
             'ark-dashboard': mockService,
         });
-        const command = createInstallCommand({});
+        const command = createInstallCommand(mockConfig);
         await command.parseAsync(['node', 'test', 'ark-dashboard']);
         // Should NOT include --namespace flag
         expect(mockExeca).toHaveBeenCalledWith('helm', [
@@ -114,7 +123,7 @@ describe('install command', () => {
         mockGetInstallableServices.mockReturnValue({
             'simple-service': mockService,
         });
-        const command = createInstallCommand({});
+        const command = createInstallCommand(mockConfig);
         await command.parseAsync(['node', 'test', 'simple-service']);
         expect(mockExeca).toHaveBeenCalledWith('helm', [
             'upgrade',
@@ -129,7 +138,6 @@ describe('install command', () => {
         mockGetClusterInfo.mockResolvedValue({ error: true });
         const command = createInstallCommand({});
         await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('no kubernetes cluster detected');
         expect(mockExit).toHaveBeenCalledWith(1);
     });
 });

package/dist/commands/query/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
+export declare function createQueryCommand(_: ArkConfig): Command;

package/dist/commands/query/index.js

@@ -0,0 +1,131 @@
+import { Command } from 'commander';
+import { execa } from 'execa';
+import ora from 'ora';
+import output from '../../lib/output.js';
+async function runQuery(target, message) {
+    const spinner = ora('Creating query...').start();
+    // Generate a unique query name
+    const timestamp = Date.now();
+    const queryName = `cli-query-${timestamp}`;
+    // Parse the target format (e.g., model/default -> type: model, name: default)
+    const [targetType, targetName] = target.split('/');
+    // Create the Query resource
+    const queryManifest = {
+        apiVersion: 'ark.mckinsey.com/v1alpha1',
+        kind: 'Query',
+        metadata: {
+            name: queryName,
+        },
+        spec: {
+            input: message,
+            targets: [
+                {
+                    type: targetType,
+                    name: 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 = 'Running query: 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);
+    }
+}
+export function createQueryCommand(_) {
+    const queryCommand = new Command('query');
+    queryCommand
+        .description('Execute a single query against a model or agent')
+        .argument('<target>', 'Query target (e.g., model/default, agent/my-agent)')
+        .argument('<message>', 'Message to send')
+        .action(async (target, message) => {
+        // Validate target format
+        if (!target.includes('/')) {
+            output.error('Invalid target format. Use: model/name or agent/name etc');
+            process.exit(1);
+        }
+        await runQuery(target, message);
+    });
+    return queryCommand;
+}

package/dist/commands/status/index.js

@@ -158,9 +158,6 @@ function buildStatusSections(data, config) {
                 statusColor: statusInfo.color,
                 name: displayName,
                 details: details,
-                subtext: controller.status === 'healthy' && !data.defaultModelExists
-                    ? '(no default model configured)'
-                    : undefined,
             });
             // Add version update status as separate line
             if (controller.status === 'healthy' && controller.version && config) {
@@ -199,6 +196,39 @@ function buildStatusSections(data, config) {
                     }
                 }
             }
+            // Add default model status
+            if (data.defaultModel) {
+                if (!data.defaultModel.exists) {
+                    arkStatusLines.push({
+                        icon: '○',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not configured',
+                    });
+                }
+                else if (data.defaultModel.available) {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'green',
+                        status: 'default model',
+                        statusColor: 'green',
+                        name: '',
+                        details: data.defaultModel.provider || 'configured',
+                    });
+                }
+                else {
+                    arkStatusLines.push({
+                        icon: '●',
+                        iconColor: 'yellow',
+                        status: 'default model',
+                        statusColor: 'yellow',
+                        name: '',
+                        details: 'not available',
+                    });
+                }
+            }
         }
     }
     sections.push({ title: 'ark status:', lines: arkStatusLines });

package/dist/commands/uninstall/index.d.ts

@@ -1,3 +1,3 @@
 import { Command } from 'commander';
 import type { ArkConfig } from '../../lib/config.js';
-export declare function createUninstallCommand(_: ArkConfig): Command;
+export declare function createUninstallCommand(config: ArkConfig): Command;

package/dist/commands/uninstall/index.js

@@ -2,7 +2,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { execute } from '../../lib/commands.js';
 import inquirer from 'inquirer';
-import { getClusterInfo } from '../../lib/cluster.js';
+import { showNoClusterError } from '../../lib/startup.js';
 import output from '../../lib/output.js';
 import { getInstallableServices } from '../../arkServices.js';
 async function uninstallService(service, verbose = false) {
@@ -13,14 +13,13 @@ async function uninstallService(service, verbose = false) {
     }
     await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
 }
-async function uninstallArk(serviceName, options = {}) {
-    // Check cluster connectivity
-    const clusterInfo = await getClusterInfo();
-    if (clusterInfo.error) {
-        output.error('no kubernetes cluster detected');
-        output.info('please ensure you have a running cluster and kubectl is configured.');
+async function uninstallArk(config, serviceName, options = {}) {
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
         process.exit(1);
     }
+    const clusterInfo = config.clusterInfo;
     // Show cluster info
     output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
     output.info(`type: ${clusterInfo.type}`);
@@ -93,7 +92,7 @@ async function uninstallArk(serviceName, options = {}) {
         }
     }
 }
-export function createUninstallCommand(_) {
+export function createUninstallCommand(config) {
     const command = new Command('uninstall');
     command
         .description('Uninstall ARK components using Helm')
@@ -101,7 +100,7 @@ export function createUninstallCommand(_) {
         .option('-y, --yes', 'automatically confirm all uninstallations')
         .option('-v, --verbose', 'show commands being executed')
         .action(async (service, options) => {
-        await uninstallArk(service, options);
+        await uninstallArk(config, service, options);
     });
     return command;
 }

package/dist/commands/uninstall/index.spec.js

@@ -9,8 +9,10 @@ jest.unstable_mockModule('../../lib/cluster.js', () => ({
     getClusterInfo: mockGetClusterInfo,
 }));
 const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
 jest.unstable_mockModule('../../arkServices.js', () => ({
     getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
 }));
 const mockOutput = {
     error: jest.fn(),
@@ -28,6 +30,13 @@ jest.spyOn(console, 'log').mockImplementation(() => { });
 jest.spyOn(console, 'error').mockImplementation(() => { });
 const { createUninstallCommand } = await import('./index.js');
 describe('uninstall command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
     beforeEach(() => {
         jest.clearAllMocks();
         mockGetClusterInfo.mockResolvedValue({
@@ -37,7 +46,7 @@ describe('uninstall command', () => {
         });
     });
     it('creates command with correct structure', () => {
-        const command = createUninstallCommand({});
+        const command = createUninstallCommand(mockConfig);
         expect(command).toBeInstanceOf(Command);
         expect(command.name()).toBe('uninstall');
     });
@@ -50,7 +59,7 @@ describe('uninstall command', () => {
         mockGetInstallableServices.mockReturnValue({
             'ark-api': mockService,
         });
-        const command = createUninstallCommand({});
+        const command = createUninstallCommand(mockConfig);
         await command.parseAsync(['node', 'test', 'ark-api']);
         expect(mockExeca).toHaveBeenCalledWith('helm', [
             'uninstall',
@@ -68,7 +77,7 @@ describe('uninstall command', () => {
             'ark-api': { name: 'ark-api' },
             'ark-controller': { name: 'ark-controller' },
         });
-        const command = createUninstallCommand({});
+        const command = createUninstallCommand(mockConfig);
         await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
         expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
         expect(mockOutput.info).toHaveBeenCalledWith('available services:');
@@ -85,7 +94,7 @@ describe('uninstall command', () => {
         mockGetInstallableServices.mockReturnValue({
             'ark-dashboard': mockService,
         });
-        const command = createUninstallCommand({});
+        const command = createUninstallCommand(mockConfig);
         await command.parseAsync(['node', 'test', 'ark-dashboard']);
         // Should NOT include --namespace flag
         expect(mockExeca).toHaveBeenCalledWith('helm', ['uninstall', 'ark-dashboard', '--ignore-not-found'], {
@@ -102,7 +111,7 @@ describe('uninstall command', () => {
             'ark-api': mockService,
         });
         mockExeca.mockRejectedValue(new Error('helm failed'));
-        const command = createUninstallCommand({});
+        const command = createUninstallCommand(mockConfig);
         await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
         expect(mockOutput.error).toHaveBeenCalledWith('failed to uninstall ark-api');
         expect(mockExit).toHaveBeenCalledWith(1);
@@ -111,7 +120,6 @@ describe('uninstall command', () => {
         mockGetClusterInfo.mockResolvedValue({ error: true });
         const command = createUninstallCommand({});
         await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
-        expect(mockOutput.error).toHaveBeenCalledWith('no kubernetes cluster detected');
         expect(mockExit).toHaveBeenCalledWith(1);
     });
 });

package/dist/components/statusChecker.js

@@ -372,16 +372,35 @@ export class StatusChecker {
         // Check if ARK is ready (controller is running)
         let arkReady = false;
         let defaultModelExists = false;
+        let defaultModel;
         if (clusterAccess) {
             arkReady = await isArkReady();
-            // Check for default model
+            // Check for default model with detailed status
             if (arkReady) {
                 try {
-                    await execa('kubectl', ['get', 'model', 'default', '-o', 'name']);
+                    const { stdout } = await execa('kubectl', [
+                        'get',
+                        'model',
+                        'default',
+                        '-o',
+                        'json',
+                    ]);
+                    const model = JSON.parse(stdout);
                     defaultModelExists = true;
+                    // Extract model details
+                    const available = model.status?.conditions?.find((c) => c.type === 'Available')?.status === 'True';
+                    defaultModel = {
+                        exists: true,
+                        available,
+                        provider: model.spec?.provider,
+                        details: model.spec?.model || model.spec?.apiEndpoint,
+                    };
                 }
                 catch {
                     defaultModelExists = false;
+                    defaultModel = {
+                        exists: false,
+                    };
                 }
             }
         }
@@ -392,6 +411,7 @@ export class StatusChecker {
             clusterInfo,
             arkReady,
             defaultModelExists,
+            defaultModel,
         };
     }
 }

package/dist/index.js

@@ -12,10 +12,12 @@ import { createChatCommand } from './commands/chat/index.js';
 import { createClusterCommand } from './commands/cluster/index.js';
 import { createCompletionCommand } from './commands/completion/index.js';
 import { createDashboardCommand } from './commands/dashboard/index.js';
+import { createDocsCommand } from './commands/docs/index.js';
 import { createDevCommand } from './commands/dev/index.js';
 import { createGenerateCommand } from './commands/generate/index.js';
 import { createInstallCommand } from './commands/install/index.js';
 import { createModelsCommand } from './commands/models/index.js';
+import { createQueryCommand } from './commands/query/index.js';
 import { createUninstallCommand } from './commands/uninstall/index.js';
 import { createStatusCommand } from './commands/status/index.js';
 import { createConfigCommand } from './commands/config/index.js';
@@ -41,10 +43,12 @@ async function main() {
     program.addCommand(createClusterCommand(config));
     program.addCommand(createCompletionCommand(config));
     program.addCommand(createDashboardCommand(config));
+    program.addCommand(createDocsCommand(config));
     program.addCommand(createDevCommand(config));
     program.addCommand(createGenerateCommand(config));
     program.addCommand(createInstallCommand(config));
     program.addCommand(createModelsCommand(config));
+    program.addCommand(createQueryCommand(config));
     program.addCommand(createUninstallCommand(config));
     program.addCommand(createStatusCommand(config));
     program.addCommand(createConfigCommand(config));

package/dist/lib/config.d.ts

@@ -1,3 +1,4 @@
+import type { ClusterInfo } from './cluster.js';
 export interface ChatConfig {
     streaming?: boolean;
     outputFormat?: 'text' | 'markdown';
@@ -6,6 +7,7 @@ export interface ArkConfig {
     chat?: ChatConfig;
     latestVersion?: string;
     currentVersion?: string;
+    clusterInfo?: ClusterInfo;
 }
 /**
  * Load configuration from multiple sources with proper precedence:

package/dist/lib/nextSteps.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Print helpful next steps after successful ARK installation
+ */
+export declare function printNextSteps(): void;

package/dist/lib/nextSteps.js

@@ -0,0 +1,20 @@
+import chalk from 'chalk';
+/**
+ * Print helpful next steps after successful ARK installation
+ */
+export function printNextSteps() {
+    console.log();
+    console.log(chalk.green.bold('✓ ARK installed successfully!'));
+    console.log();
+    console.log(chalk.gray('Next steps:'));
+    console.log();
+    console.log(`  ${chalk.gray('docs:')}              ${chalk.blue('https://mckinsey.github.io/agents-at-scale-ark/')}`);
+    console.log(`  ${chalk.gray('create model:')}      ${chalk.white.bold('ark models create default')}`);
+    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('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/nextSteps.spec.d.ts

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

package/dist/lib/nextSteps.spec.js

@@ -0,0 +1,59 @@
+import { jest } from '@jest/globals';
+import { printNextSteps } from './nextSteps.js';
+describe('printNextSteps', () => {
+    let consoleLogSpy;
+    let output = [];
+    beforeEach(() => {
+        output = [];
+        consoleLogSpy = jest.spyOn(console, 'log').mockImplementation((...args) => {
+            output.push(args.join(' '));
+        });
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+    });
+    it('prints successful installation message', () => {
+        printNextSteps();
+        const fullOutput = output.join('\n');
+        expect(fullOutput).toContain('ARK installed successfully!');
+    });
+    it('includes all required commands', () => {
+        printNextSteps();
+        const fullOutput = output.join('\n');
+        // Check for each command
+        expect(fullOutput).toContain('ark models create default');
+        expect(fullOutput).toContain('ark dashboard');
+        expect(fullOutput).toContain('kubectl get agents');
+        expect(fullOutput).toContain('ark query model/default "What are large language models?"');
+        expect(fullOutput).toContain('ark');
+        expect(fullOutput).toContain("# then choose 'Chat'");
+        expect(fullOutput).toContain('ark generate project my-agents');
+    });
+    it('includes all required links', () => {
+        printNextSteps();
+        const fullOutput = output.join('\n');
+        // Check for documentation links
+        expect(fullOutput).toContain('https://mckinsey.github.io/agents-at-scale-ark/');
+        expect(fullOutput).toContain('https://mckinsey.github.io/agents-at-scale-ark/developer-guide/cli-tools/');
+    });
+    it('includes all section labels', () => {
+        printNextSteps();
+        const fullOutput = output.join('\n');
+        // Check for labels
+        expect(fullOutput).toContain('Next steps:');
+        expect(fullOutput).toContain('docs:');
+        expect(fullOutput).toContain('create model:');
+        expect(fullOutput).toContain('open dashboard:');
+        expect(fullOutput).toContain('show agents:');
+        expect(fullOutput).toContain('run a query:');
+        expect(fullOutput).toContain('interactive chat:');
+        expect(fullOutput).toContain('new project:');
+        expect(fullOutput).toContain('install fark:');
+    });
+    it('has correct structure with empty lines', () => {
+        printNextSteps();
+        // Should have empty lines for formatting
+        expect(output[0]).toBe('');
+        expect(output[output.length - 1]).toBe('');
+    });
+});

package/dist/lib/startup.d.ts

@@ -1,4 +1,8 @@
 import type { ArkConfig } from './config.js';
+/**
+ * Show error message when no cluster is detected
+ */
+export declare function showNoClusterError(): void;
 /**
  * Initialize the CLI by checking requirements and loading config
  */

package/dist/lib/startup.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 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',
@@ -32,6 +33,20 @@ async function checkRequirements() {
         process.exit(1);
     }
 }
+/**
+ * Show error message when no cluster is detected
+ */
+export function showNoClusterError() {
+    console.log(chalk.red.bold('\n✗ No Kubernetes cluster detected\n'));
+    console.log('Please ensure you have configured a connection to a Kubernetes cluster.');
+    console.log('For local development, you can use:');
+    console.log(`  • Minikube: ${chalk.blue('https://minikube.sigs.k8s.io/docs/start')}`);
+    console.log(`  • Docker Desktop: ${chalk.blue('https://docs.docker.com/desktop/kubernetes/')}`);
+    console.log(`  • Kind: ${chalk.blue('https://kind.sigs.k8s.io/docs/user/quick-start/')}`);
+    console.log('');
+    console.log('And more. For help, check the Quickstart guide:');
+    console.log(chalk.blue('  https://mckinsey.github.io/agents-at-scale-ark/quickstart/'));
+}
 /**
  * Fetch version information (non-blocking)
  */
@@ -67,6 +82,11 @@ export async function startup() {
     await checkRequirements();
     // Load config
     const config = loadConfig();
+    // Get cluster info - if no error, we have cluster access
+    const clusterInfo = await getClusterInfo();
+    if (!clusterInfo.error) {
+        config.clusterInfo = clusterInfo;
+    }
     // Fetch version info synchronously so it's available immediately
     await fetchVersionInfo(config);
     return config;

package/dist/lib/startup.spec.js

@@ -135,7 +135,7 @@ describe('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');
+            expect(config.latestVersion).toBe('0.1.35');
         });
         it('handles GitHub API failure gracefully', async () => {
             globalThis.fetch.mockRejectedValue(new Error('Network error'));

package/dist/lib/types.d.ts

@@ -31,11 +31,18 @@ export interface DependencyStatus {
     version?: string;
     details?: string;
 }
+export interface ModelStatus {
+    exists: boolean;
+    available?: boolean;
+    provider?: string;
+    details?: string;
+}
 export interface StatusData {
     services: ServiceStatus[];
     dependencies: DependencyStatus[];
     arkReady?: boolean;
     defaultModelExists?: boolean;
+    defaultModel?: ModelStatus;
 }
 export interface CommandVersionConfig {
     command: string;

package/dist/ui/MainMenu.js

@@ -239,7 +239,7 @@ const MainMenu = ({ config }) => {
     ║        Agents at Scale Platform       ║
     ║                                       ║
     ╚═══════════════════════════════════════╝
-        ` }), isChecking ? (_jsxs(Text, { color: "gray", children: [_jsx(Spinner, { type: "dots" }), " Checking Ark status..."] })) : arkReady ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: "\u25CF Ark is ready" }), config.currentVersion && (_jsxs(Text, { color: "gray", children: [" (", config.currentVersion, ")"] }))] })) : (_jsx(Text, { color: "yellow", bold: true, children: "\u25CF Ark is not installed" })), _jsx(Text, { color: "gray", children: "Interactive terminal interface for Ark agents" })] }), !isChecking && (_jsx(Box, { flexDirection: "column", paddingX: 4, marginTop: 1, children: choices.map((choice, index) => {
+        ` }), isChecking ? (_jsxs(Text, { color: "gray", children: [_jsx(Spinner, { type: "dots" }), " Checking Ark status..."] })) : arkReady ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: "\u25CF Ark is ready" }), config.currentVersion && (_jsxs(Text, { color: "gray", children: [" (", config.currentVersion, ")"] }))] })) : (_jsx(Text, { color: "yellow", bold: true, children: "\u25CF Ark is not installed" })), config.clusterInfo?.context ? (_jsxs(Text, { children: [_jsx(Text, { color: "gray", children: "Current context: " }), _jsx(Text, { color: "white", bold: true, children: config.clusterInfo.context })] })) : (_jsx(Text, { color: "gray", children: "No Kubernetes context configured" }))] }), !isChecking && (_jsx(Box, { flexDirection: "column", paddingX: 4, marginTop: 1, children: choices.map((choice, index) => {
                     const isSelected = index === selectedIndex;
                     return (_jsxs(Box, { flexDirection: "row", paddingY: 0, children: [_jsx(Text, { color: "gray", dimColor: true, children: isSelected ? '❯ ' : '  ' }), _jsxs(Text, { color: "gray", dimColor: true, children: [index + 1, "."] }), _jsx(Box, { marginLeft: 1, width: 20, children: _jsx(Text, { color: isSelected ? 'green' : 'white', bold: isSelected, children: choice.label }) }), _jsx(Text, { color: "gray", children: choice.description })] }, choice.value));
                 }) }))] }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-at-scale/ark",
-  "version": "0.1.35-rc1",
+  "version": "0.1.35-rc2",
   "description": "ARK CLI - Interactive terminal interface for ARK agents",
   "main": "dist/index.js",
   "type": "module",