@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/commands/completion/index.js

@@ -0,0 +1,230 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+export function createCompletionCommand(_) {
+    const completion = new Command('completion');
+    completion.description('Generate shell completion scripts').action(() => {
+        console.log(chalk.cyan('Shell completion for ARK CLI'));
+        console.log('');
+        console.log('Usage:');
+        console.log('  ark completion bash   Generate bash completion script');
+        console.log('  ark completion zsh    Generate zsh completion script');
+        console.log('');
+        console.log('To enable completion, add this to your shell profile:');
+        console.log(chalk.grey('  # For bash:'));
+        console.log(chalk.grey('  eval "$(ark completion bash)"'));
+        console.log(chalk.grey('  # For zsh:'));
+        console.log(chalk.grey('  eval "$(ark completion zsh)"'));
+    });
+    completion
+        .command('bash')
+        .description('Generate bash completion script')
+        .action(() => {
+        console.log(`
+_ark_completion() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  
+  case \${COMP_CWORD} in
+    1)
+      opts="agents chat cluster completion config dashboard docs generate install models query routes status targets teams tools uninstall help"
+      COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+      return 0
+      ;;
+    2)
+      case \${prev} in
+        cluster)
+          opts="get-ip get-type"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        completion)
+          opts="bash zsh"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        check)
+          opts="status"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        targets)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        agents)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        models)
+          opts="list ls create"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        teams)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        tools)
+          opts="list ls"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        generate)
+          opts="agent marketplace mcp-server project query team"
+          COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+          return 0
+          ;;
+        chat)
+          # Dynamically fetch available targets using ark targets list
+          local targets
+          targets=$(ark targets list 2>/dev/null)
+          if [ -z "$targets" ]; then
+            # Fallback to common targets if API is not available
+            targets="agent/sample-agent agent/math agent/weather model/default"
+          fi
+          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
+      ;;
+  esac
+}
+
+complete -F _ark_completion ark
+      `.trim());
+    });
+    completion
+        .command('zsh')
+        .description('Generate zsh completion script')
+        .action(() => {
+        // Shell script requires escaped $ characters
+        /* eslint-disable no-useless-escape */
+        console.log(`
+#compdef ark
+
+_ark() {
+  local context state line
+  
+  _arguments -C \\
+    '1:command:->command' \\
+    '2:subcommand:->subcommand' \\
+    '*::arg:->args'
+    
+  case $state in
+    command)
+      _values 'ark commands' \\
+        'agents[List available agents]' \\
+        'chat[Interactive chat with agents and models]' \\
+        'cluster[Cluster management commands]' \\
+        'completion[Generate shell completion scripts]' \\
+        'config[Configuration management]' \\
+        'dashboard[Open ARK dashboard]' \\
+        '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]' \\
+        'teams[List available teams]' \\
+        'tools[List available tools]' \\
+        'uninstall[Uninstall ARK services]' \\
+        'help[Show help information]'
+      ;;
+    subcommand)
+      case $words[2] in
+        cluster)
+          _values 'cluster commands' \\
+            'get-ip[Get cluster IP address]' \\
+            'get-type[Get cluster type]'
+          ;;
+        completion)
+          _values 'completion shells' \\
+            'bash[Generate bash completion]' \\
+            'zsh[Generate zsh completion]'
+          ;;
+        check)
+          _values 'check commands' \\
+            'status[Check system status]'
+          ;;
+        targets)
+          _values 'targets commands' \\
+            'list[List all available targets]' \\
+            'ls[List all available targets]'
+          ;;
+        agents)
+          _values 'agents commands' \\
+            'list[List all available agents]' \\
+            'ls[List all available agents]'
+          ;;
+        models)
+          _values 'models commands' \\
+            'list[List all available models]' \\
+            'ls[List all available models]' \\
+            'create[Create a new model]'
+          ;;
+        teams)
+          _values 'teams commands' \\
+            'list[List all available teams]' \\
+            'ls[List all available teams]'
+          ;;
+        tools)
+          _values 'tools commands' \\
+            'list[List all available tools]' \\
+            'ls[List all available tools]'
+          ;;
+        generate)
+          _values 'generate types' \\
+            'agent[Generate a new agent]' \\
+            'marketplace[Generate marketplace content]' \\
+            'mcp-server[Generate MCP server]' \\
+            'project[Generate a new project]' \\
+            'query[Generate a query]' \\
+            'team[Generate a team]'
+          ;;
+        chat)
+          # Get available targets dynamically
+          local -a targets
+          targets=($(ark targets list 2>/dev/null))
+          if [ \${#targets[@]} -eq 0 ]; then
+            targets=('agent/sample-agent' 'agent/math' 'agent/weather' 'model/default')
+          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
+      ;;
+  esac
+}
+
+_ark
+      `.trim());
+        /* eslint-enable no-useless-escape */
+    });
+    return completion;
+}

package/dist/commands/completion/index.spec.d.ts

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

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

@@ -0,0 +1,34 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+const { createCompletionCommand } = await import('./index.js');
+describe('completion command', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('creates command with correct structure', () => {
+        const command = createCompletionCommand({});
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('completion');
+    });
+    it('shows help when called without subcommand', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test']);
+        // Check first call contains the title (strip ANSI color codes)
+        expect(mockConsoleLog.mock.calls[0][0]).toContain('Shell completion for ARK CLI');
+        // Check that bash completion instructions are shown
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('ark completion bash'));
+    });
+    it('outputs bash completion script', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test', 'bash']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('_ark_completion()'));
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('COMPREPLY'));
+    });
+    it('outputs zsh completion script', async () => {
+        const command = createCompletionCommand({});
+        await command.parseAsync(['node', 'test', 'zsh']);
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('#compdef ark'));
+        expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('_ark()'));
+    });
+});

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

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

package/dist/commands/config/index.js

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig, getConfigPaths, formatConfig, } from '../../lib/config.js';
+import fs from 'fs';
+export function createConfigCommand(_) {
+    const configCommand = new Command('config');
+    configCommand.description('Show current configuration').action(() => {
+        const config = loadConfig();
+        const paths = getConfigPaths();
+        console.log();
+        // User config
+        if (fs.existsSync(paths.user)) {
+            console.log(chalk.green('✓'), chalk.white(paths.user));
+        }
+        else {
+            console.log(chalk.red('✗'), chalk.white(paths.user), chalk.gray(`doesn't exist`));
+        }
+        // Project config
+        if (fs.existsSync(paths.project)) {
+            console.log(chalk.green('✓'), chalk.white(paths.project));
+        }
+        else {
+            console.log(chalk.red('✗'), chalk.white(paths.project), chalk.gray(`doesn't exist`));
+        }
+        // Environment variables
+        if (process.env.ARK_CHAT_STREAMING !== undefined) {
+            console.log(chalk.green('✓'), chalk.white('ARK_CHAT_STREAMING'), chalk.gray(process.env.ARK_CHAT_STREAMING));
+        }
+        else {
+            console.log(chalk.red('✗'), chalk.white('ARK_CHAT_STREAMING'), chalk.gray('not set'));
+        }
+        if (process.env.ARK_CHAT_OUTPUT_FORMAT !== undefined) {
+            console.log(chalk.green('✓'), chalk.white('ARK_CHAT_OUTPUT_FORMAT'), chalk.gray(process.env.ARK_CHAT_OUTPUT_FORMAT));
+        }
+        else {
+            console.log(chalk.red('✗'), chalk.white('ARK_CHAT_OUTPUT_FORMAT'), chalk.gray('not set'));
+        }
+        console.log();
+        console.log(formatConfig(config));
+    });
+    return configCommand;
+}

package/dist/commands/config/index.spec.d.ts

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

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

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

package/dist/commands/dashboard/index.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import open from 'open';
+import ora from 'ora';
+import { ArkServiceProxy } from '../../lib/arkServiceProxy.js';
+import { arkServices } from '../../arkServices.js';
+export async function openDashboard() {
+    const spinner = ora('Connecting to dashboard').start();
+    try {
+        const dashboardService = arkServices['ark-dashboard'];
+        const proxy = new ArkServiceProxy(dashboardService, 3274); // DASH on phone keypad
+        const url = await proxy.start();
+        spinner.succeed('Dashboard connected');
+        console.log(`ARK dashboard running on: ${chalk.green(url)}`);
+        console.log(chalk.gray('Press Ctrl+C to stop'));
+        // Brief pause before opening browser
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        // Open browser
+        await open(url);
+        // Handle Ctrl+C gracefully
+        process.on('SIGINT', () => {
+            proxy.stop();
+            process.exit(0);
+        });
+        // Keep process alive
+        process.stdin.resume();
+    }
+    catch (error) {
+        spinner.fail(error instanceof Error ? error.message : 'Failed to start dashboard');
+        process.exit(1);
+    }
+}
+export function createDashboardCommand(_) {
+    const dashboardCommand = new Command('dashboard');
+    dashboardCommand
+        .description('Open the ARK dashboard in your browser')
+        .action(openDashboard);
+    return dashboardCommand;
+}

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/config.js

@@ -2,7 +2,6 @@
  * Shared configuration for generators across CLI and UI
  */
 import path from 'path';
-import { ConfigManager } from '../../lib/config.js';
 /**
  * Project type choices - shared between CLI and UI
  */
@@ -70,36 +69,18 @@ export const GENERATOR_CHOICES = [
  */
 export const GENERATOR_DEFAULTS = {
     get projectType() {
-        try {
-            const configManager = new ConfigManager();
-            return configManager.get('defaultProjectType');
-        }
-        catch {
-            return 'with-samples';
-        }
+        return 'with-samples';
     },
     get skipModels() {
-        try {
-            const configManager = new ConfigManager();
-            return configManager.get('skipModelsbyDefault');
-        }
-        catch {
-            return false;
-        }
+        return false;
     },
     get skipGit() {
-        try {
-            const configManager = new ConfigManager();
-            return configManager.get('skipGitByDefault');
-        }
-        catch {
-            return false;
-        }
+        return false;
     },
     getDefaultDestination: () => {
         try {
-            const configManager = new ConfigManager();
-            const configured = configManager.get('defaultDestination');
+            // Return current working directory as default
+            const configured = null;
             if (configured && configured !== process.cwd()) {
                 return configured;
             }

package/dist/commands/generate/generators/mcpserver.d.ts

@@ -1,3 +1,4 @@
+import type { GeneratorOptions } from '../index.js';
 export interface McpServerConfig {
     mcpServerName: string;
     description: string;
@@ -21,5 +22,5 @@ export declare function createMcpServerGenerator(): {
     name: string;
     description: string;
     templatePath: string;
-    generate: (name: string, destination: string, options: any) => Promise<void>;
+    generate: (name: string, destination: string, options: GeneratorOptions) => Promise<void>;
 };

package/dist/commands/generate/generators/mcpserver.js

@@ -159,7 +159,7 @@ class McpServerGenerator {
         // Get tool definitions
         const tools = await this.getToolDefinitions();
         // Check if destination exists
-        if (fs.existsSync(answers.destination)) {
+        if (answers.destination && fs.existsSync(answers.destination)) {
             const overwrite = await inquirer.prompt([
                 {
                     type: 'confirm',
@@ -174,9 +174,18 @@ class McpServerGenerator {
             }
         }
         return {
-            ...answers,
+            mcpServerName: answers.mcpServerName || name,
+            description: answers.description || '',
+            technology: answers.technology || 'node',
+            packageSource: answers.packageSource || 'local',
+            packageName: answers.packageName,
+            destination: answers.destination || defaultDestination,
+            requiresAuth: answers.requiresAuth || false,
+            hasCustomConfig: answers.hasCustomConfig || false,
+            maintainerName: answers.maintainerName || '',
+            homeUrl: answers.homeUrl,
             tools,
-            packageManager: this.getPackageManager(answers.technology),
+            packageManager: this.getPackageManager(answers.technology || 'node'),
             sourceUrls: answers.homeUrl ? [answers.homeUrl] : [],
             sampleQuery: this.generateSampleQuery(tools),
         };
@@ -307,7 +316,19 @@ class McpServerGenerator {
             }
             // Generate from template
             // Set template variables using the same structure expected by templates
-            this.templateEngine.setVariables(config);
+            // Convert config to template variables format
+            const templateVars = {};
+            Object.entries(config).forEach(([key, value]) => {
+                if (typeof value === 'string' ||
+                    typeof value === 'number' ||
+                    typeof value === 'boolean') {
+                    templateVars[key] = value;
+                }
+                else {
+                    templateVars[key] = JSON.stringify(value);
+                }
+            });
+            this.templateEngine.setVariables(templateVars);
             await this.templateEngine.processTemplate(templatePath, config.destination);
             // Make build script executable (owner only for security)
             const buildScriptPath = path.join(config.destination, 'build.sh');
@@ -317,7 +338,7 @@ class McpServerGenerator {
             console.log(chalk.green(`✅ MCP server generated successfully at ${config.destination}`));
         }
         catch (error) {
-            console.error(chalk.red('Failed to generate MCP server:'), error.message);
+            console.error(chalk.red('Failed to generate MCP server:'), error instanceof Error ? error.message : 'Unknown error');
             process.exit(1);
         }
     }