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

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

@@ -1,256 +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;

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

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

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

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

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

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