@agents-at-scale/ark 0.1.35 → 0.1.36

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

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

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

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

package/dist/commands/generate/index.js

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

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

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

package/dist/commands/install/index.js

@@ -0,0 +1,295 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { execute } from '../../lib/commands.js';
+import inquirer from 'inquirer';
+import { showNoClusterError } from '../../lib/startup.js';
+import output from '../../lib/output.js';
+import { getInstallableServices, arkDependencies, } from '../../arkServices.js';
+import { isArkReady } from '../../lib/arkStatus.js';
+import { printNextSteps } from '../../lib/nextSteps.js';
+import ora from 'ora';
+async function installService(service, verbose = false) {
+    const helmArgs = [
+        'upgrade',
+        '--install',
+        service.helmReleaseName,
+        service.chartPath,
+    ];
+    // Only add namespace flag if service has explicit namespace
+    if (service.namespace) {
+        helmArgs.push('--namespace', service.namespace);
+    }
+    // Add any additional install args
+    helmArgs.push(...(service.installArgs || []));
+    await execute('helm', helmArgs, { stdio: 'inherit' }, { verbose });
+}
+export async function installArk(config, serviceName, options = {}) {
+    // Validate that --wait-for-ready requires -y
+    if (options.waitForReady && !options.yes) {
+        output.error('--wait-for-ready requires -y flag for non-interactive mode');
+        process.exit(1);
+    }
+    // Check cluster connectivity from config
+    if (!config.clusterInfo) {
+        showNoClusterError();
+        process.exit(1);
+    }
+    const clusterInfo = config.clusterInfo;
+    // Show cluster info
+    output.success(`connected to cluster: ${chalk.bold(clusterInfo.context)}`);
+    console.log(); // Add blank line after cluster info
+    // If a specific service is requested, install only that service
+    if (serviceName) {
+        const services = getInstallableServices();
+        const service = Object.values(services).find((s) => s.name === serviceName);
+        if (!service) {
+            output.error(`service '${serviceName}' not found`);
+            output.info('available services:');
+            for (const s of Object.values(services)) {
+                output.info(`  ${s.name}`);
+            }
+            process.exit(1);
+        }
+        output.info(`installing ${service.name}...`);
+        try {
+            await installService(service, options.verbose);
+            output.success(`${service.name} installed successfully`);
+        }
+        catch (error) {
+            output.error(`failed to install ${service.name}`);
+            console.error(error);
+            process.exit(1);
+        }
+        return;
+    }
+    // If not using -y flag, show checklist interface
+    if (!options.yes) {
+        console.log(chalk.cyan.bold('\nSelect components to install:'));
+        console.log(chalk.gray('Use arrow keys to navigate, space to toggle, enter to confirm\n'));
+        // Build choices for the checkbox prompt
+        const allChoices = [
+            new inquirer.Separator(chalk.bold('──── Dependencies ────')),
+            {
+                name: `cert-manager ${chalk.gray('- Certificate management')}`,
+                value: 'cert-manager',
+                checked: true,
+            },
+            {
+                name: `gateway-api ${chalk.gray('- Gateway API CRDs')}`,
+                value: 'gateway-api',
+                checked: true,
+            },
+            new inquirer.Separator(chalk.bold('──── Ark Core ────')),
+            {
+                name: `ark-controller ${chalk.gray('- Core Ark controller')}`,
+                value: 'ark-controller',
+                checked: true,
+            },
+            new inquirer.Separator(chalk.bold('──── Ark Services ────')),
+            {
+                name: `ark-api ${chalk.gray('- API service')}`,
+                value: 'ark-api',
+                checked: true,
+            },
+            {
+                name: `ark-dashboard ${chalk.gray('- Web dashboard')}`,
+                value: 'ark-dashboard',
+                checked: true,
+            },
+            {
+                name: `ark-mcp ${chalk.gray('- MCP services')}`,
+                value: 'ark-mcp',
+                checked: true,
+            },
+            {
+                name: `localhost-gateway ${chalk.gray('- Gateway for local access')}`,
+                value: 'localhost-gateway',
+                checked: true,
+            },
+        ];
+        let selectedComponents = [];
+        try {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'components',
+                    message: 'Components to install:',
+                    choices: allChoices,
+                    pageSize: 15,
+                },
+            ]);
+            selectedComponents = answers.components;
+            if (selectedComponents.length === 0) {
+                output.warning('No components selected. Exiting.');
+                process.exit(0);
+            }
+        }
+        catch (error) {
+            // Handle Ctrl-C gracefully
+            if (error && error.name === 'ExitPromptError') {
+                console.log('\nInstallation cancelled');
+                process.exit(130);
+            }
+            throw error;
+        }
+        // Install dependencies if selected
+        const shouldInstallDeps = selectedComponents.includes('cert-manager') ||
+            selectedComponents.includes('gateway-api');
+        // Install selected dependencies
+        if (shouldInstallDeps) {
+            // Always install cert-manager repo and update if installing any dependency
+            if (selectedComponents.includes('cert-manager') ||
+                selectedComponents.includes('gateway-api')) {
+                for (const depKey of ['cert-manager-repo', 'helm-repo-update']) {
+                    const dep = arkDependencies[depKey];
+                    output.info(`installing ${dep.description || dep.name}...`);
+                    try {
+                        await execute(dep.command, dep.args, {
+                            stdio: 'inherit',
+                        }, { verbose: options.verbose });
+                        output.success(`${dep.name} completed`);
+                        console.log();
+                    }
+                    catch {
+                        console.log();
+                        process.exit(1);
+                    }
+                }
+            }
+            // Install cert-manager if selected
+            if (selectedComponents.includes('cert-manager')) {
+                const dep = arkDependencies['cert-manager'];
+                output.info(`installing ${dep.description || dep.name}...`);
+                try {
+                    await execute(dep.command, dep.args, {
+                        stdio: 'inherit',
+                    }, { verbose: options.verbose });
+                    output.success(`${dep.name} completed`);
+                    console.log();
+                }
+                catch {
+                    console.log();
+                    process.exit(1);
+                }
+            }
+            // Install gateway-api if selected
+            if (selectedComponents.includes('gateway-api')) {
+                const dep = arkDependencies['gateway-api-crds'];
+                output.info(`installing ${dep.description || dep.name}...`);
+                try {
+                    await execute(dep.command, dep.args, {
+                        stdio: 'inherit',
+                    }, { verbose: options.verbose });
+                    output.success(`${dep.name} completed`);
+                    console.log();
+                }
+                catch {
+                    console.log();
+                    process.exit(1);
+                }
+            }
+        }
+        // Install selected services
+        const services = getInstallableServices();
+        for (const service of Object.values(services)) {
+            // Check if this service was selected
+            const serviceKey = service.helmReleaseName;
+            if (!selectedComponents.includes(serviceKey)) {
+                continue;
+            }
+            output.info(`installing ${service.name}...`);
+            try {
+                await installService(service, options.verbose);
+                console.log(); // Add blank line after command output
+            }
+            catch {
+                // Continue with remaining services on error
+                console.log(); // Add blank line after error output
+            }
+        }
+    }
+    else {
+        // -y flag was used, install everything
+        // Install all dependencies
+        for (const dep of Object.values(arkDependencies)) {
+            output.info(`installing ${dep.description || dep.name}...`);
+            try {
+                await execute(dep.command, dep.args, {
+                    stdio: 'inherit',
+                }, { verbose: options.verbose });
+                output.success(`${dep.name} completed`);
+                console.log(); // Add blank line after dependency
+            }
+            catch {
+                console.log(); // Add blank line after error
+                process.exit(1);
+            }
+        }
+        // Install all services
+        const services = getInstallableServices();
+        for (const service of Object.values(services)) {
+            output.info(`installing ${service.name}...`);
+            try {
+                await installService(service, options.verbose);
+                console.log(); // Add blank line after command output
+            }
+            catch {
+                // Continue with remaining services on error
+                console.log(); // Add blank line after error output
+            }
+        }
+    }
+    // Show next steps after successful installation
+    if (!serviceName || serviceName === 'all') {
+        printNextSteps();
+    }
+    // Wait for Ark to be ready if requested
+    if (options.waitForReady) {
+        // Parse timeout value (e.g., '30s', '2m', '60')
+        const parseTimeout = (value) => {
+            const match = value.match(/^(\d+)([sm])?$/);
+            if (!match) {
+                throw new Error('Invalid timeout format. Use format like 30s or 2m');
+            }
+            const num = parseInt(match[1], 10);
+            const unit = match[2] || 's';
+            return unit === 'm' ? num * 60 : num;
+        };
+        try {
+            const timeoutSeconds = parseTimeout(options.waitForReady);
+            const startTime = Date.now();
+            const endTime = startTime + timeoutSeconds * 1000;
+            const spinner = ora(`Waiting for Ark to be ready (timeout: ${timeoutSeconds}s)...`).start();
+            while (Date.now() < endTime) {
+                if (await isArkReady()) {
+                    spinner.succeed('Ark is ready!');
+                    return;
+                }
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                spinner.text = `Waiting for Ark to be ready (${elapsed}/${timeoutSeconds}s)...`;
+                // Wait 2 seconds before checking again
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            }
+            // Timeout reached
+            spinner.fail(`Ark did not become ready within ${timeoutSeconds} seconds`);
+            process.exit(1);
+        }
+        catch (error) {
+            output.error(`Failed to wait for ready: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    }
+}
+export function createInstallCommand(config) {
+    const command = new Command('install');
+    command
+        .description('Install ARK components using Helm')
+        .argument('[service]', 'specific service to install, or all if omitted')
+        .option('-y, --yes', 'automatically confirm all installations')
+        .option('--wait-for-ready <timeout>', 'wait for Ark to be ready after installation (e.g., 30s, 2m)')
+        .option('-v, --verbose', 'show commands being executed')
+        .action(async (service, options) => {
+        await installArk(config, service, options);
+    });
+    return command;
+}

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

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

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

@@ -0,0 +1,143 @@
+import { jest } from '@jest/globals';
+import { Command } from 'commander';
+const mockExeca = jest.fn(() => Promise.resolve());
+jest.unstable_mockModule('execa', () => ({
+    execa: mockExeca,
+}));
+const mockGetClusterInfo = jest.fn();
+jest.unstable_mockModule('../../lib/cluster.js', () => ({
+    getClusterInfo: mockGetClusterInfo,
+}));
+const mockGetInstallableServices = jest.fn();
+const mockArkServices = {};
+const mockArkDependencies = {};
+jest.unstable_mockModule('../../arkServices.js', () => ({
+    getInstallableServices: mockGetInstallableServices,
+    arkServices: mockArkServices,
+    arkDependencies: mockArkDependencies,
+}));
+const mockOutput = {
+    error: jest.fn(),
+    info: jest.fn(),
+    success: jest.fn(),
+    warning: jest.fn(),
+};
+jest.unstable_mockModule('../../lib/output.js', () => ({
+    default: mockOutput,
+}));
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+    throw new Error('process.exit called');
+}));
+jest.spyOn(console, 'log').mockImplementation(() => { });
+jest.spyOn(console, 'error').mockImplementation(() => { });
+const { createInstallCommand } = await import('./index.js');
+describe('install command', () => {
+    const mockConfig = {
+        clusterInfo: {
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockGetClusterInfo.mockResolvedValue({
+            context: 'test-cluster',
+            type: 'minikube',
+            namespace: 'default',
+        });
+    });
+    it('creates command with correct structure', () => {
+        const command = createInstallCommand(mockConfig);
+        expect(command).toBeInstanceOf(Command);
+        expect(command.name()).toBe('install');
+    });
+    it('installs single service with correct helm parameters', async () => {
+        const mockService = {
+            name: 'ark-api',
+            helmReleaseName: 'ark-api',
+            chartPath: './charts/ark-api',
+            namespace: 'ark-system',
+            installArgs: ['--set', 'image.tag=latest'],
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-api']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'ark-api',
+            './charts/ark-api',
+            '--namespace',
+            'ark-system',
+            '--set',
+            'image.tag=latest',
+        ], { stdio: 'inherit' });
+        expect(mockOutput.success).toHaveBeenCalledWith('ark-api installed successfully');
+    });
+    it('shows error when service not found', async () => {
+        mockGetInstallableServices.mockReturnValue({
+            'ark-api': { name: 'ark-api' },
+            'ark-controller': { name: 'ark-controller' },
+        });
+        const command = createInstallCommand(mockConfig);
+        await expect(command.parseAsync(['node', 'test', 'invalid-service'])).rejects.toThrow('process.exit called');
+        expect(mockOutput.error).toHaveBeenCalledWith("service 'invalid-service' not found");
+        expect(mockOutput.info).toHaveBeenCalledWith('available services:');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-api');
+        expect(mockOutput.info).toHaveBeenCalledWith('  ark-controller');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+    it('handles service without namespace (uses current context)', async () => {
+        const mockService = {
+            name: 'ark-dashboard',
+            helmReleaseName: 'ark-dashboard',
+            chartPath: './charts/ark-dashboard',
+            // namespace is undefined - should use current context
+            installArgs: ['--set', 'replicas=2'],
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'ark-dashboard': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'ark-dashboard']);
+        // Should NOT include --namespace flag
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'ark-dashboard',
+            './charts/ark-dashboard',
+            '--set',
+            'replicas=2',
+        ], { stdio: 'inherit' });
+    });
+    it('handles service without installArgs', async () => {
+        const mockService = {
+            name: 'simple-service',
+            helmReleaseName: 'simple-service',
+            chartPath: './charts/simple',
+            namespace: 'default',
+        };
+        mockGetInstallableServices.mockReturnValue({
+            'simple-service': mockService,
+        });
+        const command = createInstallCommand(mockConfig);
+        await command.parseAsync(['node', 'test', 'simple-service']);
+        expect(mockExeca).toHaveBeenCalledWith('helm', [
+            'upgrade',
+            '--install',
+            'simple-service',
+            './charts/simple',
+            '--namespace',
+            'default',
+        ], { stdio: 'inherit' });
+    });
+    it('exits when cluster not connected', async () => {
+        mockGetClusterInfo.mockResolvedValue({ error: true });
+        const command = createInstallCommand({});
+        await expect(command.parseAsync(['node', 'test', 'ark-api'])).rejects.toThrow('process.exit called');
+        expect(mockExit).toHaveBeenCalledWith(1);
+    });
+});

package/dist/commands/models/create.d.ts

@@ -0,0 +1 @@
+export declare function createModel(modelName?: string): Promise<boolean>;