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

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;

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

@@ -0,0 +1,142 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import ora from 'ora';
+import output from '../../../lib/output.js';
+import { ArkDevToolAnalyzer } from '../../../lib/dev/tools/analyzer.js';
+import { toMCPTool } from '../../../lib/dev/tools/mcp-types.js';
+async function checkTool(toolPath, options) {
+    const absolutePath = path.resolve(toolPath);
+    const analyzer = new ArkDevToolAnalyzer();
+    const isJson = options.output === 'json';
+    // Build up result object as we go
+    const result = {
+        path: absolutePath,
+        projectRoot: null,
+        error: null,
+        platform: null,
+        projectType: null,
+        projectName: null,
+        projectVersion: null,
+        hasFastmcp: false,
+        fastmcpVersion: null,
+        tools: [],
+        toolDiscoveryError: null,
+    };
+    if (!isJson) {
+        console.log();
+    }
+    // Single spinner for all analysis (skip for JSON output)
+    const analyzeSpinner = isJson
+        ? null
+        : ora(`analyzing ${absolutePath}`).start();
+    // Small delay to let user see what's happening (skip for JSON)
+    if (!isJson) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    // Collect all information
+    const project = await analyzer.discoverProject(absolutePath);
+    if (!project || !project.exists) {
+        result.error = 'path not found';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`path not found: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    if (!project.is_directory) {
+        result.error = 'path is not a directory';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`path is not a directory: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    if (!project.platform) {
+        result.error =
+            'platform unknown - no pyproject.toml or requirements.txt found';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`no pyproject.toml or requirements.txt found in: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    // Update result with project info
+    result.platform = project.platform;
+    result.projectType = project.project_type;
+    result.projectName = project.project_name;
+    result.projectVersion = project.project_version;
+    result.hasFastmcp = project.has_fastmcp;
+    result.fastmcpVersion = project.fastmcp_version;
+    result.projectRoot = absolutePath; // Store the project root
+    // Discover tools recursively in the project
+    const rawTools = [];
+    try {
+        const projectTools = await analyzer.findProjectTools(absolutePath);
+        if (projectTools && projectTools.tools) {
+            rawTools.push(...projectTools.tools);
+        }
+    }
+    catch (error) {
+        result.toolDiscoveryError =
+            error instanceof Error ? error.message : 'Unknown error';
+    }
+    // Store tools in the appropriate format
+    result.tools = isJson ? rawTools.map(toMCPTool) : rawTools;
+    if (isJson) {
+        // Output raw JSON
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    analyzeSpinner.succeed('analysis complete');
+    console.log();
+    // Display summary in cleaner format
+    output.section(path.basename(absolutePath));
+    // Platform
+    output.statusCheck('found', 'platform', result.platform);
+    // Project type with name and version in gray
+    let projectDetails = '';
+    if (result.projectName) {
+        projectDetails = result.projectName;
+        if (result.projectVersion) {
+            projectDetails += ` v${result.projectVersion}`;
+        }
+    }
+    output.statusCheck('found', 'project', result.projectType, projectDetails);
+    // Framework with version in gray
+    if (result.hasFastmcp) {
+        const fastmcpDetails = result.fastmcpVersion
+            ? `v${result.fastmcpVersion}`
+            : undefined;
+        output.statusCheck('found', 'framework', 'fastmcp', fastmcpDetails);
+    }
+    else {
+        output.statusCheck('missing', 'framework', 'fastmcp');
+    }
+    // Tools with details
+    output.statusCheck('found', 'tools', result.tools.length.toString());
+    if (result.tools.length > 0) {
+        for (const tool of result.tools) {
+            const description = tool.docstring ? tool.docstring.split('\n')[0] : '';
+            console.log(chalk.gray(`      - ${tool.name}: ${description}`));
+        }
+    }
+}
+export function createCheckCommand() {
+    const checkCommand = new Command('check');
+    checkCommand
+        .description('Check the status of an MCP tool project')
+        .argument('<path>', 'Path to the tool directory')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(checkTool);
+    return checkCommand;
+}

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

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