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

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

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

package/dist/commands/cluster/index.js

@@ -1,8 +1,10 @@
 import { Command } from 'commander';
-import { createGetCommand } from './get.js';
-export function createClusterCommand(_) {
+import { createGetIpCommand } from './get-ip.js';
+import { createGetTypeCommand } from './get-type.js';
+export function createClusterCommand() {
     const cluster = new Command('cluster');
     cluster.description('Cluster management commands');
-    cluster.addCommand(createGetCommand());
+    cluster.addCommand(createGetTypeCommand());
+    cluster.addCommand(createGetIpCommand());
     return cluster;
 }

package/dist/commands/completion.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="cluster completion check help"
       COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
       return 0
       ;;
@@ -49,81 +49,6 @@ _ark_completion() {
           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
-          ;;
-        dev)
-          opts="tool"
-          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
-          ;;
-      esac
-      ;;
-    3)
-      case \${COMP_WORDS[1]} in
-        dev)
-          case \${prev} in
-            tool)
-              opts="check init generate"
-              COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
-              return 0
-              ;;
-          esac
-          ;;
-      esac
-      ;;
-    4)
-      # Handle path completion for dev tool commands
-      case \${COMP_WORDS[1]} in
-        dev)
-          if [[ \${COMP_WORDS[2]} == "tool" ]]; then
-            case \${COMP_WORDS[3]} in
-              check|init|generate)
-                # Complete with directories
-                COMPREPLY=( $(compgen -d -- \${cur}) )
-                return 0
-                ;;
-            esac
-          fi
-          ;;
       esac
       ;;
   esac
@@ -150,22 +75,9 @@ _ark() {
   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]' \\
-        'dev[Development tools for ARK]' \\
-        'generate[Generate ARK resources]' \\
-        'install[Install ARK services]' \\
-        'models[List available models]' \\
-        '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]' \\
+        'check[Check system components]' \\
         'help[Show help information]'
       ;;
     subcommand)
@@ -184,75 +96,6 @@ _ark() {
           _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]'
-          ;;
-        dev)
-          _values 'dev commands' \\
-            'tool[MCP tool development utilities]'
-          ;;
-        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[@]}
-          ;;
-      esac
-      ;;
-    args)
-      case \$words[2] in
-        dev)
-          if [[ \$words[3] == "tool" ]]; then
-            case \$words[4] in
-              check|init|generate)
-                # Complete with directories
-                _files -/
-                ;;
-              *)
-                _values 'tool commands' \\
-                  'check[Check the status of an MCP tool project]' \\
-                  'init[Initialize an MCP tool project]' \\
-                  'generate[Generate project files from templates]' \\
-                  'clean[Remove template-generated files]'
-                ;;
-            esac
-          fi
-          ;;
       esac
       ;;
   esac

package/dist/commands/config.d.ts

@@ -1,2 +1,5 @@
+/**
+ * Configuration management commands for ARK CLI
+ */
 import { Command } from 'commander';
 export declare function createConfigCommand(): Command;

package/dist/commands/config.js

@@ -1,44 +1,327 @@
+/**
+ * Configuration management commands for ARK CLI
+ */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { loadConfig, getConfigPaths, formatConfig } from '../lib/config.js';
-import fs from 'fs';
+import inquirer from 'inquirer';
+import { ConfigManager } from '../lib/config.js';
+import { ErrorHandler } from '../lib/errors.js';
+import { OutputFormatter, EnhancedPrompts } from '../lib/progress.js';
 export function createConfigCommand() {
-    const configCommand = new Command('config');
-    configCommand
+    const config = new Command('config');
+    config
+        .description('Manage ARK CLI configuration')
+        .addHelpText('before', `
+${chalk.blue('⚙️  ARK Configuration Management')}
+Manage your ARK CLI preferences and defaults.
+`)
+        .addHelpText('after', `
+${chalk.cyan('Examples:')}
+  ${chalk.yellow('ark config list')}                    # Show current configuration
+  ${chalk.yellow('ark config set defaultProjectType with-samples')}
+  ${chalk.yellow('ark config get defaultProjectType')}  # Get specific value
+  ${chalk.yellow('ark config edit')}                    # Interactive configuration
+  ${chalk.yellow('ark config reset')}                   # Reset to defaults
+`);
+    // List command - show current configuration
+    const listCommand = new Command('list');
+    listCommand
+        .alias('ls')
         .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));
+        .option('--json', 'Output in JSON format', false)
+        .action((options) => {
+        ErrorHandler.catchAndHandle(async () => {
+            const configManager = new ConfigManager();
+            const currentConfig = configManager.getMergedConfig();
+            if (options.json) {
+                console.log(JSON.stringify(currentConfig, null, 2));
+                return;
+            }
+            console.log(chalk.blue('\n⚙️  ARK CLI Configuration\n'));
+            // Generator settings
+            console.log(chalk.cyan('🎯 Generator Defaults:'));
+            OutputFormatter.formatKeyValueList([
+                {
+                    key: 'Project Type',
+                    value: currentConfig.defaultProjectType,
+                    highlight: true,
+                },
+                {
+                    key: 'Default Destination',
+                    value: currentConfig.defaultDestination,
+                },
+                {
+                    key: 'Skip Git by Default',
+                    value: currentConfig.skipGitByDefault ? 'yes' : 'no',
+                },
+                {
+                    key: 'Skip Models by Default',
+                    value: currentConfig.skipModelsbyDefault ? 'yes' : 'no',
+                },
+                {
+                    key: 'Default Model Provider',
+                    value: currentConfig.defaultModelProvider,
+                },
+            ]);
+            // User preferences
+            console.log(chalk.cyan('\n👤 User Preferences:'));
+            OutputFormatter.formatKeyValueList([
+                { key: 'Preferred Editor', value: currentConfig.preferredEditor },
+                {
+                    key: 'Color Output',
+                    value: currentConfig.colorOutput ? 'enabled' : 'disabled',
+                },
+                {
+                    key: 'Verbose Output',
+                    value: currentConfig.verboseOutput ? 'enabled' : 'disabled',
+                },
+            ]);
+            // Advanced settings
+            console.log(chalk.cyan('\n🔧 Advanced Settings:'));
+            OutputFormatter.formatKeyValueList([
+                {
+                    key: 'Parallel Operations',
+                    value: currentConfig.parallelOperations ? 'enabled' : 'disabled',
+                },
+                {
+                    key: 'Max Concurrent Files',
+                    value: currentConfig.maxConcurrentFiles.toString(),
+                },
+                {
+                    key: 'File Watching',
+                    value: currentConfig.fileWatchingEnabled ? 'enabled' : 'disabled',
+                },
+                {
+                    key: 'Telemetry',
+                    value: currentConfig.telemetryEnabled ? 'enabled' : 'disabled',
+                },
+            ]);
+            console.log(chalk.gray(`\nConfig file: ${configManager.getConfigFilePath()}`));
+            console.log(chalk.gray('Use "ark config edit" for interactive configuration\n'));
+        }, 'Listing configuration').catch(ErrorHandler.handleAndExit);
     });
-    return configCommand;
+    // Get command - get a specific configuration value
+    const getCommand = new Command('get');
+    getCommand
+        .description('Get a specific configuration value')
+        .argument('<key>', 'Configuration key to retrieve')
+        .action((key) => {
+        ErrorHandler.catchAndHandle(async () => {
+            const configManager = new ConfigManager();
+            const currentConfig = configManager.getMergedConfig();
+            if (key in currentConfig) {
+                const value = currentConfig[key];
+                console.log(typeof value === 'object'
+                    ? JSON.stringify(value, null, 2)
+                    : String(value));
+            }
+            else {
+                console.error(chalk.red(`Unknown configuration key: ${key}`));
+                console.log(chalk.gray('Available keys:'));
+                Object.keys(currentConfig).forEach((k) => console.log(chalk.gray(`  ${k}`)));
+                process.exit(1);
+            }
+        }, 'Getting configuration value').catch(ErrorHandler.handleAndExit);
+    });
+    // Set command - set a specific configuration value
+    const setCommand = new Command('set');
+    setCommand
+        .description('Set a specific configuration value')
+        .argument('<key>', 'Configuration key to set')
+        .argument('<value>', 'Value to set')
+        .action((key, value) => {
+        ErrorHandler.catchAndHandle(async () => {
+            const configManager = new ConfigManager();
+            const currentConfig = configManager.getConfig();
+            if (!(key in currentConfig)) {
+                console.error(chalk.red(`Unknown configuration key: ${key}`));
+                console.log(chalk.gray('Available keys:'));
+                Object.keys(currentConfig).forEach((k) => console.log(chalk.gray(`  ${k}`)));
+                process.exit(1);
+            }
+            // Parse value based on the current type
+            const currentValue = currentConfig[key];
+            let parsedValue = value;
+            if (typeof currentValue === 'boolean') {
+                parsedValue = ['true', 'yes', '1', 'on'].includes(value.toLowerCase());
+            }
+            else if (typeof currentValue === 'number') {
+                parsedValue = parseInt(value, 10);
+                if (isNaN(parsedValue)) {
+                    console.error(chalk.red(`Invalid number value: ${value}`));
+                    process.exit(1);
+                }
+            }
+            // Update configuration
+            configManager.set(key, parsedValue);
+            // Validate the configuration
+            configManager.validateConfig();
+            console.log(chalk.green(`✅ Set ${key} = ${parsedValue}`));
+        }, 'Setting configuration value').catch(ErrorHandler.handleAndExit);
+    });
+    // Edit command - interactive configuration editor
+    const editCommand = new Command('edit');
+    editCommand.description('Edit configuration interactively').action(() => {
+        ErrorHandler.catchAndHandle(async () => {
+            const configManager = new ConfigManager();
+            const currentConfig = configManager.getConfig();
+            console.log(chalk.blue('\n⚙️  ARK CLI Configuration Editor\n'));
+            EnhancedPrompts.showInfo('Leave fields empty to keep current values');
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'defaultProjectType',
+                    message: 'Default project type:',
+                    choices: [
+                        {
+                            name: 'with-samples (recommended for beginners)',
+                            value: 'with-samples',
+                        },
+                        { name: 'empty (for experienced users)', value: 'empty' },
+                    ],
+                    default: currentConfig.defaultProjectType,
+                },
+                {
+                    type: 'input',
+                    name: 'defaultDestination',
+                    message: 'Default destination directory:',
+                    default: currentConfig.defaultDestination,
+                },
+                {
+                    type: 'list',
+                    name: 'defaultModelProvider',
+                    message: 'Default model provider:',
+                    choices: [
+                        { name: 'Azure OpenAI (recommended)', value: 'azure' },
+                        { name: 'OpenAI', value: 'openai' },
+                        { name: 'Claude (Anthropic)', value: 'claude' },
+                        { name: 'Gemini (Google)', value: 'gemini' },
+                        { name: 'Custom', value: 'custom' },
+                    ],
+                    default: currentConfig.defaultModelProvider,
+                },
+                {
+                    type: 'input',
+                    name: 'preferredEditor',
+                    message: 'Preferred editor command:',
+                    default: currentConfig.preferredEditor,
+                },
+                {
+                    type: 'confirm',
+                    name: 'skipGitByDefault',
+                    message: 'Skip git setup by default?',
+                    default: currentConfig.skipGitByDefault,
+                },
+                {
+                    type: 'confirm',
+                    name: 'skipModelsbyDefault',
+                    message: 'Skip model configuration by default?',
+                    default: currentConfig.skipModelsbyDefault,
+                },
+                {
+                    type: 'confirm',
+                    name: 'colorOutput',
+                    message: 'Enable colored output?',
+                    default: currentConfig.colorOutput,
+                },
+                {
+                    type: 'confirm',
+                    name: 'verboseOutput',
+                    message: 'Enable verbose output?',
+                    default: currentConfig.verboseOutput,
+                },
+                {
+                    type: 'number',
+                    name: 'maxConcurrentFiles',
+                    message: 'Maximum concurrent file operations:',
+                    default: currentConfig.maxConcurrentFiles,
+                    validate: (input) => input !== undefined && input >= 1 && input <= 100
+                        ? true
+                        : 'Must be between 1 and 100',
+                },
+            ]);
+            // Update configuration
+            configManager.updateConfig(answers);
+            // Validate the configuration
+            configManager.validateConfig();
+            EnhancedPrompts.showSuccess('Configuration updated successfully');
+            console.log(chalk.gray(`Config saved to: ${configManager.getConfigFilePath()}\n`));
+        }, 'Editing configuration').catch(ErrorHandler.handleAndExit);
+    });
+    // Reset command - reset to default configuration
+    const resetCommand = new Command('reset');
+    resetCommand
+        .description('Reset configuration to defaults')
+        .option('--confirm', 'Skip confirmation prompt', false)
+        .action((options) => {
+        ErrorHandler.catchAndHandle(async () => {
+            if (!options.confirm) {
+                const { confirmReset } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirmReset',
+                        message: 'Are you sure you want to reset all configuration to defaults?',
+                        default: false,
+                    },
+                ]);
+                if (!confirmReset) {
+                    console.log(chalk.yellow('Reset cancelled'));
+                    return;
+                }
+            }
+            const configManager = new ConfigManager();
+            configManager.resetConfig();
+            EnhancedPrompts.showSuccess('Configuration reset to defaults');
+            console.log(chalk.gray(`Config file: ${configManager.getConfigFilePath()}\n`));
+        }, 'Resetting configuration').catch(ErrorHandler.handleAndExit);
+    });
+    // Export command - export configuration for backup
+    const exportCommand = new Command('export');
+    exportCommand
+        .description('Export configuration to JSON')
+        .option('-o, --output <file>', 'Output file (default: stdout)')
+        .action((options) => {
+        ErrorHandler.catchAndHandle(async () => {
+            const configManager = new ConfigManager();
+            const configJson = configManager.exportConfig();
+            if (options.output) {
+                const fs = await import('fs');
+                fs.writeFileSync(options.output, configJson);
+                EnhancedPrompts.showSuccess(`Configuration exported to ${options.output}`);
+            }
+            else {
+                console.log(configJson);
+            }
+        }, 'Exporting configuration').catch(ErrorHandler.handleAndExit);
+    });
+    // Import command - import configuration from backup
+    const importCommand = new Command('import');
+    importCommand
+        .description('Import configuration from JSON file')
+        .argument('<file>', 'JSON file to import')
+        .option('--merge', 'Merge with existing configuration', false)
+        .action((file, options) => {
+        ErrorHandler.catchAndHandle(async () => {
+            const fs = await import('fs');
+            const configJson = fs.readFileSync(file, 'utf-8');
+            const configManager = new ConfigManager();
+            if (options.merge) {
+                const importedConfig = JSON.parse(configJson);
+                configManager.updateConfig(importedConfig);
+            }
+            else {
+                configManager.importConfig(configJson);
+            }
+            EnhancedPrompts.showSuccess(`Configuration imported from ${file}`);
+        }, 'Importing configuration').catch(ErrorHandler.handleAndExit);
+    });
+    // Add subcommands
+    config.addCommand(listCommand);
+    config.addCommand(getCommand);
+    config.addCommand(setCommand);
+    config.addCommand(editCommand);
+    config.addCommand(resetCommand);
+    config.addCommand(exportCommand);
+    config.addCommand(importCommand);
+    return config;
 }

package/dist/commands/generate/config.js

@@ -2,6 +2,7 @@
  * 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
  */
@@ -69,18 +70,36 @@ export const GENERATOR_CHOICES = [
  */
 export const GENERATOR_DEFAULTS = {
     get projectType() {
-        return 'with-samples';
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('defaultProjectType');
+        }
+        catch {
+            return 'with-samples';
+        }
     },
     get skipModels() {
-        return false;
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('skipModelsbyDefault');
+        }
+        catch {
+            return false;
+        }
     },
     get skipGit() {
-        return false;
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('skipGitByDefault');
+        }
+        catch {
+            return false;
+        }
     },
     getDefaultDestination: () => {
         try {
-            // Return current working directory as default
-            const configured = null;
+            const configManager = new ConfigManager();
+            const configured = configManager.get('defaultDestination');
             if (configured && configured !== process.cwd()) {
                 return configured;
             }

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

@@ -144,11 +144,11 @@ class AgentGenerator {
             console.log(chalk.gray(`  1. Review and customise the agent configuration`));
             if (config.createQuery) {
                 console.log(chalk.gray(`  2. Review and customise the query configuration`));
-                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  4. Test with: kubectl get agents,queries`));
             }
             else {
-                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} . --namespace ${config.projectName}`));
                 console.log(chalk.gray(`  3. Test with: kubectl get agents`));
             }
         }, 'Generating agent');

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

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