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

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/config.d.ts

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

package/dist/commands/config.js

@@ -1,327 +1,44 @@
-/**
- * Configuration management commands for ARK CLI
- */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import inquirer from 'inquirer';
-import { ConfigManager } from '../lib/config.js';
-import { ErrorHandler } from '../lib/errors.js';
-import { OutputFormatter, EnhancedPrompts } from '../lib/progress.js';
+import { loadConfig, getConfigPaths, formatConfig } from '../lib/config.js';
+import fs from 'fs';
 export function createConfigCommand() {
-    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')
+    const configCommand = new Command('config');
+    configCommand
         .description('Show current configuration')
-        .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);
+        .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));
     });
-    // 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;
+    return configCommand;
 }

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/dashboard.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function openDashboard(): Promise<void>;
+export declare function createDashboardCommand(): Command;

package/dist/commands/dashboard.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/dev/index.d.ts

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

package/dist/commands/dev/index.js

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

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createCheckCommand(): Command;