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

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;