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

package/dist/commands/dev/index.js

@@ -1,9 +0,0 @@
-import { Command } from 'commander';
-import { createToolCommand } from './tool/index.js';
-export function createDevCommand(_) {
-    const devCommand = new Command('dev');
-    devCommand.description('Development tools for ARK');
-    // Add subcommands
-    devCommand.addCommand(createToolCommand());
-    return devCommand;
-}

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

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

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

@@ -1,142 +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 checkTool(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 createCheckCommand() {
-    const checkCommand = new Command('check');
-    checkCommand
-        .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(checkTool);
-    return checkCommand;
-}

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

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

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

@@ -1,153 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs';
-import yaml from 'yaml';
-import inquirer from 'inquirer';
-import output from '../../../lib/output.js';
-async function cleanTool(toolPath, options = {}) {
-    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 to validate it's parseable
-    yaml.parse(fs.readFileSync(arkConfigPath, 'utf-8'));
-    // Find template directory
-    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)) {
-        output.error('Template directory not found');
-        process.exit(1);
-    }
-    // Collect all template-based files (not directories)
-    const allTemplateFiles = [];
-    const dirsToCheck = new Set();
-    collectTemplateFiles(templateDir, absolutePath, allTemplateFiles, dirsToCheck);
-    // Filter to only existing files
-    const filesToClean = allTemplateFiles.filter((file) => {
-        const fullPath = path.join(absolutePath, file);
-        return fs.existsSync(fullPath);
-    });
-    if (filesToClean.length === 0) {
-        console.log(chalk.green('No template-generated files found to clean.'));
-        return;
-    }
-    console.log(chalk.yellow(`Found ${filesToClean.length} template-generated file(s) to potentially remove:`));
-    // Display the list of files
-    filesToClean.forEach((file) => {
-        console.log(chalk.gray(`  - ${file}`));
-    });
-    console.log();
-    let removedCount = 0;
-    let skippedCount = 0;
-    // First, delete individual files
-    for (const file of filesToClean) {
-        const fullPath = path.join(absolutePath, file);
-        // Ask for confirmation unless --yes flag is set
-        let shouldDelete = options.yes;
-        if (!shouldDelete) {
-            const answer = await inquirer.prompt([
-                {
-                    type: 'confirm',
-                    name: 'delete',
-                    message: `Delete file ${chalk.cyan(file)}?`,
-                    default: false,
-                },
-            ]);
-            shouldDelete = answer.delete;
-        }
-        if (shouldDelete) {
-            try {
-                fs.unlinkSync(fullPath);
-                console.log(chalk.green(`  ✓ Removed ${file}`));
-                removedCount++;
-            }
-            catch (err) {
-                console.log(chalk.red(`  ✗ Failed to remove ${file}: ${err instanceof Error ? err.message : 'Unknown error'}`));
-            }
-        }
-        else {
-            console.log(chalk.gray(`  - Skipped ${file}`));
-            skippedCount++;
-        }
-    }
-    // Now check for empty directories and offer to delete them
-    const sortedDirs = Array.from(dirsToCheck).sort((a, b) => b.length - a.length); // Process deepest dirs first
-    for (const dir of sortedDirs) {
-        const fullPath = path.join(absolutePath, dir);
-        // Check if directory exists and is empty
-        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
-            const contents = fs.readdirSync(fullPath);
-            if (contents.length === 0) {
-                // Directory is empty, ask to delete it
-                let shouldDelete = options.yes;
-                if (!shouldDelete) {
-                    const answer = await inquirer.prompt([
-                        {
-                            type: 'confirm',
-                            name: 'delete',
-                            message: `Delete empty directory ${chalk.cyan(dir)}?`,
-                            default: false,
-                        },
-                    ]);
-                    shouldDelete = answer.delete;
-                }
-                if (shouldDelete) {
-                    try {
-                        fs.rmdirSync(fullPath);
-                        console.log(chalk.green(`  ✓ Removed empty directory ${dir}`));
-                    }
-                    catch (err) {
-                        console.log(chalk.red(`  ✗ Failed to remove directory ${dir}: ${err instanceof Error ? err.message : 'Unknown error'}`));
-                    }
-                }
-                else {
-                    console.log(chalk.gray(`  - Kept empty directory ${dir}`));
-                }
-            }
-        }
-    }
-    console.log();
-    if (removedCount > 0) {
-        console.log(chalk.green(`✓ Removed ${removedCount} file(s)`));
-    }
-    if (skippedCount > 0) {
-        console.log(chalk.gray(`Skipped ${skippedCount} file(s)`));
-    }
-}
-function collectTemplateFiles(sourceDir, targetDir, files, dirsToCheck, relativePath = '') {
-    const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            // Track directory for later checking
-            const dirPath = path.join(relativePath, entry.name);
-            dirsToCheck.add(dirPath);
-            // Recursively collect from subdirectory
-            const subSourceDir = path.join(sourceDir, entry.name);
-            collectTemplateFiles(subSourceDir, targetDir, files, dirsToCheck, dirPath);
-        }
-        else {
-            // Check if it's a template file
-            const targetFileName = entry.name.startsWith('template.')
-                ? entry.name.replace('template.', '')
-                : entry.name;
-            const filePath = path.join(relativePath, targetFileName);
-            files.push(filePath);
-        }
-    }
-}
-export function createCleanCommand() {
-    const cleanCommand = new Command('clean');
-    cleanCommand
-        .description('Remove template-generated files from an MCP tool project')
-        .argument('<path>', 'Path to the tool directory')
-        .option('-y, --yes', 'Skip confirmation prompts and delete all files')
-        .action(cleanTool);
-    return cleanCommand;
-}

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

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

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

@@ -1,28 +0,0 @@
-import { Command } from 'commander';
-import chalk from 'chalk';
-import path from 'path';
-import { generateProjectFiles } from './shared.js';
-async function generateTool(toolPath, options = {}) {
-    const absolutePath = path.resolve(toolPath);
-    if (!options.dryRun) {
-        if (options.overwrite) {
-            console.log(chalk.yellow('Overwrite mode: existing files will be replaced'));
-        }
-    }
-    await generateProjectFiles(absolutePath, {
-        interactive: !options.dryRun,
-        dryRun: options.dryRun,
-        overwrite: options.overwrite,
-    });
-    // Next steps message removed - files are ready to use
-}
-export function createGenerateCommand() {
-    const generateCommand = new Command('generate');
-    generateCommand
-        .description('Generate project files (Dockerfile, .dockerignore, etc.) from templates')
-        .argument('<path>', 'Path to the tool directory')
-        .option('--dry-run', 'Show generated template files without creating them')
-        .option('--overwrite', 'Overwrite existing files')
-        .action(generateTool);
-    return generateCommand;
-}

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

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

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

@@ -1,14 +0,0 @@
-import { Command } from 'commander';
-import { createCheckCommand } from './check.js';
-import { createInitCommand } from './init.js';
-import { createGenerateCommand } from './generate.js';
-import { createCleanCommand } from './clean.js';
-export function createToolCommand() {
-    const toolCommand = new Command('tool');
-    toolCommand.description('MCP tool development utilities');
-    toolCommand.addCommand(createCheckCommand());
-    toolCommand.addCommand(createInitCommand());
-    toolCommand.addCommand(createGenerateCommand());
-    toolCommand.addCommand(createCleanCommand());
-    return toolCommand;
-}

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

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