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

package/dist/lib/progress.js

@@ -1,273 +0,0 @@
-/**
- * Progress indicators and user experience utilities for ARK CLI
- */
-import chalk from 'chalk';
-export class ProgressIndicator {
-    constructor(title) {
-        this.title = title;
-        this.steps = [];
-        this.startTime = Date.now();
-        console.log(chalk.blue(`\n🚀 ${this.title}\n`));
-    }
-    /**
-     * Add a step to the progress indicator
-     */
-    addStep(name, message) {
-        this.steps.push({
-            name,
-            status: 'pending',
-            message,
-        });
-    }
-    /**
-     * Start a step
-     */
-    startStep(name, message) {
-        const step = this.steps.find((s) => s.name === name);
-        if (step) {
-            step.status = 'running';
-            step.message = message;
-            this.renderProgress();
-        }
-    }
-    /**
-     * Complete a step
-     */
-    completeStep(name, message) {
-        const step = this.steps.find((s) => s.name === name);
-        if (step) {
-            step.status = 'completed';
-            step.message = message;
-            this.renderProgress();
-        }
-    }
-    /**
-     * Fail a step
-     */
-    failStep(name, message) {
-        const step = this.steps.find((s) => s.name === name);
-        if (step) {
-            step.status = 'failed';
-            step.message = message;
-            this.renderProgress();
-        }
-    }
-    /**
-     * Skip a step
-     */
-    skipStep(name, message) {
-        const step = this.steps.find((s) => s.name === name);
-        if (step) {
-            step.status = 'skipped';
-            step.message = message;
-            this.renderProgress();
-        }
-    }
-    /**
-     * Render the current progress
-     */
-    renderProgress() {
-        // Clear previous output (simple version)
-        process.stdout.write('\r\x1b[K');
-        for (const step of this.steps) {
-            const icon = this.getStatusIcon(step.status);
-            const color = this.getStatusColor(step.status);
-            const statusText = step.message || step.name;
-            console.log(`${icon} ${chalk[color](statusText)}`);
-        }
-        // Move cursor back up to overwrite on next update
-        if (this.steps.length > 1) {
-            process.stdout.write(`\x1b[${this.steps.length}A`);
-        }
-    }
-    /**
-     * Complete the progress indicator
-     */
-    complete(message) {
-        // Clear any remaining progress rendering
-        process.stdout.write('\r\x1b[K');
-        // Only print failed or skipped steps - hide successful validation
-        const importantSteps = this.steps.filter((step) => step.status === 'failed' || step.status === 'skipped');
-        for (const step of importantSteps) {
-            const icon = this.getStatusIcon(step.status);
-            const color = this.getStatusColor(step.status);
-            const statusText = step.message || step.name;
-            console.log(`${icon} ${chalk[color](statusText)}`);
-        }
-        const duration = Date.now() - this.startTime;
-        const durationText = duration > 1000 ? `${(duration / 1000).toFixed(1)}s` : `${duration}ms`;
-        // Only show completion message if there were issues or if verbose
-        if (importantSteps.length > 0) {
-            console.log(chalk.green(`\n✅ ${message || this.title} completed in ${durationText}\n`));
-        }
-    }
-    /**
-     * Get status icon for a step
-     */
-    getStatusIcon(status) {
-        switch (status) {
-            case 'pending':
-                return chalk.gray('⏳');
-            case 'running':
-                return chalk.blue('🔄');
-            case 'completed':
-                return chalk.green('✅');
-            case 'failed':
-                return chalk.red('❌');
-            case 'skipped':
-                return chalk.yellow('⏭️');
-            default:
-                return '❓';
-        }
-    }
-    /**
-     * Get status color for a step
-     */
-    getStatusColor(status) {
-        switch (status) {
-            case 'pending':
-                return 'gray';
-            case 'running':
-                return 'blue';
-            case 'completed':
-                return 'green';
-            case 'failed':
-                return 'red';
-            case 'skipped':
-                return 'yellow';
-            default:
-                return 'gray';
-        }
-    }
-}
-/**
- * Simple spinner for long-running operations
- */
-export class Spinner {
-    constructor(message) {
-        this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-        this.index = 0;
-        this.interval = null;
-        this.message = message;
-    }
-    start() {
-        this.interval = setInterval(() => {
-            process.stdout.write(`\r${chalk.blue(this.frames[this.index])} ${this.message}`);
-            this.index = (this.index + 1) % this.frames.length;
-        }, 100);
-    }
-    stop(finalMessage) {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = null;
-        }
-        process.stdout.write(`\r\x1b[K${finalMessage ? chalk.green(`✅ ${finalMessage}`) : ''}\n`);
-    }
-    fail(errorMessage) {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = null;
-        }
-        process.stdout.write(`\r\x1b[K${errorMessage ? chalk.red(`❌ ${errorMessage}`) : ''}\n`);
-    }
-}
-/**
- * Enhanced prompts with better validation and user guidance
- */
-export class EnhancedPrompts {
-    /**
-     * Show a helpful tip to the user
-     */
-    static showTip(message) {
-        console.log(chalk.cyan(`💡 Tip: ${message}`));
-    }
-    /**
-     * Show a warning to the user
-     */
-    static showWarning(message) {
-        console.log(chalk.yellow(`⚠️  Warning: ${message}`));
-    }
-    /**
-     * Show information to the user
-     */
-    static showInfo(message) {
-        console.log(chalk.blue(`ℹ️  ${message}`));
-    }
-    /**
-     * Show a success message
-     */
-    static showSuccess(message) {
-        console.log(chalk.green(`✅ ${message}`));
-    }
-    /**
-     * Show available options for a choice
-     */
-    static showChoiceHelp(title, choices) {
-        console.log(chalk.cyan(`\n📋 ${title}:`));
-        choices.forEach((choice) => {
-            console.log(chalk.gray(`  • ${chalk.white(choice.name)}: ${choice.description}`));
-        });
-        console.log();
-    }
-    /**
-     * Show next steps after completion
-     */
-    static showNextSteps(title, steps) {
-        console.log(chalk.cyan(`\n📋 ${title}:`));
-        steps.forEach((step, index) => {
-            console.log(chalk.gray(`  ${index + 1}. ${step}`));
-        });
-        console.log();
-    }
-    /**
-     * Show a separator for better visual organization
-     */
-    static showSeparator(title) {
-        if (title) {
-            console.log(chalk.gray(`\n${'─'.repeat(50)}`));
-            console.log(chalk.cyan(`${title}`));
-            console.log(chalk.gray(`${'─'.repeat(50)}\n`));
-        }
-        else {
-            console.log(chalk.gray(`${'─'.repeat(50)}`));
-        }
-    }
-}
-/**
- * Utility for consistent formatting of output
- */
-export class OutputFormatter {
-    /**
-     * Format a list of key-value pairs
-     */
-    static formatKeyValueList(items) {
-        const maxKeyLength = Math.max(...items.map((item) => item.key.length));
-        items.forEach((item) => {
-            const paddedKey = item.key.padEnd(maxKeyLength);
-            const color = item.highlight ? 'cyan' : 'gray';
-            console.log(`  ${chalk[color](paddedKey)}: ${chalk.white(item.value)}`);
-        });
-    }
-    /**
-     * Format a file list with icons
-     */
-    static formatFileList(files) {
-        files.forEach((file) => {
-            const icon = file.type === 'directory' ? '📁' : '📄';
-            const description = file.description
-                ? chalk.gray(` - ${file.description}`)
-                : '';
-            console.log(`  ${icon} ${chalk.white(file.path)}${description}`);
-        });
-    }
-    /**
-     * Format command examples
-     */
-    static formatCommands(title, commands) {
-        console.log(chalk.cyan(`\n${title}:`));
-        commands.forEach((cmd) => {
-            console.log(`  ${chalk.yellow(cmd.command)}`);
-            console.log(chalk.gray(`    ${cmd.description}\n`));
-        });
-    }
-}

package/dist/lib/queryRunner.d.ts

@@ -1,22 +0,0 @@
-/**
- * Shared query execution logic for both universal and resource-specific query commands
- */
-export interface QueryOptions {
-    targetType: string;
-    targetName: string;
-    message: string;
-    verbose?: boolean;
-}
-/**
- * Execute a query against any ARK target (model, agent, team)
- * This is the shared implementation used by all query commands
- */
-export declare function executeQuery(options: QueryOptions): Promise<void>;
-/**
- * Parse a target string like "model/default" or "agent/weather"
- * Returns { targetType, targetName } or null if invalid
- */
-export declare function parseTarget(target: string): {
-    targetType: string;
-    targetName: string;
-} | null;

package/dist/lib/queryRunner.js

@@ -1,142 +0,0 @@
-/**
- * Shared query execution logic for both universal and resource-specific query commands
- */
-import { execa } from 'execa';
-import ora from 'ora';
-import output from './output.js';
-/**
- * Execute a query against any ARK target (model, agent, team)
- * This is the shared implementation used by all query commands
- */
-export async function executeQuery(options) {
-    const spinner = ora('Creating query...').start();
-    // Generate a unique query name
-    const timestamp = Date.now();
-    const queryName = `cli-query-${timestamp}`;
-    // Create the Query resource
-    const queryManifest = {
-        apiVersion: 'ark.mckinsey.com/v1alpha1',
-        kind: 'Query',
-        metadata: {
-            name: queryName,
-        },
-        spec: {
-            input: options.message,
-            targets: [
-                {
-                    type: options.targetType,
-                    name: options.targetName,
-                },
-            ],
-        },
-    };
-    try {
-        // Apply the query
-        spinner.text = 'Submitting query...';
-        await execa('kubectl', ['apply', '-f', '-'], {
-            input: JSON.stringify(queryManifest),
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        // Watch for query completion
-        spinner.text = 'Query status: initializing';
-        let queryComplete = false;
-        let attempts = 0;
-        const maxAttempts = 300; // 5 minutes with 1 second intervals
-        while (!queryComplete && attempts < maxAttempts) {
-            attempts++;
-            try {
-                const { stdout } = await execa('kubectl', [
-                    'get',
-                    'query',
-                    queryName,
-                    '-o',
-                    'json',
-                ], { stdio: 'pipe' });
-                const query = JSON.parse(stdout);
-                const phase = query.status?.phase;
-                // Update spinner with current phase
-                if (phase) {
-                    spinner.text = `Query status: ${phase}`;
-                }
-                // Check if query is complete based on phase
-                if (phase === 'done') {
-                    queryComplete = true;
-                    spinner.succeed('Query completed');
-                    // Extract and display the response from responses array
-                    if (query.status?.responses && query.status.responses.length > 0) {
-                        const response = query.status.responses[0];
-                        console.log('\n' + (response.content || response));
-                    }
-                    else {
-                        output.warning('No response received');
-                    }
-                }
-                else if (phase === 'error') {
-                    queryComplete = true;
-                    spinner.fail('Query failed');
-                    // Try to get error message from conditions or status
-                    const errorCondition = query.status?.conditions?.find((c) => {
-                        const condition = c;
-                        return condition.type === 'Complete' && condition.status === 'False';
-                    });
-                    if (errorCondition?.message) {
-                        output.error(errorCondition.message);
-                    }
-                    else if (query.status?.error) {
-                        output.error(query.status.error);
-                    }
-                    else {
-                        output.error('Query failed with unknown error');
-                    }
-                }
-                else if (phase === 'canceled') {
-                    queryComplete = true;
-                    spinner.warn('Query canceled');
-                    // Try to get cancellation reason if available
-                    if (query.status?.message) {
-                        output.warning(query.status.message);
-                    }
-                }
-            }
-            catch {
-                // Query might not exist yet, continue waiting
-                spinner.text = 'Query status: waiting for query to be created';
-            }
-            if (!queryComplete) {
-                await new Promise(resolve => setTimeout(resolve, 1000)); // Wait 1 second
-            }
-        }
-        if (!queryComplete) {
-            spinner.fail('Query timed out');
-            output.error('Query did not complete within 5 minutes');
-        }
-    }
-    catch (error) {
-        spinner.fail('Query failed');
-        output.error(error instanceof Error ? error.message : 'Unknown error');
-        process.exit(1);
-    }
-    finally {
-        // Clean up the query resource
-        try {
-            await execa('kubectl', ['delete', 'query', queryName], { stdio: 'pipe' });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
-    }
-}
-/**
- * Parse a target string like "model/default" or "agent/weather"
- * Returns { targetType, targetName } or null if invalid
- */
-export function parseTarget(target) {
-    const parts = target.split('/');
-    if (parts.length !== 2) {
-        return null;
-    }
-    return {
-        targetType: parts[0],
-        targetName: parts[1],
-    };
-}

package/dist/lib/wrappers/git.d.ts

@@ -1,2 +0,0 @@
-export declare function ensureInArkRepo(expectedRepoName: string, expectedRemoteSubstring?: string): Promise<void>;
-export declare function getRepoProjectRoot(): Promise<string>;

package/dist/lib/wrappers/git.js

@@ -1,43 +0,0 @@
-import * as path from 'path';
-import chalk from 'chalk';
-import { simpleGit } from 'simple-git';
-import { ARK_REPO_ERROR_MESSAGE } from '../consts.js';
-// Initialize simple-git instance
-const git = simpleGit();
-export async function ensureInArkRepo(expectedRepoName, expectedRemoteSubstring) {
-    try {
-        // Get repository root
-        const gitRoot = await git.revparse(['--show-toplevel']);
-        if (path.basename(gitRoot) !== expectedRepoName) {
-            console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
-            process.exit(1);
-        }
-        if (expectedRemoteSubstring) {
-            try {
-                // Get remote URL
-                const remoteUrl = await git.remote(['get-url', 'origin']);
-                if (!remoteUrl || !remoteUrl.includes(expectedRemoteSubstring)) {
-                    console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
-                    process.exit(1);
-                }
-            }
-            catch (_error) {
-                console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
-                process.exit(1);
-            }
-        }
-    }
-    catch (_error) {
-        console.error(chalk.red(ARK_REPO_ERROR_MESSAGE));
-        process.exit(1);
-    }
-}
-export async function getRepoProjectRoot() {
-    try {
-        return await git.revparse(['--show-toplevel']);
-    }
-    catch (_error) {
-        console.error(chalk.red('Failed to determine git repository root path'));
-        process.exit(1);
-    }
-}