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

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;

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>;