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

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

@@ -0,0 +1,78 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockLoadConfig = jest.fn();
+const mockGetConfigPaths = jest.fn();
+const mockFormatConfig = jest.fn();
+jest.unstable_mockModule('../../lib/config.js', () => ({
+    loadConfig: mockLoadConfig,
+    getConfigPaths: mockGetConfigPaths,
+    formatConfig: mockFormatConfig,
+}));
+const mockExistsSync = jest.fn();
+jest.unstable_mockModule('fs', () => ({
+    default: {
+        existsSync: mockExistsSync,
+    },
+    existsSync: mockExistsSync,
+}));
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createConfigCommand } = await import('./index.js');
+describe('config command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Reset environment variables
+        delete process.env.ARK_CHAT_STREAMING;
+        delete process.env.ARK_CHAT_OUTPUT_FORMAT;
+    });
+    it('creates command with correct structure', () => {
+        const command = createConfigCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('config');
+    });
+    it('displays config paths and environment variables', async () => {
+        const mockConfig = { defaultModel: 'test-model' };
+        const mockPaths = {
+            user: '/home/user/.arkrc.yaml',
+            project: '/project/.arkrc.yaml',
+        };
+        mockLoadConfig.mockReturnValue(mockConfig);
+        mockGetConfigPaths.mockReturnValue(mockPaths);
+        mockFormatConfig.mockReturnValue('formatted config');
+        mockExistsSync.mockReturnValue(true);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockLoadConfig).toHaveBeenCalled();
+        expect(mockGetConfigPaths).toHaveBeenCalled();
+        expect(mockFormatConfig).toHaveBeenCalledWith(mockConfig);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.user);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.project);
+    });
+    it('shows when config files do not exist', async () => {
+        const mockPaths = {
+            user: '/home/user/.arkrc.yaml',
+            project: '/project/.arkrc.yaml',
+        };
+        mockLoadConfig.mockReturnValue({});
+        mockGetConfigPaths.mockReturnValue(mockPaths);
+        mockFormatConfig.mockReturnValue('');
+        mockExistsSync.mockReturnValue(false);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.user);
+        expect(mockExistsSync).toHaveBeenCalledWith(mockPaths.project);
+        // Should show that files don't exist
+        expect(mockConsoleLog).toHaveBeenCalled();
+    });
+    it('displays environment variables when set', async () => {
+        process.env.ARK_CHAT_STREAMING = 'true';
+        process.env.ARK_CHAT_OUTPUT_FORMAT = 'json';
+        mockLoadConfig.mockReturnValue({});
+        mockGetConfigPaths.mockReturnValue({ user: '', project: '' });
+        mockFormatConfig.mockReturnValue('');
+        mockExistsSync.mockReturnValue(false);
+        const command = createConfigCommand({});
+        await command.parseAsync(['node', 'test']);
+        // Should display the environment variables
+        expect(mockConsoleLog).toHaveBeenCalled();
+    });
+});

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

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

package/dist/commands/dashboard/index.js

@@ -30,7 +30,7 @@ export async function openDashboard() {
         process.exit(1);
     }
 }
-export function createDashboardCommand() {
+export function createDashboardCommand(_) {
     const dashboardCommand = new Command('dashboard');
     dashboardCommand
         .description('Open the ARK dashboard in your browser')

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

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

package/dist/commands/dev/index.js

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { createToolCommand } from './tool/index.js';
-export function createDevCommand() {
+export function createDevCommand(_) {
     const devCommand = new Command('dev');
     devCommand.description('Development tools for ARK');
     // Add subcommands

package/dist/commands/dev/tool-generate.spec.d.ts

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

package/dist/commands/dev/tool-generate.spec.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import os from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('ark dev tool generate', () => {
+    let tempDir;
+    const cliPath = path.join(__dirname, '../../../dist/index.js');
+    beforeEach(() => {
+        // Create a temp directory for testing
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ark-test-'));
+    });
+    afterEach(() => {
+        // Clean up temp directory
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('Dockerfile generation', () => {
+        it('should generate correct Dockerfile for pyproject type', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  path: ${tempDir}
+  platform: python3
+  type: pyproject
+  name: test-tool
+  version: 0.2.0
+  framework: fastmcp
+  frameworkVersion: 0.5.0
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check Dockerfile was generated
+            const dockerfilePath = path.join(tempDir, 'Dockerfile');
+            expect(fs.existsSync(dockerfilePath)).toBe(true);
+            // Check Dockerfile content
+            const dockerfileContent = fs.readFileSync(dockerfilePath, 'utf-8');
+            // Should have uv commands for pyproject
+            expect(dockerfileContent).toContain('RUN pip install uv');
+            expect(dockerfileContent).toContain('COPY pyproject.toml ./');
+            expect(dockerfileContent).toContain('COPY uv.lock* ./');
+            expect(dockerfileContent).toContain('RUN uv sync --frozen');
+            expect(dockerfileContent).toContain('CMD ["uv", "run", "python", "-m", "test_tool"]');
+            // Should NOT have requirements.txt commands
+            expect(dockerfileContent).not.toContain('requirements.txt');
+            expect(dockerfileContent).not.toContain('pip install --no-cache-dir');
+        });
+        it('should generate correct Dockerfile for requirements type', () => {
+            // Create a test .ark.yaml with requirements type
+            const arkYaml = `version: "1.0"
+project:
+  path: ${tempDir}
+  platform: python3
+  type: requirements
+  name: test-req-tool
+  version: 0.1.0
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check Dockerfile was generated
+            const dockerfilePath = path.join(tempDir, 'Dockerfile');
+            expect(fs.existsSync(dockerfilePath)).toBe(true);
+            // Check Dockerfile content
+            const dockerfileContent = fs.readFileSync(dockerfilePath, 'utf-8');
+            // Should have pip commands for requirements.txt
+            expect(dockerfileContent).toContain('COPY requirements.txt ./');
+            expect(dockerfileContent).toContain('RUN pip install --no-cache-dir -r requirements.txt');
+            expect(dockerfileContent).toContain('CMD ["python", "-m", "test_req_tool"]');
+            // Should NOT have uv commands
+            expect(dockerfileContent).not.toContain('RUN pip install uv');
+            expect(dockerfileContent).not.toContain('pyproject.toml');
+            expect(dockerfileContent).not.toContain('uv.lock');
+            expect(dockerfileContent).not.toContain('uv sync');
+        });
+    });
+    describe('.dockerignore generation', () => {
+        it('should generate comprehensive .dockerignore file', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  platform: python3
+  type: pyproject
+  name: test-tool
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check .dockerignore was generated
+            const dockerignorePath = path.join(tempDir, '.dockerignore');
+            expect(fs.existsSync(dockerignorePath)).toBe(true);
+            // Check .dockerignore content
+            const dockerignoreContent = fs.readFileSync(dockerignorePath, 'utf-8');
+            // Should include Python patterns
+            expect(dockerignoreContent).toContain('__pycache__/');
+            expect(dockerignoreContent).toContain('*.py[cod]');
+            expect(dockerignoreContent).toContain('*.egg-info/');
+            // Should include UV patterns
+            expect(dockerignoreContent).toContain('.venv/');
+            // Should include testing patterns
+            expect(dockerignoreContent).toContain('.pytest_cache/');
+            expect(dockerignoreContent).toContain('.coverage');
+            // Should include IDE patterns
+            expect(dockerignoreContent).toContain('.vscode/');
+            expect(dockerignoreContent).toContain('.idea/');
+            // Should include ARK specific patterns
+            expect(dockerignoreContent).toContain('.ark.yaml');
+            expect(dockerignoreContent).toContain('devspace.yaml');
+        });
+    });
+    describe('file skip behavior', () => {
+        it('should skip existing files without overwriting', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  platform: python3
+  type: pyproject
+  name: test-tool
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Create an existing Dockerfile with custom content
+            const customDockerfile = '# My custom Dockerfile\nFROM alpine\n';
+            fs.writeFileSync(path.join(tempDir, 'Dockerfile'), customDockerfile);
+            // Run the generate command
+            const output = execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check that existing file was not overwritten
+            const dockerfileContent = fs.readFileSync(path.join(tempDir, 'Dockerfile'), 'utf-8');
+            expect(dockerfileContent).toBe(customDockerfile);
+            // Check that output mentions skipping the existing file
+            expect(output).toContain('Skipping Dockerfile (already exists)');
+        });
+    });
+    describe('error handling', () => {
+        it('should fail when .ark.yaml is missing', () => {
+            // Try to run generate without .ark.yaml
+            let error = null;
+            try {
+                execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                });
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).not.toBeNull();
+            expect(error.message).toContain('.ark.yaml not found');
+        });
+    });
+});

package/dist/commands/dev/tool.spec.d.ts

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

package/dist/commands/dev/tool.spec.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from '@jest/globals';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('sample-projects', () => {
+    describe('reverse-tool', () => {
+        it('should output correct MCP tool format in JSON', () => {
+            const projectPath = path.join(__dirname, '../../../samples/reverse_tool');
+            const cliPath = path.join(__dirname, '../../../dist/index.js');
+            // Run the command and capture output
+            const output = execSync(`node ${cliPath} dev tool check ${projectPath} --output json`, { encoding: 'utf8' });
+            // Parse the JSON output
+            const result = JSON.parse(output);
+            // Assert the structure
+            expect(result).toHaveProperty('path');
+            expect(result).toHaveProperty('projectRoot');
+            expect(result.projectRoot).toContain('reverse_tool');
+            expect(result).toHaveProperty('platform', 'python3');
+            expect(result).toHaveProperty('projectType', 'pyproject');
+            expect(result).toHaveProperty('projectName', 'reverse-tool');
+            expect(result).toHaveProperty('projectVersion', '0.1.0');
+            expect(result).toHaveProperty('hasFastmcp', true);
+            expect(result).toHaveProperty('fastmcpVersion', '0.5.0');
+            expect(result).toHaveProperty('tools');
+            // Assert tools array contains MCP-formatted tool
+            expect(result.tools).toHaveLength(1);
+            const tool = result.tools[0];
+            // Check MCP tool structure
+            expect(tool).toHaveProperty('name', 'reverse_message');
+            expect(tool).toHaveProperty('title', 'Reverse Message');
+            expect(tool).toHaveProperty('description', 'Reverses the text of a message');
+            expect(tool).toHaveProperty('inputSchema');
+            // Check inputSchema structure
+            expect(tool.inputSchema).toEqual({
+                type: 'object',
+                properties: {
+                    message: {
+                        type: 'string',
+                        description: 'Parameter message',
+                    },
+                },
+                required: ['message'],
+            });
+        });
+    });
+});

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/generate/generators/project.js

@@ -8,7 +8,7 @@ import { TemplateDiscovery } from '../templateDiscovery.js';
 import { toKebabCase, validateNameStrict, isValidKubernetesName, } from '../utils/nameUtils.js';
 import { getInquirerProjectTypeChoices, GENERATOR_DEFAULTS, CLI_CONFIG, } from '../config.js';
 import { SecurityUtils } from '../../../lib/security.js';
-import { EnhancedPrompts, ProgressIndicator } from '../../../lib/progress.js';
+import ora from 'ora';
 export function createProjectGenerator() {
     return {
         name: 'project',
@@ -38,61 +38,40 @@ class ProjectGenerator {
         }
     }
     async generate(name, destination, options) {
-        const progress = new ProgressIndicator('ARK Agent Project Generator');
-        // Add steps to progress indicator
-        progress.addStep('prerequisites', 'Checking prerequisites');
-        progress.addStep('configuration', 'Gathering project configuration');
-        if (!options.skipModels) {
-            progress.addStep('models', 'Configuring model providers');
-        }
-        if (!options.skipGit) {
-            progress.addStep('git', 'Setting up git repository');
-        }
-        progress.addStep('generation', 'Generating project files');
-        progress.addStep('completion', 'Finalizing project setup');
+        console.log(chalk.blue(`\n🚀 ARK Agent Project Generator\n`));
+        const spinner = ora('Checking prerequisites').start();
         try {
             // Check prerequisites
-            progress.startStep('prerequisites');
             await this.checkPrerequisites();
-            progress.completeStep('prerequisites', 'Prerequisites validated');
+            spinner.succeed('Prerequisites validated');
             // Get project configuration
-            progress.startStep('configuration');
+            spinner.start('Gathering project configuration');
             const config = await this.getProjectConfig(name, destination, options);
-            progress.completeStep('configuration', `Project "${config.name}" configured`);
+            spinner.succeed(`Project "${config.name}" configured`);
             // Discover and configure models (only if not skipped)
             if (config.configureModels) {
-                progress.startStep('models');
+                spinner.start('Configuring model providers');
                 await this.configureModels(config);
-                progress.completeStep('models', `Model provider: ${config.selectedModels || 'none'}`);
-            }
-            else {
-                progress.skipStep('models', 'Model configuration skipped');
+                spinner.succeed(`Model provider: ${config.selectedModels || 'none'}`);
             }
             // Configure git if requested (only if not skipped)
             if (config.initGit) {
-                progress.startStep('git');
+                spinner.start('Setting up git repository');
                 await this.configureGit(config);
-                progress.completeStep('git', 'Git repository configured');
-            }
-            else {
-                progress.skipStep('git', 'Git setup skipped');
+                spinner.succeed('Git repository configured');
             }
             // Generate the project
-            progress.startStep('generation');
+            spinner.start('Generating project files');
             await this.generateProject(config);
-            progress.completeStep('generation', 'Project files created');
+            spinner.succeed('Project files created');
             // Finalize
-            progress.startStep('completion');
+            spinner.start('Finalizing project setup');
             this.showNextSteps(config);
-            progress.completeStep('completion', 'Project ready');
-            progress.complete('Project generation');
+            spinner.succeed('Project ready');
+            console.log(chalk.green(`\n✅ Project generation completed\n`));
         }
         catch (error) {
-            // Find the current step and mark it as failed
-            const currentStep = progress['steps'].find((s) => s.status === 'running');
-            if (currentStep) {
-                progress.failStep(currentStep.name, `Failed: ${error instanceof Error ? error.message : String(error)}`);
-            }
+            spinner.fail(`Failed: ${error instanceof Error ? error.message : String(error)}`);
             throw error;
         }
     }
@@ -105,7 +84,7 @@ class ProjectGenerator {
         }
         catch {
             requirements.push({ tool: 'git', available: false, required: false });
-            EnhancedPrompts.showWarning('Git not found - git features will be disabled');
+            console.log(chalk.yellow('⚠️  Warning: Git not found - git features will be disabled'));
         }
         // Check for deployment tools (optional for project generation)
         const deploymentTools = ['kubectl', 'helm'];
@@ -121,12 +100,14 @@ class ProjectGenerator {
             }
         }
         if (missingDeploymentTools.length > 0) {
-            EnhancedPrompts.showInfo(`Optional tools not found: ${missingDeploymentTools.join(', ')}`);
-            EnhancedPrompts.showTip('Install kubectl and helm later to deploy your project to a cluster');
+            console.log(chalk.blue(`ℹ️  Optional tools not found: ${missingDeploymentTools.join(', ')}`));
+            console.log(chalk.cyan('💡 Tip: Install kubectl and helm later to deploy your project to a cluster'));
         }
     }
     async getProjectConfig(name, destination, options) {
-        EnhancedPrompts.showSeparator('Project Configuration');
+        console.log(chalk.gray(`\n${'─'.repeat(50)}`));
+        console.log(chalk.cyan('Project Configuration'));
+        console.log(chalk.gray(`${'─'.repeat(50)}\n`));
         // Use command line options if provided, otherwise prompt
         let projectType = options.projectType;
         let parentDir = destination;

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

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import type { ArkConfig } from '../../lib/config.js';
 export interface GeneratorOptions {
     name?: string;
     destination?: string;
@@ -21,4 +22,4 @@ export interface Generator {
     templatePath: string;
     generate(name: string, destination: string, options: GeneratorOptions): Promise<void>;
 }
-export declare function createGenerateCommand(): Command;
+export declare function createGenerateCommand(_: ArkConfig): Command;

package/dist/commands/generate/index.js

@@ -22,7 +22,7 @@ function getDefaultDestination() {
         return process.cwd();
     }
 }
-export function createGenerateCommand() {
+export function createGenerateCommand(_) {
     const generate = new Command('generate');
     generate
         .alias('g')

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

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