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

package/dist/lib/dev/tools/types.d.ts

@@ -0,0 +1,50 @@
+export interface ToolParameter {
+    name: string;
+    type?: string;
+}
+export interface DiscoveredTool {
+    name: string;
+    parameters: ToolParameter[];
+    return_type?: string;
+    docstring?: string;
+}
+export interface FileDiscoveryResult {
+    success: boolean;
+    file: string;
+    tools: DiscoveredTool[];
+    uses_fastmcp: boolean;
+    mcp_instance?: string;
+    server_name?: string;
+    error?: string;
+}
+export interface DirectoryDiscoveryResult {
+    directory: string;
+    files: FileDiscoveryResult[];
+    total_tools: number;
+    uses_fastmcp: boolean;
+}
+export type DiscoveryResult = FileDiscoveryResult | DirectoryDiscoveryResult;
+export interface ProjectDiscoveryResult {
+    path: string;
+    exists: boolean;
+    is_directory: boolean;
+    platform: 'python3' | null;
+    project_type: 'pyproject' | 'requirements' | null;
+    project_file: string | null;
+    project_name: string | null;
+    project_version: string | null;
+    has_fastmcp: boolean;
+    fastmcp_version: string | null;
+}
+export interface ProjectInfo {
+    path: string;
+    platform: 'python3';
+    projectType: 'pyproject' | 'requirements' | 'unknown';
+    hasVenv: boolean;
+    fastMCP: boolean;
+    fastMCPVersion?: string;
+}
+export interface ArkDevToolStatus extends ProjectInfo {
+    discovery?: DiscoveryResult;
+    tools: DiscoveredTool[];
+}

package/dist/lib/dev/tools/types.js

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

package/dist/lib/errors.js

@@ -162,9 +162,9 @@ export class InputValidator {
         if (!kebabRegex.test(trimmed)) {
             const suggestions = [];
             const normalized = trimmed
+                .replace(/([a-z])([A-Z])/g, '$1-$2') // Handle camelCase first
                 .toLowerCase()
                 .replace(/[\s_]+/g, '-')
-                .replace(/([a-z])([A-Z])/g, '$1-$2')
                 .replace(/-{2,}/g, '-') // Replace 2+ consecutive hyphens with single hyphen (ReDoS-safe)
                 .replace(/^-/, '') // Remove single leading hyphen (ReDoS-safe)
                 .replace(/-$/, ''); // Remove single trailing hyphen (ReDoS-safe)

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

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

package/dist/lib/errors.spec.js

@@ -0,0 +1,221 @@
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { ErrorCode, ArkError, ValidationError, TemplateError, ProjectStructureError, ErrorHandler, InputValidator, } from './errors.js';
+jest.mock('fs');
+describe('Error Classes', () => {
+    describe('ArkError', () => {
+        it('creates error with default code', () => {
+            const error = new ArkError('test message');
+            expect(error.message).toBe('test message');
+            expect(error.code).toBe(ErrorCode.UNKNOWN_ERROR);
+            expect(error.name).toBe('ArkError');
+            expect(error.details).toBeUndefined();
+            expect(error.suggestions).toBeUndefined();
+        });
+        it('creates error with all properties', () => {
+            const error = new ArkError('test error', ErrorCode.INVALID_INPUT, { field: 'name' }, ['Check the input', 'Try again']);
+            expect(error.message).toBe('test error');
+            expect(error.code).toBe(ErrorCode.INVALID_INPUT);
+            expect(error.details).toEqual({ field: 'name' });
+            expect(error.suggestions).toEqual(['Check the input', 'Try again']);
+        });
+    });
+    describe('ValidationError', () => {
+        it('creates validation error without field', () => {
+            const error = new ValidationError('validation failed');
+            expect(error.message).toBe('validation failed');
+            expect(error.code).toBe(ErrorCode.VALIDATION_ERROR);
+            expect(error.name).toBe('ValidationError');
+            expect(error.details).toBeUndefined();
+        });
+        it('creates validation error with field and suggestions', () => {
+            const error = new ValidationError('invalid email', 'email', [
+                'Use valid format',
+            ]);
+            expect(error.message).toBe('invalid email');
+            expect(error.code).toBe(ErrorCode.VALIDATION_ERROR);
+            expect(error.details).toEqual({ field: 'email' });
+            expect(error.suggestions).toEqual(['Use valid format']);
+        });
+    });
+    describe('TemplateError', () => {
+        it('creates template error', () => {
+            const error = new TemplateError('template failed', 'template.yaml');
+            expect(error.message).toBe('template failed');
+            expect(error.code).toBe(ErrorCode.TEMPLATE_ERROR);
+            expect(error.name).toBe('TemplateError');
+            expect(error.details).toEqual({ templatePath: 'template.yaml' });
+        });
+    });
+    describe('ProjectStructureError', () => {
+        it('creates project structure error with defaults', () => {
+            const error = new ProjectStructureError('project invalid');
+            expect(error.message).toBe('project invalid');
+            expect(error.code).toBe(ErrorCode.PROJECT_STRUCTURE_INVALID);
+            expect(error.name).toBe('ProjectStructureError');
+            expect(error.suggestions).toEqual([
+                'Ensure you are in a valid ARK project directory',
+                'Run "ark generate project" to create a new project',
+                'Check that Chart.yaml and agents/ directory exist',
+            ]);
+        });
+        it('creates project structure error with path', () => {
+            const error = new ProjectStructureError('project invalid', '/path/to/project');
+            expect(error.message).toBe('project invalid');
+            expect(error.code).toBe(ErrorCode.PROJECT_STRUCTURE_INVALID);
+            expect(error.details).toEqual({ projectPath: '/path/to/project' });
+        });
+    });
+    describe('ErrorHandler', () => {
+        it('formats basic error', () => {
+            const error = new Error('simple error');
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('❌ simple error');
+        });
+        it('formats ArkError with details and suggestions', () => {
+            const error = new ArkError('test error', ErrorCode.INVALID_INPUT, { field: 'name', value: 'test' }, ['Fix the input', 'Try again']);
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('❌ test error');
+            expect(formatted).toContain('Details:');
+            expect(formatted).toContain('field: name');
+            expect(formatted).toContain('value: test');
+            expect(formatted).toContain('💡 Suggestions:');
+            expect(formatted).toContain('• Fix the input');
+            expect(formatted).toContain('• Try again');
+        });
+        it('includes stack trace in debug mode', () => {
+            process.env.DEBUG = 'true';
+            const error = new Error('debug error');
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('Stack trace:');
+            delete process.env.DEBUG;
+        });
+        it('handles missing stack trace', () => {
+            process.env.NODE_ENV = 'development';
+            const error = new Error('no stack');
+            error.stack = undefined;
+            const formatted = ErrorHandler.formatError(error);
+            expect(formatted).toContain('No stack trace available');
+            delete process.env.NODE_ENV;
+        });
+        describe('handleAndExit', () => {
+            let mockExit;
+            let mockConsoleError;
+            beforeEach(() => {
+                mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+                    throw new Error('process.exit');
+                });
+                mockConsoleError = jest
+                    .spyOn(console, 'error')
+                    .mockImplementation(() => { });
+            });
+            afterEach(() => {
+                mockExit.mockRestore();
+                mockConsoleError.mockRestore();
+            });
+            it('exits with code 22 for validation errors', () => {
+                const error = new ValidationError('invalid');
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(22);
+            });
+            it('exits with code 2 for file not found', () => {
+                const error = new ArkError('not found', ErrorCode.FILE_NOT_FOUND);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(2);
+            });
+            it('exits with code 13 for permission denied', () => {
+                const error = new ArkError('denied', ErrorCode.PERMISSION_DENIED);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(13);
+            });
+            it('exits with code 127 for missing dependency', () => {
+                const error = new ArkError('missing', ErrorCode.DEPENDENCY_MISSING);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(127);
+            });
+            it('exits with code 1 for unknown errors', () => {
+                const error = new Error('unknown');
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(1);
+            });
+            it('exits with code 1 for default ArkError', () => {
+                const error = new ArkError('general', ErrorCode.UNKNOWN_ERROR);
+                expect(() => ErrorHandler.handleAndExit(error)).toThrow('process.exit');
+                expect(mockExit).toHaveBeenCalledWith(1);
+            });
+        });
+        describe('catchAndHandle', () => {
+            it('returns successful promise result', async () => {
+                const result = await ErrorHandler.catchAndHandle(async () => 'success');
+                expect(result).toBe('success');
+            });
+            it('rethrows ArkError unchanged', async () => {
+                const arkError = new ValidationError('test');
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw arkError;
+                })).rejects.toThrow(arkError);
+            });
+            it('wraps generic errors with context', async () => {
+                const error = new Error('generic');
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw error;
+                }, 'context')).rejects.toThrow('context: generic');
+            });
+            it('wraps non-Error objects', async () => {
+                await expect(ErrorHandler.catchAndHandle(async () => {
+                    throw 'string error';
+                })).rejects.toThrow('string error');
+            });
+        });
+    });
+    describe('InputValidator', () => {
+        describe('validateName', () => {
+            it('accepts valid names', () => {
+                expect(() => InputValidator.validateName('valid-name')).not.toThrow();
+                expect(() => InputValidator.validateName('test123')).not.toThrow();
+                expect(() => InputValidator.validateName('a-b-c-123')).not.toThrow();
+            });
+            it('rejects empty names', () => {
+                expect(() => InputValidator.validateName('')).toThrow('name cannot be empty');
+                expect(() => InputValidator.validateName('   ')).toThrow('name cannot be empty');
+            });
+            it('rejects names over 63 characters', () => {
+                const longName = 'a'.repeat(64);
+                expect(() => InputValidator.validateName(longName)).toThrow('must be 63 characters or less');
+            });
+            it('rejects invalid characters', () => {
+                expect(() => InputValidator.validateName('Invalid Name')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('test_name')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('-start')).toThrow('Invalid name');
+                expect(() => InputValidator.validateName('end-')).toThrow('Invalid name');
+            });
+            it('suggests normalized names', () => {
+                try {
+                    InputValidator.validateName('TestName');
+                }
+                catch (e) {
+                    expect(e.suggestions).toContain('Try: "test-name"');
+                }
+            });
+        });
+        describe('validatePath', () => {
+            it('accepts valid paths', () => {
+                expect(() => InputValidator.validatePath('/valid/path')).not.toThrow();
+                expect(() => InputValidator.validatePath('./relative')).not.toThrow();
+                expect(() => InputValidator.validatePath('simple')).not.toThrow();
+            });
+            it('rejects empty paths', () => {
+                expect(() => InputValidator.validatePath('')).toThrow('path cannot be empty');
+            });
+            it('rejects dangerous paths', () => {
+                expect(() => InputValidator.validatePath('../parent')).toThrow('unsafe characters');
+                expect(() => InputValidator.validatePath('~/home')).toThrow('unsafe characters');
+                expect(() => InputValidator.validatePath('$HOME/test')).toThrow('unsafe characters');
+            });
+        });
+        describe('validateDirectory', () => {
+            it('validates path first', () => {
+                expect(() => InputValidator.validateDirectory('')).toThrow('directory cannot be empty');
+            });
+        });
+    });
+});

package/dist/lib/exec.d.ts

@@ -1,5 +1 @@
-export declare function executeCommand(command: string, args?: string[]): Promise<{
-    stdout: string;
-    stderr: string;
-}>;
 export declare function fileExists(path: string): boolean;

package/dist/lib/exec.js

@@ -1,15 +1,4 @@
 import fs from 'fs';
-import { execa } from 'execa';
-export async function executeCommand(command, args = []) {
-    try {
-        const result = await execa(command, args);
-        return { stdout: result.stdout, stderr: result.stderr };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${errorMessage}`);
-    }
-}
 export function fileExists(path) {
     try {
         return fs.existsSync(path);

package/dist/lib/executeQuery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared query execution logic for both universal and resource-specific query commands
+ */
+import type { QueryTarget } from './types.js';
+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 QueryTarget or null if invalid
+ */
+export declare function parseTarget(target: string): QueryTarget | null;

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.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 {};