@agents-at-scale/ark 0.1.31

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

@@ -0,0 +1,2 @@
+import { Generator } from '../index.js';
+export declare function createQueryGenerator(): Generator;

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

@@ -0,0 +1,213 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs';
+import { TemplateEngine } from '../templateEngine.js';
+import { TemplateDiscovery } from '../templateDiscovery.js';
+import { toKebabCase, validateNameStrict } from '../utils/nameUtils.js';
+import { getCurrentProjectInfo } from '../utils/projectUtils.js';
+import { ErrorHandler, TemplateError, ValidationError, } from '../../../lib/errors.js';
+export function createQueryGenerator() {
+    return {
+        name: 'query',
+        description: 'Generate a new query to test agents or teams',
+        templatePath: 'templates/query',
+        generate: async (name, destination, options) => {
+            const generator = new QueryGenerator();
+            await generator.generate(name, destination, options);
+        },
+    };
+}
+class QueryGenerator {
+    constructor() {
+        this.templateDiscovery = new TemplateDiscovery();
+        this.templateEngine = new TemplateEngine();
+    }
+    /**
+     * Get query configuration from user input and validation
+     */
+    async getQueryConfig(name, _destination, _options) {
+        // Validate that we're in a project directory and get project info
+        const { projectName, projectDir } = getCurrentProjectInfo();
+        // Validate and normalize query name
+        const queryName = toKebabCase(name);
+        validateNameStrict(queryName, 'query name');
+        // Check if query already exists
+        const queriesDir = path.join(projectDir, 'queries');
+        const queryFilePath = path.join(queriesDir, `${queryName}-query.yaml`);
+        if (fs.existsSync(queryFilePath)) {
+            console.log(chalk.yellow(`⚠️  Query file already exists: ${queryFilePath}`));
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: 'Do you want to overwrite the existing query?',
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                throw new ValidationError('Query generation cancelled by user', 'overwrite', [
+                    `Use a different query name`,
+                    `Use --force flag to overwrite without prompting`,
+                ]);
+            }
+        }
+        // Ask user what type of target they want
+        const { targetType } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'targetType',
+                message: 'What should this query target?',
+                choices: [
+                    { name: 'Agent - Target a single AI agent', value: 'agent' },
+                    { name: 'Team - Target a team of agents', value: 'team' },
+                ],
+                default: 'agent',
+            },
+        ]);
+        // Get available targets based on type
+        const targetDir = path.join(projectDir, targetType === 'agent' ? 'agents' : 'teams');
+        const filePattern = targetType === 'agent' ? '-agent.yaml' : '-team.yaml';
+        let availableTargets = [];
+        if (fs.existsSync(targetDir)) {
+            const targetFiles = fs
+                .readdirSync(targetDir)
+                .filter((file) => file.endsWith(filePattern))
+                .map((file) => file.replace(filePattern, ''));
+            availableTargets = targetFiles;
+        }
+        let targetName;
+        if (availableTargets.length > 0) {
+            // Ask user to select a target or provide a custom one
+            const choices = [
+                ...availableTargets.map((target) => ({ name: target, value: target })),
+                { name: 'Other (specify manually)', value: 'custom' },
+            ];
+            const { selectedTarget } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'selectedTarget',
+                    message: `Which ${targetType} should this query target?`,
+                    choices,
+                    default: availableTargets[0],
+                },
+            ]);
+            if (selectedTarget === 'custom') {
+                const { customTarget } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'customTarget',
+                        message: `Enter the ${targetType} name:`,
+                        validate: (input) => {
+                            if (!input.trim()) {
+                                return `${targetType} name cannot be empty`;
+                            }
+                            return true;
+                        },
+                    },
+                ]);
+                targetName = toKebabCase(customTarget);
+            }
+            else {
+                targetName = selectedTarget;
+            }
+        }
+        else {
+            // No targets found, ask for manual input
+            console.log(chalk.yellow(`⚠️  No ${targetType}s found in the project.`));
+            const { customTarget } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'customTarget',
+                    message: `Enter the ${targetType} name this query should target:`,
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return `${targetType} name cannot be empty`;
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            targetName = toKebabCase(customTarget);
+        }
+        // Ask for the input message
+        const { inputMessage } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'inputMessage',
+                message: 'What message should the query send to the agent?',
+                default: `Hello! Can you help me understand what you can do for the ${projectName} project?`,
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Input message cannot be empty';
+                    }
+                    return true;
+                },
+            },
+        ]);
+        return {
+            name,
+            queryName,
+            projectName,
+            projectDirectory: projectDir,
+            targetType,
+            targetName,
+            inputMessage,
+        };
+    }
+    /**
+     * Generate the query file
+     */
+    async generateQueryFile(config) {
+        const templatePath = this.templateDiscovery.getTemplatePath('query');
+        if (!this.templateDiscovery.templateExists('query')) {
+            throw new TemplateError(`Query template not found at: ${templatePath}`, templatePath, [
+                'Ensure the templates directory exists',
+                'Check that the query template is properly installed',
+                'Verify file permissions',
+            ]);
+        }
+        // Set up template variables
+        const variables = {
+            queryName: config.queryName,
+            targetType: config.targetType,
+            targetName: config.targetName,
+            projectName: config.projectName,
+            inputMessage: config.inputMessage,
+        };
+        this.templateEngine.setVariables(variables);
+        // Ensure queries directory exists
+        const queriesDir = path.join(config.projectDirectory, 'queries');
+        if (!fs.existsSync(queriesDir)) {
+            fs.mkdirSync(queriesDir, { recursive: true });
+            console.log(chalk.blue(`📁 Created queries directory: ${queriesDir}`));
+        }
+        // Process the query template file
+        const templateFilePath = path.join(templatePath, 'query.template.yaml');
+        const destinationFilePath = path.join(queriesDir, `${config.queryName}-query.yaml`);
+        await this.templateEngine.processFile(templateFilePath, destinationFilePath);
+        console.log(chalk.green(`✅ Query file created: queries/${config.queryName}-query.yaml`));
+    }
+    /**
+     * Main generation method
+     */
+    async generate(name, destination, options) {
+        await ErrorHandler.catchAndHandle(async () => {
+            console.log(chalk.blue('🔍 Generating query...'));
+            // Get configuration
+            const config = await this.getQueryConfig(name, destination, options);
+            console.log(chalk.blue(`\n📝 Query details:`));
+            console.log(chalk.gray(`  Name: ${config.queryName}`));
+            console.log(chalk.gray(`  Target ${config.targetType}: ${config.targetName}`));
+            console.log(chalk.gray(`  Project: ${config.projectName}`));
+            console.log(chalk.gray(`  Message: ${config.inputMessage.substring(0, 50)}${config.inputMessage.length > 50 ? '...' : ''}`));
+            // Generate query file
+            await this.generateQueryFile(config);
+            console.log(chalk.green('\n🎉 Query generation completed successfully!'));
+            console.log(chalk.cyan('\n💡 Next steps:'));
+            console.log(chalk.gray(`  1. Review the generated query: queries/${config.queryName}-query.yaml`));
+            console.log(chalk.gray(`  2. Test the query: kubectl apply -f queries/${config.queryName}-query.yaml`));
+            console.log(chalk.gray(`  3. Check results: kubectl get queries`));
+        }, 'Generating query');
+    }
+}

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

@@ -0,0 +1,2 @@
+import { Generator } from '../index.js';
+export declare function createTeamGenerator(): Generator;

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

@@ -0,0 +1,407 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import path from 'path';
+import fs from 'fs';
+import { TemplateEngine } from '../templateEngine.js';
+import { TemplateDiscovery } from '../templateDiscovery.js';
+import { toKebabCase, isValidKubernetesName } from '../utils/nameUtils.js';
+import { validateCurrentProject, getCurrentProjectDirectory, } from '../utils/projectUtils.js';
+export function createTeamGenerator() {
+    return {
+        name: 'team',
+        description: 'Generate a new team with selected agents',
+        templatePath: 'templates/team',
+        generate: async (name, destination, options) => {
+            const generator = new TeamGenerator();
+            await generator.generate(name, destination, options);
+        },
+    };
+}
+class TeamGenerator {
+    constructor() {
+        this.templateDiscovery = new TemplateDiscovery();
+        this.templateEngine = new TemplateEngine();
+    }
+    /**
+     * Discover existing agents in the project
+     */
+    async discoverAgents(projectDir) {
+        const agentsDir = path.join(projectDir, 'agents');
+        const agents = [];
+        if (!fs.existsSync(agentsDir)) {
+            return agents;
+        }
+        const files = fs.readdirSync(agentsDir);
+        for (const file of files) {
+            if (file.endsWith('-agent.yaml') && file !== '.keep') {
+                const filePath = path.join(agentsDir, file);
+                const agentName = file.replace('-agent.yaml', '');
+                agents.push({
+                    name: agentName,
+                    fileName: file,
+                    path: filePath,
+                });
+            }
+        }
+        return agents;
+    }
+    /**
+     * Get team configuration from user input and validation
+     */
+    async getTeamConfig(name, _destination, _options) {
+        // Validate that we're in a project directory
+        const projectDir = getCurrentProjectDirectory();
+        const validation = validateCurrentProject();
+        if (!validation.isValid) {
+            throw new Error(validation.error || 'Invalid project structure');
+        }
+        const projectName = validation.projectName || path.basename(projectDir);
+        // Normalize team name
+        const teamName = toKebabCase(name);
+        if (!isValidKubernetesName(teamName)) {
+            throw new Error(`Invalid team name: ${teamName}. Must be lowercase kebab-case`);
+        }
+        // Check if team already exists
+        const teamsDir = path.join(projectDir, 'teams');
+        const teamFilePath = path.join(teamsDir, `${teamName}-team.yaml`);
+        if (fs.existsSync(teamFilePath)) {
+            console.log(chalk.yellow(`⚠️  Team file already exists: ${teamFilePath}`));
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: 'Do you want to overwrite the existing team?',
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                throw new Error('Team generation cancelled');
+            }
+        }
+        // Discover existing agents
+        const existingAgents = await this.discoverAgents(projectDir);
+        // Select team strategy
+        const { strategy } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'strategy',
+                message: 'Select team strategy:',
+                choices: [
+                    { name: 'Sequential - Agents execute in order', value: 'sequential' },
+                    { name: 'Round Robin - Agents take turns', value: 'round-robin' },
+                    { name: 'Graph - Custom workflow with dependencies', value: 'graph' },
+                    { name: 'Selector - AI chooses the next agent', value: 'selector' },
+                ],
+                default: 'sequential',
+            },
+        ]);
+        // Select agents for the team
+        const teamMembers = await this.selectTeamMembers(existingAgents, projectName, projectDir);
+        // Ask if user wants to create a query for the team
+        const { createQuery } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'createQuery',
+                message: `Would you like to create a sample query for the ${teamName} team?`,
+                default: true,
+            },
+        ]);
+        return {
+            name,
+            teamName,
+            projectName,
+            projectDirectory: projectDir,
+            strategy,
+            members: teamMembers,
+            createQuery,
+        };
+    }
+    /**
+     * Build choices for existing agents
+     */
+    buildExistingAgentChoices(existingAgents, members) {
+        if (existingAgents.length === 0) {
+            return [];
+        }
+        const choices = [
+            {
+                name: '--- Select from existing agents ---',
+                value: 'separator',
+                disabled: true,
+            },
+        ];
+        existingAgents.forEach((agent) => {
+            const alreadySelected = members.some((m) => m.name === `${agent.name}-agent`);
+            choices.push({
+                name: `${agent.name}-agent${alreadySelected ? ' (already selected)' : ''}`,
+                value: `existing:${agent.name}`,
+                disabled: alreadySelected,
+            });
+        });
+        return choices;
+    }
+    /**
+     * Build action choices for the member selection menu
+     */
+    buildActionChoices(members) {
+        const choices = [
+            { name: '--- Actions ---', value: 'separator', disabled: true },
+            { name: '➕ Create a new agent', value: 'create-new' },
+            { name: '✅ Done selecting members', value: 'done' },
+        ];
+        if (members.length > 0) {
+            choices.push({ name: '❌ Remove last member', value: 'remove-last' });
+        }
+        return choices;
+    }
+    /**
+     * Handle different member selection actions
+     */
+    async handleMemberAction(action, members, existingAgents, projectName, projectDir) {
+        if (action === 'done') {
+            if (members.length === 0) {
+                console.log(chalk.yellow('⚠️  A team must have at least one member'));
+                return false; // Continue the loop
+            }
+            return true; // Exit the loop
+        }
+        if (action === 'remove-last') {
+            const removed = members.pop();
+            console.log(chalk.gray(`➖ Removed: ${removed?.name}`));
+            return false; // Continue the loop
+        }
+        if (action === 'create-new') {
+            const newAgent = await this.createNewAgent(projectName, projectDir);
+            if (newAgent) {
+                members.push({ name: `${newAgent}-agent`, type: 'agent' });
+                console.log(chalk.green(`➕ Added: ${newAgent}-agent`));
+                // Refresh existing agents list
+                const updatedAgents = await this.discoverAgents(projectDir);
+                existingAgents.length = 0;
+                existingAgents.push(...updatedAgents);
+            }
+            return false; // Continue the loop
+        }
+        if (action.startsWith('existing:')) {
+            const agentName = action.replace('existing:', '');
+            members.push({ name: `${agentName}-agent`, type: 'agent' });
+            console.log(chalk.green(`➕ Added: ${agentName}-agent`));
+            return false; // Continue the loop
+        }
+        return false; // Continue the loop for unknown actions
+    }
+    /**
+     * Interactive agent selection and creation
+     */
+    async selectTeamMembers(existingAgents, projectName, projectDir) {
+        const members = [];
+        while (true) {
+            const existingChoices = this.buildExistingAgentChoices(existingAgents, members);
+            const actionChoices = this.buildActionChoices(members);
+            const choices = [...existingChoices, ...actionChoices];
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: `Select team members (${members.length} selected):`,
+                    choices,
+                },
+            ]);
+            const shouldExit = await this.handleMemberAction(action, members, existingAgents, projectName, projectDir);
+            if (shouldExit) {
+                break;
+            }
+        }
+        return members;
+    }
+    /**
+     * Create a new agent using the agent generator
+     */
+    async createNewAgent(projectName, projectDir) {
+        const { agentName } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'agentName',
+                message: 'Enter the name for the new agent:',
+                validate: (input) => {
+                    if (!input.trim()) {
+                        return 'Agent name cannot be empty';
+                    }
+                    const normalizedName = toKebabCase(input);
+                    if (!isValidKubernetesName(normalizedName)) {
+                        return 'Agent name must be lowercase kebab-case';
+                    }
+                    return true;
+                },
+                filter: (input) => toKebabCase(input.trim()),
+            },
+        ]);
+        try {
+            // Use the template engine to create the agent
+            const agentTemplateEngine = new TemplateEngine();
+            const templatePath = this.templateDiscovery.getTemplatePath('agent');
+            if (!this.templateDiscovery.templateExists('agent')) {
+                throw new Error(`Agent template not found at: ${templatePath}`);
+            }
+            // Set up template variables
+            const variables = {
+                agentName,
+                projectName,
+            };
+            agentTemplateEngine.setVariables(variables);
+            // Process the agent template file
+            const templateFilePath = path.join(templatePath, 'agent.template.yaml');
+            const destinationFilePath = path.join(projectDir, 'agents', `${agentName}-agent.yaml`);
+            await agentTemplateEngine.processFile(templateFilePath, destinationFilePath);
+            console.log(chalk.green(`📝 Created agent: ${agentName}-agent`));
+            return agentName;
+        }
+        catch (error) {
+            console.error(chalk.red(`❌ Failed to create agent: ${error}`));
+            return null;
+        }
+    }
+    /**
+     * Generate the team file
+     */
+    async generateTeamFile(config) {
+        const templatePath = this.templateDiscovery.getTemplatePath('team');
+        if (!this.templateDiscovery.templateExists('team')) {
+            throw new Error(`Team template not found at: ${templatePath}`);
+        }
+        // For simple teams, use the first agent as the primary agent
+        const primaryAgentName = config.members[0]?.name.replace('-agent', '') || 'default';
+        // Set up template variables
+        const variables = {
+            teamName: config.teamName,
+            projectName: config.projectName,
+            agentName: primaryAgentName,
+        };
+        this.templateEngine.setVariables(variables);
+        // Process the team template file
+        const templateFilePath = path.join(templatePath, 'team.template.yaml');
+        const destinationFilePath = path.join(config.projectDirectory, 'teams', `${config.teamName}-team.yaml`);
+        await this.templateEngine.processFile(templateFilePath, destinationFilePath);
+        // Post-process the file to update members and strategy
+        await this.updateTeamFile(destinationFilePath, config);
+    }
+    /**
+     * Update the generated team file with selected members and strategy
+     */
+    async updateTeamFile(filePath, config) {
+        let content = fs.readFileSync(filePath, 'utf-8');
+        // Update strategy
+        content = content.replace(/strategy: "sequential"/, `strategy: "${config.strategy}"`);
+        // Update members section using safe line-based replacement to avoid regex backtracking DoS
+        const lines = content.split('\n');
+        const membersHeaderIndex = lines.findIndex((line) => {
+            // Safe string-based check to avoid ReDoS vulnerability
+            const trimmed = line.trim();
+            return trimmed === 'members:';
+        });
+        if (membersHeaderIndex !== -1) {
+            const baseIndentRegex = /^\s*/;
+            const baseIndentMatch = baseIndentRegex.exec(lines[membersHeaderIndex]);
+            const baseIndent = baseIndentMatch ? baseIndentMatch[0] : '';
+            // Find the end of the current members block by scanning until a line with
+            // indentation less than or equal to the base indent (i.e., next top-level key)
+            let endIndex = membersHeaderIndex + 1;
+            while (endIndex < lines.length) {
+                const currentLine = lines[endIndex];
+                // Always advance through empty lines inside the block
+                if (currentLine.trim().length === 0) {
+                    endIndex++;
+                    continue;
+                }
+                const indentRegex = /^\s*/;
+                const currentIndent = (indentRegex.exec(currentLine) || [''])[0];
+                if (currentIndent.length <= baseIndent.length) {
+                    break;
+                }
+                endIndex++;
+            }
+            // Build the new members block with correct indentation derived from the file
+            const memberIndent = baseIndent + '  ';
+            const newMemberLines = [];
+            for (const member of config.members) {
+                newMemberLines.push(`${memberIndent}- name: ${member.name}`);
+                newMemberLines.push(`${memberIndent}  type: ${member.type}`);
+            }
+            // Splice in the new block
+            const replacement = newMemberLines.length > 0 ? newMemberLines : [];
+            lines.splice(membersHeaderIndex + 1, Math.max(0, endIndex - (membersHeaderIndex + 1)), ...replacement);
+            content = lines.join('\n');
+        }
+        fs.writeFileSync(filePath, content);
+    }
+    /**
+     * Generate the query file for the team
+     */
+    async generateQueryFile(config) {
+        const templatePath = this.templateDiscovery.getTemplatePath('query');
+        if (!this.templateDiscovery.templateExists('query')) {
+            throw new Error(`Query template not found at: ${templatePath}`);
+        }
+        // Set up template variables
+        const variables = {
+            queryName: config.teamName,
+            targetType: 'team',
+            targetName: config.teamName,
+            projectName: config.projectName,
+            inputMessage: `Hello! Can you help me understand what the ${config.teamName} team can do for the ${config.projectName} project?`,
+        };
+        this.templateEngine.setVariables(variables);
+        // Process the query template file
+        const templateFilePath = path.join(templatePath, 'query.template.yaml');
+        const destinationFilePath = path.join(config.projectDirectory, 'queries', `${config.teamName}-query.yaml`);
+        await this.templateEngine.processFile(templateFilePath, destinationFilePath);
+    }
+    /**
+     * Main generate method
+     */
+    async generate(name, destination, options) {
+        console.log(chalk.blue(`👥 ARK Team Generator\n`));
+        try {
+            // Get team configuration
+            const config = await this.getTeamConfig(name, destination, options);
+            console.log(chalk.cyan(`📋 Team Configuration:`));
+            console.log(chalk.gray(`  Name: ${config.teamName}`));
+            console.log(chalk.gray(`  Project: ${config.projectName}`));
+            console.log(chalk.gray(`  Strategy: ${config.strategy}`));
+            console.log(chalk.gray(`  Members: ${config.members.length} agent(s)`));
+            config.members.forEach((member) => {
+                console.log(chalk.gray(`    - ${member.name}`));
+            });
+            console.log(chalk.gray(`  Directory: ${config.projectDirectory}\n`));
+            // Generate the team
+            console.log(chalk.blue(`🔧 Generating team: ${config.teamName}`));
+            await this.generateTeamFile(config);
+            // Generate query if requested
+            if (config.createQuery) {
+                console.log(chalk.blue(`🔧 Generating query for team: ${config.teamName}`));
+                await this.generateQueryFile(config);
+            }
+            console.log(chalk.green(`\n✅ Successfully generated team: ${config.teamName}`));
+            console.log(chalk.gray(`📁 Created: teams/${config.teamName}-team.yaml`));
+            if (config.createQuery) {
+                console.log(chalk.gray(`📁 Created: queries/${config.teamName}-query.yaml`));
+            }
+            // Show next steps
+            console.log(chalk.cyan(`\n📋 Next Steps:`));
+            console.log(chalk.gray(`  1. Review and customise the team configuration`));
+            if (config.createQuery) {
+                console.log(chalk.gray(`  2. Review and customise the query configuration`));
+                console.log(chalk.gray(`  3. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  4. Test with: kubectl get teams,queries`));
+            }
+            else {
+                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  3. Test with: kubectl get teams`));
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`\n❌ Failed to generate team:`), error);
+            throw error;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+export interface GeneratorOptions {
+    name?: string;
+    destination?: string;
+    interactive?: boolean;
+    projectType?: string;
+    namespace?: string;
+    skipModels?: boolean;
+    skipGit?: boolean;
+    selectedModels?: string;
+    azureApiKey?: string;
+    azureBaseUrl?: string;
+    aigwBaseUrl?: string;
+    gitUserName?: string;
+    gitUserEmail?: string;
+    gitCreateCommit?: boolean;
+}
+export interface Generator {
+    name: string;
+    description: string;
+    templatePath: string;
+    generate(name: string, destination: string, options: GeneratorOptions): Promise<void>;
+}
+export declare function createGenerateCommand(): Command;