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

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

@@ -1,320 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import path from 'path';
-import ora from 'ora';
-import inquirer from 'inquirer';
-import fs from 'fs';
-import yaml from 'yaml';
-import output from '../../../lib/output.js';
-import { ArkDevToolAnalyzer } from '../../../lib/dev/tools/analyzer.js';
-import { generateProjectFiles } from './shared.js';
-async function initTool(toolPath) {
-    const absolutePath = path.resolve(toolPath);
-    const analyzer = new ArkDevToolAnalyzer();
-    // Check if .ark.yaml already exists
-    const arkConfigPath = path.join(absolutePath, '.ark.yaml');
-    if (fs.existsSync(arkConfigPath)) {
-        const { overwrite } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'overwrite',
-                message: chalk.yellow('.ark.yaml already exists. Overwrite?'),
-                default: false,
-            },
-        ]);
-        if (!overwrite) {
-            console.log(chalk.gray('Initialization cancelled'));
-            return;
-        }
-    }
-    // Initialize configuration object
-    const arkConfig = {
-        version: '1.0',
-        project: {},
-    };
-    // Step 1: Check if path exists and is a directory
-    const checkSpinner = ora('Checking project path...').start();
-    const project = await analyzer.discoverProject(absolutePath);
-    if (!project || !project.exists) {
-        checkSpinner.fail('Path not found');
-        output.error(`Path not found: ${absolutePath}`);
-        process.exit(1);
-    }
-    if (!project.is_directory) {
-        checkSpinner.fail('Path is not a directory');
-        output.error(`Path is not a directory: ${absolutePath}`);
-        process.exit(1);
-    }
-    checkSpinner.succeed('Project path verified');
-    arkConfig.project.path = absolutePath;
-    // Step 2: Detect platform
-    console.log();
-    if (!project.platform) {
-        console.log(chalk.yellow('⚠ No Python project files found (pyproject.toml or requirements.txt)'));
-        const { continueWithoutProject } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'continueWithoutProject',
-                message: 'Continue without project files?',
-                default: false,
-            },
-        ]);
-        if (!continueWithoutProject) {
-            console.log(chalk.gray('Initialization cancelled'));
-            return;
-        }
-        // Set defaults but don't create anything
-        arkConfig.project.platform = 'python3';
-        arkConfig.project.type = 'none';
-    }
-    else {
-        console.log(chalk.green(`✓ Detected platform: ${chalk.white(project.platform)}`));
-        console.log(chalk.gray(`  Found from: ${project.project_type === 'pyproject' ? 'pyproject.toml' : 'requirements.txt'}`));
-        const { confirmPlatform } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'confirmPlatform',
-                message: `Confirm platform is ${project.platform}?`,
-                default: true,
-            },
-        ]);
-        if (!confirmPlatform) {
-            console.log(chalk.gray('Initialization cancelled'));
-            return;
-        }
-        arkConfig.project.platform = project.platform;
-        arkConfig.project.type = project.project_type;
-        // Step 3: Project metadata
-        if (project.project_name) {
-            console.log();
-            console.log(chalk.green(`✓ Found project name: ${chalk.white(project.project_name)}`));
-            console.log(chalk.gray(`  From: pyproject.toml [project.name]`));
-            const { confirmName } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirmName',
-                    message: `Save project name as "${project.project_name}"?`,
-                    default: true,
-                },
-            ]);
-            if (confirmName) {
-                arkConfig.project.name = project.project_name;
-            }
-            if (project.project_version) {
-                console.log();
-                console.log(chalk.green(`✓ Found project version: ${chalk.white(project.project_version)}`));
-                console.log(chalk.gray(`  From: pyproject.toml [project.version]`));
-                const { confirmVersion } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'confirmVersion',
-                        message: `Save project version as "${project.project_version}"?`,
-                        default: true,
-                    },
-                ]);
-                if (confirmVersion) {
-                    arkConfig.project.version = project.project_version;
-                }
-            }
-        }
-        // Step 4: Check for FastMCP
-        console.log();
-        if (project.has_fastmcp) {
-            console.log(chalk.green(`✓ Found FastMCP framework: ${chalk.white(`v${project.fastmcp_version || 'unknown'}`)}`));
-            console.log(chalk.gray(`  From: ${project.project_type === 'pyproject' ? 'pyproject.toml dependencies' : 'requirements.txt'}`));
-            const { confirmFramework } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirmFramework',
-                    message: `Save framework as FastMCP v${project.fastmcp_version}?`,
-                    default: true,
-                },
-            ]);
-            if (confirmFramework) {
-                arkConfig.project.framework = 'fastmcp';
-                arkConfig.project.frameworkVersion = project.fastmcp_version;
-            }
-        }
-        else {
-            console.log(chalk.yellow('⚠ FastMCP not found in dependencies'));
-            console.log(chalk.gray(`  Checked: ${project.project_type === 'pyproject' ? 'pyproject.toml' : 'requirements.txt'}`));
-            const { recordMissing } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'recordMissing',
-                    message: 'Record that FastMCP is not installed?',
-                    default: true,
-                },
-            ]);
-            if (recordMissing) {
-                arkConfig.project.framework = 'none';
-            }
-        }
-    }
-    // Step 5: MCP Transport Configuration (only if FastMCP is detected)
-    if (arkConfig.project.framework === 'fastmcp') {
-        // Try to detect transport from existing code
-        let detectedTransport = null;
-        const pythonFiles = fs
-            .readdirSync(absolutePath)
-            .filter((f) => f.endsWith('.py'));
-        for (const file of pythonFiles) {
-            const content = fs.readFileSync(path.join(absolutePath, file), 'utf-8');
-            if (content.includes('transport="sse"')) {
-                detectedTransport = 'sse';
-                break;
-            }
-            else if (content.includes('transport="http"')) {
-                detectedTransport = 'http';
-                break;
-            }
-            else if (content.includes('transport="stdio"') ||
-                content.includes('.run()')) {
-                detectedTransport = 'stdio';
-                break;
-            }
-        }
-        if (detectedTransport) {
-            console.log(chalk.green(`✓ MCP: Detected transport ${chalk.white(detectedTransport)}`));
-            const { confirmTransport } = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'confirmTransport',
-                    message: `Use transport "${detectedTransport}"?`,
-                    default: true,
-                },
-            ]);
-            if (confirmTransport) {
-                arkConfig.mcp = { transport: detectedTransport };
-            }
-        }
-        // If not detected or not confirmed, ask
-        if (!arkConfig.mcp) {
-            const { transport } = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'transport',
-                    message: 'Select MCP transport for deployment:',
-                    choices: [
-                        {
-                            name: 'SSE (Server-Sent Events) - Recommended for Kubernetes',
-                            value: 'sse',
-                            short: 'SSE',
-                        },
-                        {
-                            name: 'HTTP - Stateless request/response',
-                            value: 'http',
-                            short: 'HTTP',
-                        },
-                        {
-                            name: 'STDIO - Standard input/output for CLI tools',
-                            value: 'stdio',
-                            short: 'STDIO',
-                        },
-                    ],
-                    default: 'sse',
-                },
-            ]);
-            arkConfig.mcp = { transport };
-        }
-        // Ask for port if not stdio
-        if (arkConfig.mcp.transport !== 'stdio') {
-            const { port } = await inquirer.prompt([
-                {
-                    type: 'input',
-                    name: 'port',
-                    message: 'MCP server port:',
-                    default: '8080',
-                    validate: (input) => {
-                        const num = parseInt(input);
-                        if (isNaN(num) || num < 1 || num > 65535) {
-                            return 'Please enter a valid port number (1-65535)';
-                        }
-                        return true;
-                    },
-                },
-            ]);
-            arkConfig.mcp.port = parseInt(port);
-            // Show configuration snippet
-            console.log();
-            console.log(chalk.yellow('📝 Add this to your MCP server code:'));
-            console.log(chalk.gray('─'.repeat(40)));
-            if (arkConfig.mcp.transport === 'sse') {
-                console.log(chalk.green(`if __name__ == "__main__":
-    import os
-    port = int(os.environ.get("PORT", "${arkConfig.mcp.port}"))
-    mcp.run(transport="sse", host="0.0.0.0", port=port)`));
-            }
-            else if (arkConfig.mcp.transport === 'http') {
-                console.log(chalk.green(`if __name__ == "__main__":
-    import os
-    port = int(os.environ.get("PORT", "${arkConfig.mcp.port}"))
-    mcp.run(transport="http", host="0.0.0.0", port=port, path="/")`));
-            }
-            console.log(chalk.gray('─'.repeat(40)));
-            console.log(chalk.dim('The PORT environment variable will be set by Kubernetes'));
-        }
-    }
-    // Step 6: Write .ark.yaml
-    console.log();
-    const writeSpinner = ora('Writing .ark.yaml configuration...').start();
-    try {
-        const yamlContent = yaml.stringify(arkConfig);
-        fs.writeFileSync(arkConfigPath, yamlContent, 'utf-8');
-        writeSpinner.succeed('.ark.yaml created successfully');
-        console.log();
-        console.log(chalk.blue('Configuration Summary:'));
-        console.log(chalk.gray('─'.repeat(40)));
-        console.log(`Platform:  ${arkConfig.project.platform}`);
-        console.log(`Type:      ${arkConfig.project.type}`);
-        if (arkConfig.project.name) {
-            console.log(`Name:      ${arkConfig.project.name}`);
-            console.log(`Version:   ${arkConfig.project.version || 'unknown'}`);
-        }
-        if (arkConfig.project.framework) {
-            console.log(`Framework: ${arkConfig.project.framework}`);
-        }
-        if (arkConfig.mcp) {
-            console.log(`Transport: ${arkConfig.mcp.transport}`);
-            if (arkConfig.mcp.port) {
-                console.log(`Port:      ${arkConfig.mcp.port}`);
-            }
-        }
-        console.log(chalk.gray('─'.repeat(40)));
-        console.log();
-        console.log(chalk.green('✓ Initialization complete!'));
-        // Step 6: Ask about generating project files
-        console.log();
-        const { generateFiles } = await inquirer.prompt([
-            {
-                type: 'confirm',
-                name: 'generateFiles',
-                message: 'Generate project files (Dockerfile, .dockerignore, etc.)?',
-                default: true,
-            },
-        ]);
-        if (generateFiles) {
-            console.log();
-            await generateProjectFiles(absolutePath, {
-                interactive: true,
-                dryRun: false,
-                overwrite: false,
-            });
-        }
-        console.log();
-        console.log('  • Edit ' + chalk.cyan('.ark.yaml') + ' to update configuration');
-    }
-    catch (error) {
-        writeSpinner.fail('Failed to write .ark.yaml');
-        output.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        process.exit(1);
-    }
-}
-export function createInitCommand() {
-    const initCommand = new Command('init');
-    initCommand
-        .description('Initialize an MCP tool project with .ark.yaml configuration')
-        .argument('<path>', 'Path to the tool directory')
-        .action(initTool);
-    return initCommand;
-}

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

@@ -1,5 +0,0 @@
-export declare function generateProjectFiles(toolPath: string, options?: {
-    interactive?: boolean;
-    dryRun?: boolean;
-    overwrite?: boolean;
-}): Promise<boolean>;

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

@@ -1,258 +0,0 @@
-import chalk from 'chalk';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import ora from 'ora';
-import fs from 'fs';
-import yaml from 'yaml';
-import { execSync } from 'child_process';
-import output from '../../../lib/output.js';
-export async function generateProjectFiles(toolPath, options = {
-    interactive: true,
-    dryRun: false,
-    overwrite: false,
-}) {
-    const absolutePath = path.resolve(toolPath);
-    const arkConfigPath = path.join(absolutePath, '.ark.yaml');
-    // Check if .ark.yaml exists
-    if (!fs.existsSync(arkConfigPath)) {
-        output.error('.ark.yaml not found. Run "ark dev tool init" first.');
-        process.exit(1);
-    }
-    // Load .ark.yaml
-    const arkConfig = yaml.parse(fs.readFileSync(arkConfigPath, 'utf-8'));
-    const generateSpinner = options.dryRun
-        ? null
-        : ora('Generating project files...').start();
-    try {
-        // Find template directory - templates are in the source tree
-        const currentFile = fileURLToPath(import.meta.url);
-        const distDir = path.dirname(path.dirname(path.dirname(path.dirname(currentFile)))); // Goes to dist/
-        const arkCliDir = path.dirname(distDir); // Goes to ark-cli/
-        const templateDir = path.join(arkCliDir, 'templates', 'python-mcp-tool');
-        if (!fs.existsSync(templateDir)) {
-            if (generateSpinner) {
-                generateSpinner.fail('Template directory not found');
-            }
-            console.log(chalk.yellow('Could not find templates at: ' + templateDir));
-            return false;
-        }
-        // Use a Set to track all generated items (both files and directories)
-        const generatedItems = new Set();
-        const skippedItems = new Set();
-        const errors = [];
-        // Process all files and directories in the template directory
-        processTemplateDirectory(templateDir, absolutePath, arkConfig, options, {
-            generatedItems,
-            skippedItems,
-            errors,
-        });
-        if (!options.dryRun) {
-            if (generatedItems.size > 0) {
-                generateSpinner.succeed(`Generated ${generatedItems.size} file(s)`);
-                // Show the generated files after stopping the spinner
-                if (options.interactive && generatedItems.size > 0) {
-                    // Sort items for consistent display
-                    const sortedItems = Array.from(generatedItems).sort();
-                    sortedItems.forEach((item) => {
-                        console.log(chalk.green(`  ✓ Generated ${item}`));
-                    });
-                }
-            }
-            else if (skippedItems.size > 0) {
-                generateSpinner.warn(`No new files generated (${skippedItems.size} already exist)`);
-            }
-            else {
-                generateSpinner.warn('No files to generate');
-            }
-        }
-        if (errors.length > 0 && options.interactive) {
-            console.log(chalk.red('Errors:'));
-            errors.forEach((e) => console.log(chalk.red(`  - ${e}`)));
-        }
-        return generatedItems.size > 0;
-    }
-    catch (error) {
-        if (!options.dryRun && generateSpinner) {
-            generateSpinner.fail('Failed to generate project files');
-        }
-        if (options.interactive) {
-            console.log(chalk.red(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        }
-        return false;
-    }
-}
-function processTemplateDirectory(sourceDir, targetDir, arkConfig, options, stats, rootTargetDir) {
-    // Track the root target directory for relative path calculations
-    const actualRootTargetDir = rootTargetDir || targetDir;
-    // Check if this directory needs to be created
-    const dirExists = fs.existsSync(targetDir);
-    // Create target directory if it doesn't exist
-    if (!options.dryRun && !dirExists) {
-        fs.mkdirSync(targetDir, { recursive: true });
-        // Track the directory creation (relative to root)
-        const relativePath = path.relative(actualRootTargetDir, targetDir);
-        if (relativePath) {
-            // Don't add empty string for root directory
-            stats.generatedItems.add(`${relativePath}/`);
-        }
-    }
-    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = path.join(sourceDir, entry.name);
-        if (entry.isDirectory()) {
-            // Recursively process subdirectories
-            const targetSubDir = path.join(targetDir, entry.name);
-            if (options.dryRun) {
-                const relativePath = path.relative(actualRootTargetDir, targetSubDir);
-                console.log(chalk.cyan(`\n=== ${relativePath}/ directory ===`));
-                console.log(`Directory: ${entry.name}`);
-                console.log(chalk.cyan(`=== END ${relativePath}/ directory ===\n`));
-            }
-            processTemplateDirectory(sourcePath, targetSubDir, arkConfig, options, stats, actualRootTargetDir);
-        }
-        else {
-            // Process file - check if it's a template
-            const isTemplate = entry.name.startsWith('template.');
-            const targetFileName = isTemplate
-                ? entry.name.replace('template.', '')
-                : entry.name;
-            const targetPath = path.join(targetDir, targetFileName);
-            // Make target path relative to the original target directory for display
-            const displayPath = path.relative(actualRootTargetDir, targetPath);
-            // Check if file already exists
-            const fileExists = fs.existsSync(targetPath);
-            if (!options.dryRun && !options.overwrite && fileExists) {
-                if (options.interactive) {
-                    console.log(chalk.yellow(`  Skipping ${displayPath} (already exists)`));
-                }
-                stats.skippedItems.add(displayPath);
-                continue;
-            }
-            try {
-                let content;
-                if (isTemplate) {
-                    // Process template file with helm - pass the actual root target directory
-                    content = processTemplateFile(sourcePath, targetFileName, arkConfig, options, actualRootTargetDir);
-                }
-                else {
-                    // Regular file, just read it
-                    content = fs.readFileSync(sourcePath, 'utf-8');
-                }
-                // In dry-run mode, print to stdout; otherwise write the file
-                if (options.dryRun) {
-                    console.log(chalk.cyan(`\n=== ${displayPath} ===`));
-                    console.log(content);
-                    console.log(chalk.cyan(`=== END ${displayPath} ===\n`));
-                    stats.generatedItems.add(displayPath);
-                }
-                else {
-                    fs.writeFileSync(targetPath, content);
-                    stats.generatedItems.add(displayPath);
-                }
-            }
-            catch (err) {
-                const errorMsg = `${displayPath}: ${err instanceof Error ? err.message : 'Unknown error'}`;
-                stats.errors.push(errorMsg);
-                if (options.dryRun) {
-                    console.log(chalk.red(`Error processing ${displayPath}: ${err instanceof Error ? err.message : 'Unknown error'}`));
-                }
-            }
-        }
-    }
-}
-function processTemplateFile(templatePath, targetFileName, arkConfig, options, rootTargetDir) {
-    // Prepare consistent values structure for all templates
-    const projectName = arkConfig.project?.name ||
-        path.basename(rootTargetDir || path.dirname(templatePath));
-    const values = {
-        project: {
-            name: projectName,
-            type: arkConfig.project?.type || 'pyproject',
-            platform: arkConfig.project?.platform || 'python3',
-            version: arkConfig.project?.version || '0.1.0',
-            framework: arkConfig.project?.framework || 'fastmcp',
-            description: arkConfig.project?.description || `${projectName} MCP tool`,
-        },
-        python: {
-            version: '3.11', // Default Python version
-            module_name: projectName.replace(/-/g, '_'), // Convert kebab-case to snake_case
-        },
-        mcp: {
-            transport: arkConfig.mcp?.transport || 'sse', // Default to SSE for Kubernetes
-            port: arkConfig.mcp?.port || 8080,
-            healthCheck: arkConfig.mcp?.transport !== 'stdio', // No health checks for stdio
-        },
-        devspace: {
-            namespace: 'default',
-            image: {
-                repository: projectName, // Default repository name
-            },
-        },
-    };
-    // Create temp directory for helm processing
-    const tempDir = path.join('/tmp', `ark-helm-${Date.now()}`);
-    const tempChartDir = path.join(tempDir, 'chart');
-    const tempTemplatesDir = path.join(tempChartDir, 'templates');
-    fs.mkdirSync(tempTemplatesDir, { recursive: true });
-    try {
-        // Write minimal Chart.yaml
-        fs.writeFileSync(path.join(tempChartDir, 'Chart.yaml'), 'apiVersion: v2\nname: temp\nversion: 0.1.0\n');
-        // Write values file
-        const tempValuesFile = path.join(tempDir, 'values.yaml');
-        fs.writeFileSync(tempValuesFile, yaml.stringify(values));
-        // Determine if this is a YAML file
-        const isYamlFile = targetFileName.endsWith('.yaml') || targetFileName.endsWith('.yml');
-        // For dotfiles, replace the leading dot with 'dot' for helm processing
-        const helmTemplateName = targetFileName.startsWith('.')
-            ? 'dot' + targetFileName.substring(1)
-            : targetFileName;
-        if (isYamlFile) {
-            // Copy YAML files directly
-            fs.copyFileSync(templatePath, path.join(tempTemplatesDir, helmTemplateName));
-        }
-        else {
-            // Wrap non-YAML content in a YAML structure for helm
-            const originalContent = fs.readFileSync(templatePath, 'utf-8');
-            const wrappedContent = `# Wrapped for helm processing\ncontent: |\n${originalContent
-                .split('\n')
-                .map((line) => '  ' + line)
-                .join('\n')}`;
-            fs.writeFileSync(path.join(tempTemplatesDir, helmTemplateName + '.yaml'), wrappedContent);
-        }
-        // Run helm template to process the file
-        const actualHelmFile = isYamlFile
-            ? helmTemplateName
-            : helmTemplateName + '.yaml';
-        const helmCommand = `helm template temp ${tempChartDir} --values ${tempValuesFile} -s templates/${actualHelmFile}`;
-        let content;
-        try {
-            content = execSync(helmCommand, {
-                encoding: 'utf-8',
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            // Remove the YAML document separator that helm adds
-            content = content.replace(/^---\n/, '');
-            // Remove helm's source comment
-            content = content.replace(/^# Source:.*\n/gm, '');
-            // For non-YAML files, extract the content from the wrapped YAML
-            if (!isYamlFile) {
-                // Parse the YAML to extract the content field
-                const yamlContent = yaml.parse(content);
-                content = yamlContent.content || '';
-            }
-        }
-        catch (helmError) {
-            const errorMsg = helmError.stderr ||
-                helmError.message ||
-                'Unknown error';
-            throw new Error(`Failed to template ${targetFileName}: ${errorMsg}`);
-        }
-        return content;
-    }
-    finally {
-        // Clean up temp directory
-        if (fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-    }
-}

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

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