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

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

@@ -0,0 +1,258 @@
+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

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

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

@@ -0,0 +1,136 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import path from 'path';
+import ora from 'ora';
+import output from '../../../lib/output.js';
+import { ArkDevToolAnalyzer } from '../../../lib/dev/tools/analyzer.js';
+import { toMCPTool } from '../../../lib/dev/tools/mcp-types.js';
+async function statusTool(toolPath, options) {
+    const absolutePath = path.resolve(toolPath);
+    const analyzer = new ArkDevToolAnalyzer();
+    const isJson = options.output === 'json';
+    // Build up result object as we go
+    const result = {
+        path: absolutePath,
+        projectRoot: null,
+        error: null,
+        platform: null,
+        projectType: null,
+        projectName: null,
+        projectVersion: null,
+        hasFastmcp: false,
+        fastmcpVersion: null,
+        tools: [],
+        toolDiscoveryError: null
+    };
+    if (!isJson) {
+        console.log();
+    }
+    // Single spinner for all analysis (skip for JSON output)
+    const analyzeSpinner = isJson ? null : ora(`analyzing ${absolutePath}`).start();
+    // Small delay to let user see what's happening (skip for JSON)
+    if (!isJson) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    // Collect all information
+    const project = await analyzer.discoverProject(absolutePath);
+    if (!project || !project.exists) {
+        result.error = 'path not found';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`path not found: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    if (!project.is_directory) {
+        result.error = 'path is not a directory';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`path is not a directory: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    if (!project.platform) {
+        result.error = 'platform unknown - no pyproject.toml or requirements.txt found';
+        if (isJson) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            analyzeSpinner.stop();
+            output.error(`no pyproject.toml or requirements.txt found in: ${absolutePath}`);
+        }
+        process.exit(1);
+    }
+    // Update result with project info
+    result.platform = project.platform;
+    result.projectType = project.project_type;
+    result.projectName = project.project_name;
+    result.projectVersion = project.project_version;
+    result.hasFastmcp = project.has_fastmcp;
+    result.fastmcpVersion = project.fastmcp_version;
+    result.projectRoot = absolutePath; // Store the project root
+    // Discover tools recursively in the project
+    const rawTools = [];
+    try {
+        const projectTools = await analyzer.findProjectTools(absolutePath);
+        if (projectTools && projectTools.tools) {
+            rawTools.push(...projectTools.tools);
+        }
+    }
+    catch (error) {
+        result.toolDiscoveryError = error instanceof Error ? error.message : 'Unknown error';
+    }
+    // Store tools in the appropriate format
+    result.tools = isJson ? rawTools.map(toMCPTool) : rawTools;
+    if (isJson) {
+        // Output raw JSON
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    analyzeSpinner.succeed('analysis complete');
+    console.log();
+    // Display summary in cleaner format
+    output.section(path.basename(absolutePath));
+    // Platform
+    output.statusCheck('found', 'platform', result.platform);
+    // Project type with name and version in gray
+    let projectDetails = '';
+    if (result.projectName) {
+        projectDetails = result.projectName;
+        if (result.projectVersion) {
+            projectDetails += ` v${result.projectVersion}`;
+        }
+    }
+    output.statusCheck('found', 'project', result.projectType, projectDetails);
+    // Framework with version in gray
+    if (result.hasFastmcp) {
+        const fastmcpDetails = result.fastmcpVersion ? `v${result.fastmcpVersion}` : undefined;
+        output.statusCheck('found', 'framework', 'fastmcp', fastmcpDetails);
+    }
+    else {
+        output.statusCheck('missing', 'framework', 'fastmcp');
+    }
+    // Tools with details
+    output.statusCheck('found', 'tools', result.tools.length.toString());
+    if (result.tools.length > 0) {
+        for (const tool of result.tools) {
+            const description = tool.docstring ? tool.docstring.split('\n')[0] : '';
+            console.log(chalk.gray(`      - ${tool.name}: ${description}`));
+        }
+    }
+}
+export function createStatusCommand() {
+    const statusCommand = new Command('status');
+    statusCommand
+        .description('Check the status of an MCP tool project')
+        .argument('<path>', 'Path to the tool directory')
+        .option('-o, --output <format>', 'Output format (json)', 'text')
+        .action(statusTool);
+    return statusCommand;
+}

package/dist/commands/dev/tool-generate.spec.d.ts

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

package/dist/commands/dev/tool-generate.spec.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import os from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('ark dev tool generate', () => {
+    let tempDir;
+    const cliPath = path.join(__dirname, '../../../dist/index.js');
+    beforeEach(() => {
+        // Create a temp directory for testing
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ark-test-'));
+    });
+    afterEach(() => {
+        // Clean up temp directory
+        if (tempDir && fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('Dockerfile generation', () => {
+        it('should generate correct Dockerfile for pyproject type', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  path: ${tempDir}
+  platform: python3
+  type: pyproject
+  name: test-tool
+  version: 0.2.0
+  framework: fastmcp
+  frameworkVersion: 0.5.0
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check Dockerfile was generated
+            const dockerfilePath = path.join(tempDir, 'Dockerfile');
+            expect(fs.existsSync(dockerfilePath)).toBe(true);
+            // Check Dockerfile content
+            const dockerfileContent = fs.readFileSync(dockerfilePath, 'utf-8');
+            // Should have uv commands for pyproject
+            expect(dockerfileContent).toContain('RUN pip install uv');
+            expect(dockerfileContent).toContain('COPY pyproject.toml ./');
+            expect(dockerfileContent).toContain('COPY uv.lock* ./');
+            expect(dockerfileContent).toContain('RUN uv sync --frozen');
+            expect(dockerfileContent).toContain('CMD ["uv", "run", "python", "-m", "test_tool"]');
+            // Should NOT have requirements.txt commands
+            expect(dockerfileContent).not.toContain('requirements.txt');
+            expect(dockerfileContent).not.toContain('pip install --no-cache-dir');
+        });
+        it('should generate correct Dockerfile for requirements type', () => {
+            // Create a test .ark.yaml with requirements type
+            const arkYaml = `version: "1.0"
+project:
+  path: ${tempDir}
+  platform: python3
+  type: requirements
+  name: test-req-tool
+  version: 0.1.0
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check Dockerfile was generated
+            const dockerfilePath = path.join(tempDir, 'Dockerfile');
+            expect(fs.existsSync(dockerfilePath)).toBe(true);
+            // Check Dockerfile content
+            const dockerfileContent = fs.readFileSync(dockerfilePath, 'utf-8');
+            // Should have pip commands for requirements.txt
+            expect(dockerfileContent).toContain('COPY requirements.txt ./');
+            expect(dockerfileContent).toContain('RUN pip install --no-cache-dir -r requirements.txt');
+            expect(dockerfileContent).toContain('CMD ["python", "-m", "test_req_tool"]');
+            // Should NOT have uv commands
+            expect(dockerfileContent).not.toContain('RUN pip install uv');
+            expect(dockerfileContent).not.toContain('pyproject.toml');
+            expect(dockerfileContent).not.toContain('uv.lock');
+            expect(dockerfileContent).not.toContain('uv sync');
+        });
+    });
+    describe('.dockerignore generation', () => {
+        it('should generate comprehensive .dockerignore file', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  platform: python3
+  type: pyproject
+  name: test-tool
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Run the generate command
+            execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check .dockerignore was generated
+            const dockerignorePath = path.join(tempDir, '.dockerignore');
+            expect(fs.existsSync(dockerignorePath)).toBe(true);
+            // Check .dockerignore content
+            const dockerignoreContent = fs.readFileSync(dockerignorePath, 'utf-8');
+            // Should include Python patterns
+            expect(dockerignoreContent).toContain('__pycache__/');
+            expect(dockerignoreContent).toContain('*.py[cod]');
+            expect(dockerignoreContent).toContain('*.egg-info/');
+            // Should include UV patterns
+            expect(dockerignoreContent).toContain('.venv/');
+            // Should include testing patterns
+            expect(dockerignoreContent).toContain('.pytest_cache/');
+            expect(dockerignoreContent).toContain('.coverage');
+            // Should include IDE patterns
+            expect(dockerignoreContent).toContain('.vscode/');
+            expect(dockerignoreContent).toContain('.idea/');
+            // Should include ARK specific patterns
+            expect(dockerignoreContent).toContain('.ark.yaml');
+            expect(dockerignoreContent).toContain('devspace.yaml');
+        });
+    });
+    describe('file skip behavior', () => {
+        it('should skip existing files without overwriting', () => {
+            // Create a test .ark.yaml
+            const arkYaml = `version: "1.0"
+project:
+  platform: python3
+  type: pyproject
+  name: test-tool
+`;
+            fs.writeFileSync(path.join(tempDir, '.ark.yaml'), arkYaml);
+            // Create an existing Dockerfile with custom content
+            const customDockerfile = '# My custom Dockerfile\nFROM alpine\n';
+            fs.writeFileSync(path.join(tempDir, 'Dockerfile'), customDockerfile);
+            // Run the generate command
+            const output = execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                encoding: 'utf8',
+            });
+            // Check that existing file was not overwritten
+            const dockerfileContent = fs.readFileSync(path.join(tempDir, 'Dockerfile'), 'utf-8');
+            expect(dockerfileContent).toBe(customDockerfile);
+            // Check that output mentions skipping the existing file
+            expect(output).toContain('Skipping Dockerfile (already exists)');
+        });
+    });
+    describe('error handling', () => {
+        it('should fail when .ark.yaml is missing', () => {
+            // Try to run generate without .ark.yaml
+            let error = null;
+            try {
+                execSync(`node ${cliPath} dev tool generate ${tempDir}`, {
+                    encoding: 'utf8',
+                    stdio: 'pipe',
+                });
+            }
+            catch (e) {
+                error = e;
+            }
+            expect(error).not.toBeNull();
+            expect(error.message).toContain('.ark.yaml not found');
+        });
+    });
+});

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

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