@agents-at-scale/ark 0.1.31

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

@@ -0,0 +1,145 @@
+/**
+ * Shared configuration for generators across CLI and UI
+ */
+export interface ProjectTypeChoice {
+    value: 'empty' | 'with-samples';
+    label: string;
+    shortLabel?: string;
+    description?: string;
+    icon?: string;
+    recommended?: boolean;
+}
+export interface GeneratorChoice {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: string;
+}
+export interface GeneratorDefaults {
+    projectType: 'empty' | 'with-samples';
+    skipModels: boolean;
+    skipGit: boolean;
+    getDefaultDestination: () => string;
+    getDefaultNamespace: (projectName: string) => string;
+}
+/**
+ * Project type choices - shared between CLI and UI
+ */
+export declare const PROJECT_TYPE_CHOICES: ProjectTypeChoice[];
+/**
+ * Available generator types - shared between CLI and UI
+ */
+export declare const GENERATOR_CHOICES: GeneratorChoice[];
+/**
+ * Default configuration values with config manager integration
+ */
+export declare const GENERATOR_DEFAULTS: GeneratorDefaults;
+/**
+ * Validation constants
+ */
+export declare const VALIDATION_CONSTANTS: {
+    readonly MAX_NAME_LENGTH: 63;
+    readonly MIN_NAME_LENGTH: 1;
+    readonly NAME_PATTERN: RegExp;
+};
+/**
+ * UI-specific configurations
+ */
+export declare const UI_CONFIG: {
+    readonly messages: {
+        readonly projectNamePrompt: "Enter a name for your new agent project:";
+        readonly projectTypePrompt: "Choose project type:";
+        readonly generatorTypePrompt: "Choose what you'd like to generate:";
+        readonly nameTooLong: (max: number) => string;
+        readonly nameEmpty: "Name cannot be empty";
+        readonly nameInvalid: (suggested: string) => string;
+        readonly generationComplete: "Project Generated Successfully!";
+        readonly generationFailed: "Generation Failed";
+    };
+    readonly steps: {
+        readonly generatorType: "generator-type";
+        readonly projectName: "project-name";
+        readonly projectConfig: "project-config";
+        readonly generating: "generating";
+        readonly complete: "complete";
+        readonly error: "error";
+    };
+    readonly colors: {
+        readonly primary: "cyan";
+        readonly success: "green";
+        readonly error: "red";
+        readonly warning: "yellow";
+        readonly secondary: "gray";
+    };
+    readonly icons: {
+        readonly generator: "🎯";
+        readonly project: "📦";
+        readonly success: "✅";
+        readonly error: "❌";
+        readonly warning: "⚠️";
+        readonly info: "ℹ️";
+        readonly folder: "📁";
+        readonly rocket: "🚀";
+    };
+};
+/**
+ * CLI-specific configurations
+ */
+export declare const CLI_CONFIG: {
+    readonly prompts: {
+        readonly projectType: {
+            readonly type: "list";
+            readonly name: "projectType";
+            readonly message: "Project type:";
+            readonly default: "empty" | "with-samples";
+        };
+        readonly parentDir: {
+            readonly type: "input";
+            readonly name: "parentDir";
+            readonly message: "Parent directory for project:";
+            readonly filter: (input: string) => string;
+        };
+        readonly namespace: {
+            readonly type: "input";
+            readonly name: "namespace";
+            readonly message: "Kubernetes namespace:";
+        };
+    };
+    readonly messages: {
+        readonly banner: "🚀 ARK Agent Project Generator";
+        readonly checkingPrerequisites: "📋 Checking prerequisites...";
+        readonly projectConfiguration: "📋 Project Configuration";
+        readonly generatingProject: "📋 Generating project...";
+        readonly projectGenerated: "✅ Project generated successfully";
+    };
+};
+/**
+ * Get project type choices formatted for inquirer (CLI)
+ */
+export declare function getInquirerProjectTypeChoices(): {
+    name: string;
+    value: "empty" | "with-samples";
+    short: string;
+}[];
+/**
+ * Get project type choices formatted for ink-select-input (UI)
+ */
+export declare function getUIProjectTypeChoices(): {
+    label: string;
+    value: "empty" | "with-samples";
+}[];
+/**
+ * Get generator choices formatted for ink-select-input (UI)
+ */
+export declare function getUIGeneratorChoices(): {
+    label: string;
+    value: string;
+}[];
+/**
+ * Get the recommended project type
+ */
+export declare function getRecommendedProjectType(): 'empty' | 'with-samples';
+/**
+ * Get project type by value
+ */
+export declare function getProjectTypeChoice(value: 'empty' | 'with-samples'): ProjectTypeChoice | undefined;

package/dist/commands/generate/config.js

@@ -0,0 +1,253 @@
+/**
+ * Shared configuration for generators across CLI and UI
+ */
+import path from 'path';
+import { ConfigManager } from '../../lib/config.js';
+/**
+ * Project type choices - shared between CLI and UI
+ */
+export const PROJECT_TYPE_CHOICES = [
+    {
+        value: 'with-samples',
+        label: 'Project with samples (recommended for getting started)',
+        shortLabel: 'with-samples',
+        description: 'Includes sample agents, teams, models, and queries to get you started',
+        icon: '🎯',
+        recommended: true,
+    },
+    {
+        value: 'empty',
+        label: 'Empty project (just the structure)',
+        shortLabel: 'empty',
+        description: 'Just the directory structure and configuration files',
+        icon: '📁',
+        recommended: false,
+    },
+];
+/**
+ * Available generator types - shared between CLI and UI
+ */
+export const GENERATOR_CHOICES = [
+    {
+        value: 'project',
+        label: 'Project - Generate a new agent project',
+        description: 'Create a complete ARK agent project with all necessary files and structure',
+        icon: '📦',
+    },
+    {
+        value: 'agent',
+        label: 'Agent - Generate a single agent',
+        description: 'Create a new agent definition in the current project',
+        icon: '🤖',
+    },
+    {
+        value: 'team',
+        label: 'Team - Generate a team with multiple agents',
+        description: 'Create a team configuration with selected agents and strategy',
+        icon: '👥',
+    },
+    {
+        value: 'query',
+        label: 'Query - Generate a query to test agents or teams',
+        description: 'Create a query definition to test and interact with agents',
+        icon: '❓',
+    },
+    {
+        value: 'mcp-server',
+        label: 'MCP Server - Generate an MCP server with Kubernetes deployment',
+        description: 'Create an MCP server with Docker image and Kubernetes deployment configuration',
+        icon: '🔌',
+    },
+    {
+        value: 'marketplace',
+        label: 'Marketplace - Generate a marketplace repository',
+        description: 'Create a central repository for sharing reusable ARK components',
+        icon: '🏪',
+    },
+];
+/**
+ * Default configuration values with config manager integration
+ */
+export const GENERATOR_DEFAULTS = {
+    get projectType() {
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('defaultProjectType');
+        }
+        catch {
+            return 'with-samples';
+        }
+    },
+    get skipModels() {
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('skipModelsbyDefault');
+        }
+        catch {
+            return false;
+        }
+    },
+    get skipGit() {
+        try {
+            const configManager = new ConfigManager();
+            return configManager.get('skipGitByDefault');
+        }
+        catch {
+            return false;
+        }
+    },
+    getDefaultDestination: () => {
+        try {
+            const configManager = new ConfigManager();
+            const configured = configManager.get('defaultDestination');
+            if (configured && configured !== process.cwd()) {
+                return configured;
+            }
+        }
+        catch {
+            // Fall through to default logic
+        }
+        try {
+            // Get the path relative to this config file
+            // This file is at: tools/ark-cli/src/commands/generate/config.ts
+            // We want to go up to agents-at-scale and then to its parent
+            const configFileDir = new URL('.', import.meta.url).pathname;
+            const arkRoot = path.resolve(configFileDir, '../../../../../');
+            const parentDir = path.dirname(arkRoot);
+            return parentDir;
+        }
+        catch (_error) {
+            // Fallback to current working directory if we can't determine ark location
+            return process.cwd();
+        }
+    },
+    getDefaultNamespace: (projectName) => projectName,
+};
+/**
+ * Validation constants
+ */
+export const VALIDATION_CONSTANTS = {
+    MAX_NAME_LENGTH: 63,
+    MIN_NAME_LENGTH: 1,
+    NAME_PATTERN: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+};
+/**
+ * UI-specific configurations
+ */
+export const UI_CONFIG = {
+    // Text and messages
+    messages: {
+        projectNamePrompt: 'Enter a name for your new agent project:',
+        projectTypePrompt: 'Choose project type:',
+        generatorTypePrompt: "Choose what you'd like to generate:",
+        nameTooLong: (max) => `Name must be ${max} characters or less`,
+        nameEmpty: 'Name cannot be empty',
+        nameInvalid: (suggested) => `Name must be lowercase kebab-case (suggested: "${suggested}")`,
+        generationComplete: 'Project Generated Successfully!',
+        generationFailed: 'Generation Failed',
+    },
+    // Step navigation
+    steps: {
+        generatorType: 'generator-type',
+        projectName: 'project-name',
+        projectConfig: 'project-config',
+        generating: 'generating',
+        complete: 'complete',
+        error: 'error',
+    },
+    // Icons and colors
+    colors: {
+        primary: 'cyan',
+        success: 'green',
+        error: 'red',
+        warning: 'yellow',
+        secondary: 'gray',
+    },
+    icons: {
+        generator: '🎯',
+        project: '📦',
+        success: '✅',
+        error: '❌',
+        warning: '⚠️',
+        info: 'ℹ️',
+        folder: '📁',
+        rocket: '🚀',
+    },
+};
+/**
+ * CLI-specific configurations
+ */
+export const CLI_CONFIG = {
+    // Inquirer prompt configurations
+    prompts: {
+        projectType: {
+            type: 'list',
+            name: 'projectType',
+            message: 'Project type:',
+            default: GENERATOR_DEFAULTS.projectType,
+        },
+        parentDir: {
+            type: 'input',
+            name: 'parentDir',
+            message: 'Parent directory for project:',
+            filter: (input) => input.replace(/^~/, process.env.HOME || '~'),
+        },
+        namespace: {
+            type: 'input',
+            name: 'namespace',
+            message: 'Kubernetes namespace:',
+        },
+    },
+    // Console messages
+    messages: {
+        banner: '🚀 ARK Agent Project Generator',
+        checkingPrerequisites: '📋 Checking prerequisites...',
+        projectConfiguration: '📋 Project Configuration',
+        generatingProject: '📋 Generating project...',
+        projectGenerated: '✅ Project generated successfully',
+    },
+};
+/**
+ * Get project type choices formatted for inquirer (CLI)
+ */
+export function getInquirerProjectTypeChoices() {
+    return PROJECT_TYPE_CHOICES.map((choice) => ({
+        name: choice.label,
+        value: choice.value,
+        short: choice.shortLabel || choice.value,
+    }));
+}
+/**
+ * Get project type choices formatted for ink-select-input (UI)
+ */
+export function getUIProjectTypeChoices() {
+    return PROJECT_TYPE_CHOICES.map((choice) => ({
+        label: `${choice.icon || ''} ${choice.label}`,
+        value: choice.value,
+    }));
+}
+/**
+ * Get generator choices formatted for ink-select-input (UI)
+ */
+export function getUIGeneratorChoices() {
+    return [
+        ...GENERATOR_CHOICES.map((choice) => ({
+            label: `${choice.icon || ''} ${choice.label}`,
+            value: choice.value,
+        })),
+        { label: '🔙 Back to main menu', value: 'back' },
+    ];
+}
+/**
+ * Get the recommended project type
+ */
+export function getRecommendedProjectType() {
+    return (PROJECT_TYPE_CHOICES.find((choice) => choice.recommended)?.value ||
+        'with-samples');
+}
+/**
+ * Get project type by value
+ */
+export function getProjectTypeChoice(value) {
+    return PROJECT_TYPE_CHOICES.find((choice) => choice.value === value);
+}

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

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

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

@@ -0,0 +1,156 @@
+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 createAgentGenerator() {
+    return {
+        name: 'agent',
+        description: 'Generate a new agent in the current project',
+        templatePath: 'templates/agent',
+        generate: async (name, destination, options) => {
+            const generator = new AgentGenerator();
+            await generator.generate(name, destination, options);
+        },
+    };
+}
+class AgentGenerator {
+    constructor() {
+        this.templateDiscovery = new TemplateDiscovery();
+        this.templateEngine = new TemplateEngine();
+    }
+    /**
+     * Get agent configuration from user input and validation
+     */
+    async getAgentConfig(name, _destination, _options) {
+        // Validate that we're in a project directory and get project info
+        const { projectName, projectDir } = getCurrentProjectInfo();
+        // Validate and normalize agent name
+        const agentName = toKebabCase(name);
+        validateNameStrict(agentName, 'agent name');
+        // Check if agent already exists
+        const agentsDir = path.join(projectDir, 'agents');
+        const agentFilePath = path.join(agentsDir, `${agentName}-agent.yaml`);
+        if (fs.existsSync(agentFilePath)) {
+            console.log(chalk.yellow(`⚠️  Agent file already exists: ${agentFilePath}`));
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: 'Do you want to overwrite the existing agent?',
+                    default: false,
+                },
+            ]);
+            if (!overwrite) {
+                throw new ValidationError('Agent generation cancelled by user', 'overwrite', [
+                    `Use a different agent name`,
+                    `Use --force flag to overwrite without prompting`,
+                ]);
+            }
+        }
+        // Ask if user wants to create a query for the agent
+        const { createQuery } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'createQuery',
+                message: `Would you like to create a sample query for the ${agentName} agent?`,
+                default: true,
+            },
+        ]);
+        return {
+            name,
+            agentName,
+            projectName,
+            projectDirectory: projectDir,
+            createQuery,
+        };
+    }
+    /**
+     * Generate the query file for the agent
+     */
+    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.agentName,
+            targetType: 'agent',
+            targetName: config.agentName,
+            projectName: config.projectName,
+            inputMessage: `Hello! Can you help me understand what you 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.agentName}-query.yaml`);
+        await this.templateEngine.processFile(templateFilePath, destinationFilePath);
+    }
+    /**
+     * Generate the agent file
+     */
+    async generateAgentFile(config) {
+        const templatePath = this.templateDiscovery.getTemplatePath('agent');
+        if (!this.templateDiscovery.templateExists('agent')) {
+            throw new TemplateError(`Agent template not found at: ${templatePath}`, templatePath, [
+                'Ensure the templates directory exists',
+                'Check that the agent template is properly installed',
+                'Verify file permissions',
+            ]);
+        }
+        // Set up template variables
+        const variables = {
+            agentName: config.agentName,
+            projectName: config.projectName,
+        };
+        this.templateEngine.setVariables(variables);
+        // Process the agent template file
+        const templateFilePath = path.join(templatePath, 'agent.template.yaml');
+        const destinationFilePath = path.join(config.projectDirectory, 'agents', `${config.agentName}-agent.yaml`);
+        await this.templateEngine.processFile(templateFilePath, destinationFilePath);
+    }
+    /**
+     * Main generate method
+     */
+    async generate(name, destination, options) {
+        return ErrorHandler.catchAndHandle(async () => {
+            console.log(chalk.blue(`🤖 ARK Agent Generator\n`));
+            // Get agent configuration
+            const config = await this.getAgentConfig(name, destination, options);
+            console.log(chalk.cyan(`📋 Agent Configuration:`));
+            console.log(chalk.gray(`  Name: ${config.agentName}`));
+            console.log(chalk.gray(`  Project: ${config.projectName}`));
+            console.log(chalk.gray(`  Directory: ${config.projectDirectory}\n`));
+            // Generate the agent
+            console.log(chalk.blue(`🔧 Generating agent: ${config.agentName}`));
+            await this.generateAgentFile(config);
+            // Generate query if requested
+            if (config.createQuery) {
+                console.log(chalk.blue(`🔧 Generating query for agent: ${config.agentName}`));
+                await this.generateQueryFile(config);
+            }
+            console.log(chalk.green(`\n✅ Successfully generated agent: ${config.agentName}`));
+            console.log(chalk.gray(`📁 Created: agents/${config.agentName}-agent.yaml`));
+            if (config.createQuery) {
+                console.log(chalk.gray(`📁 Created: queries/${config.agentName}-query.yaml`));
+            }
+            // Show next steps
+            console.log(chalk.cyan(`\n📋 Next Steps:`));
+            console.log(chalk.gray(`  1. Review and customise the agent 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 agents,queries`));
+            }
+            else {
+                console.log(chalk.gray(`  2. Deploy with: helm upgrade --install ${config.projectName} .`));
+                console.log(chalk.gray(`  3. Test with: kubectl get agents`));
+            }
+        }, 'Generating agent');
+    }
+}

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

@@ -0,0 +1,6 @@
+export { createProjectGenerator } from './project.js';
+export { createAgentGenerator } from './agent.js';
+export { createTeamGenerator } from './team.js';
+export { createQueryGenerator } from './query.js';
+export { createMcpServerGenerator } from './mcpserver.js';
+export { createMarketplaceGenerator } from './marketplace.js';

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

@@ -0,0 +1,6 @@
+export { createProjectGenerator } from './project.js';
+export { createAgentGenerator } from './agent.js';
+export { createTeamGenerator } from './team.js';
+export { createQueryGenerator } from './query.js';
+export { createMcpServerGenerator } from './mcpserver.js';
+export { createMarketplaceGenerator } from './marketplace.js';

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

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