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

package/dist/lib/config.spec.js

@@ -1,99 +0,0 @@
-import { jest } from '@jest/globals';
-import path from 'path';
-import os from 'os';
-const mockFs = {
-    existsSync: jest.fn(),
-    readFileSync: jest.fn(),
-};
-jest.unstable_mockModule('fs', () => ({
-    default: mockFs,
-    ...mockFs,
-}));
-const mockYaml = {
-    parse: jest.fn(),
-    stringify: jest.fn(),
-};
-jest.unstable_mockModule('yaml', () => ({
-    default: mockYaml,
-    ...mockYaml,
-}));
-const { loadConfig, getConfigPaths, formatConfig } = await import('./config.js');
-describe('config', () => {
-    const originalEnv = process.env;
-    beforeEach(() => {
-        jest.clearAllMocks();
-        process.env = { ...originalEnv };
-    });
-    afterEach(() => {
-        process.env = originalEnv;
-    });
-    it('returns default config when no files exist', () => {
-        mockFs.existsSync.mockReturnValue(false);
-        const config = loadConfig();
-        expect(config).toEqual({
-            chat: {
-                streaming: true,
-                outputFormat: 'text',
-            },
-        });
-    });
-    it('loads and merges configs in order: defaults, user, project', () => {
-        mockFs.existsSync.mockReturnValue(true);
-        mockFs.readFileSync
-            .mockReturnValueOnce('user yaml')
-            .mockReturnValueOnce('project yaml');
-        mockYaml.parse
-            .mockReturnValueOnce({
-            chat: {
-                streaming: false,
-                outputFormat: 'markdown',
-            },
-        })
-            .mockReturnValueOnce({
-            chat: {
-                streaming: true,
-            },
-        });
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        expect(config.chat?.outputFormat).toBe('markdown');
-    });
-    it('environment variables override all configs', () => {
-        mockFs.existsSync.mockReturnValue(false);
-        process.env.ARK_CHAT_STREAMING = '1';
-        process.env.ARK_CHAT_OUTPUT_FORMAT = 'MARKDOWN';
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        expect(config.chat?.outputFormat).toBe('markdown');
-    });
-    it('throws error for invalid YAML', () => {
-        const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
-        mockFs.existsSync.mockImplementation((path) => path === userConfigPath);
-        mockFs.readFileSync.mockReturnValue('invalid yaml');
-        mockYaml.parse.mockImplementation(() => {
-            throw new Error('YAML parse error');
-        });
-        expect(() => loadConfig()).toThrow(`Invalid YAML in ${userConfigPath}: YAML parse error`);
-    });
-    it('handles non-Error exceptions', () => {
-        const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
-        mockFs.existsSync.mockImplementation((path) => path === userConfigPath);
-        mockFs.readFileSync.mockReturnValue('invalid yaml');
-        mockYaml.parse.mockImplementation(() => {
-            throw 'string error';
-        });
-        expect(() => loadConfig()).toThrow(`Invalid YAML in ${userConfigPath}: Unknown error`);
-    });
-    it('getConfigPaths returns correct paths', () => {
-        const paths = getConfigPaths();
-        expect(paths.user).toBe(path.join(os.homedir(), '.arkrc.yaml'));
-        expect(paths.project).toBe(path.join(process.cwd(), '.arkrc.yaml'));
-    });
-    it('formatConfig uses yaml.stringify', () => {
-        const config = { chat: { streaming: true, outputFormat: 'text' } };
-        mockYaml.stringify.mockReturnValue('formatted');
-        const result = formatConfig(config);
-        expect(mockYaml.stringify).toHaveBeenCalledWith(config);
-        expect(result).toBe('formatted');
-    });
-});

package/dist/lib/config.test.d.ts

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

package/dist/lib/config.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import { loadConfig } from './config.js';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-describe('Config', () => {
-    const originalEnv = process.env;
-    const testProjectConfig = path.join(process.cwd(), '.arkrc.yaml');
-    const testUserConfig = path.join(os.homedir(), '.arkrc.yaml');
-    beforeEach(() => {
-        // Reset environment
-        process.env = { ...originalEnv };
-        // Clean up any existing test configs
-        if (fs.existsSync(testProjectConfig)) {
-            fs.unlinkSync(testProjectConfig);
-        }
-        if (fs.existsSync(testUserConfig)) {
-            fs.unlinkSync(testUserConfig);
-        }
-    });
-    afterEach(() => {
-        // Restore environment
-        process.env = originalEnv;
-        // Clean up test configs
-        if (fs.existsSync(testProjectConfig)) {
-            fs.unlinkSync(testProjectConfig);
-        }
-        if (fs.existsSync(testUserConfig)) {
-            fs.unlinkSync(testUserConfig);
-        }
-    });
-    it('should load default config when no files or env vars exist', () => {
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        expect(config.chat?.outputFormat).toBe('text');
-    });
-    it('should override defaults with environment variables', () => {
-        process.env.ARK_CHAT_STREAMING = '0';
-        process.env.ARK_CHAT_OUTPUT_FORMAT = 'markdown';
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(false);
-        expect(config.chat?.outputFormat).toBe('markdown');
-    });
-    it('should accept "1" and "true" for streaming', () => {
-        process.env.ARK_CHAT_STREAMING = '1';
-        let config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        process.env.ARK_CHAT_STREAMING = 'true';
-        config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-    });
-    it('should load project config file', () => {
-        const configContent = `
-chat:
-  streaming: false
-  outputFormat: markdown
-`;
-        fs.writeFileSync(testProjectConfig, configContent);
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(false);
-        expect(config.chat?.outputFormat).toBe('markdown');
-    });
-    it('should prioritize env vars over config files', () => {
-        const configContent = `
-chat:
-  streaming: false
-  outputFormat: markdown
-`;
-        fs.writeFileSync(testProjectConfig, configContent);
-        process.env.ARK_CHAT_STREAMING = '1';
-        process.env.ARK_CHAT_OUTPUT_FORMAT = 'text';
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        expect(config.chat?.outputFormat).toBe('text');
-    });
-    it('should handle invalid config files gracefully', () => {
-        fs.writeFileSync(testProjectConfig, 'invalid: yaml: content: {{{');
-        // Should fall back to defaults without throwing
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(true);
-        expect(config.chat?.outputFormat).toBe('text');
-    });
-    it('should handle partial configs', () => {
-        const configContent = `
-chat:
-  streaming: false
-`;
-        fs.writeFileSync(testProjectConfig, configContent);
-        const config = loadConfig();
-        expect(config.chat?.streaming).toBe(false);
-        expect(config.chat?.outputFormat).toBe('text'); // Should use default
-    });
-});

package/dist/lib/consts.spec.d.ts

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

package/dist/lib/consts.spec.js

@@ -1,15 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { DEFAULT_ADDRESS_ARK_API, DEFAULT_TIMEOUT_MS, DEFAULT_CONNECTION_TEST_TIMEOUT_MS, CONFIG_DIR_NAME, CONFIG_FILE_NAME, DEFAULT_ARK_DASHBOARD_URL, DEFAULT_ARK_A2A_URL, DEFAULT_ARK_MEMORY_URL, DEFAULT_ARK_OTEL_URL, } from './consts.js';
-describe('Constants', () => {
-    it('defines correct default values', () => {
-        expect(DEFAULT_ADDRESS_ARK_API).toBe('http://localhost:8000');
-        expect(DEFAULT_TIMEOUT_MS).toBe(30000);
-        expect(DEFAULT_CONNECTION_TEST_TIMEOUT_MS).toBe(5000);
-        expect(CONFIG_DIR_NAME).toBe('ark');
-        expect(CONFIG_FILE_NAME).toBe('ark-cli.json');
-        expect(DEFAULT_ARK_DASHBOARD_URL).toBe('http://localhost:3000');
-        expect(DEFAULT_ARK_A2A_URL).toBe('http://localhost:8080');
-        expect(DEFAULT_ARK_MEMORY_URL).toBe('http://localhost:8081');
-        expect(DEFAULT_ARK_OTEL_URL).toBe('http://localhost:4318');
-    });
-});

package/dist/lib/dev/tools/analyzer.d.ts

@@ -1,30 +0,0 @@
-import { ArkDevToolStatus, DiscoveryResult, ProjectDiscoveryResult } from './types.js';
-export declare class ArkDevToolAnalyzer {
-    private discoverToolsScript;
-    constructor();
-    /**
-     * Analyze a tool directory and return its status
-     */
-    analyzeToolDirectory(toolPath: string): Promise<ArkDevToolStatus>;
-    /**
-     * Get project information by checking for Python project files
-     */
-    private getProjectInfo;
-    /**
-     * Discover project configuration
-     */
-    discoverProject(targetPath: string): Promise<ProjectDiscoveryResult | undefined>;
-    /**
-     * Discover tools using the Python script
-     */
-    discoverTools(targetPath: string): Promise<DiscoveryResult | undefined>;
-    /**
-     * Recursively find all MCP tools in a project
-     * This is a naive implementation that searches all Python files in the project tree
-     */
-    findProjectTools(projectRoot: string): Promise<any>;
-    /**
-     * Extract all tools from discovery result
-     */
-    private extractTools;
-}

package/dist/lib/dev/tools/analyzer.js

@@ -1,190 +0,0 @@
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export class ArkDevToolAnalyzer {
-    constructor() {
-        // The Python script is always adjacent to this file
-        // In dev: src/lib/dev/tools/discover_tools.py
-        // In prod: dist/lib/dev/tools/discover_tools.py (copied by postbuild)
-        this.discoverToolsScript = path.join(__dirname, 'discover_tools.py');
-    }
-    /**
-     * Analyze a tool directory and return its status
-     */
-    async analyzeToolDirectory(toolPath) {
-        const absolutePath = path.resolve(toolPath);
-        // Check if path exists
-        if (!fs.existsSync(absolutePath)) {
-            throw new Error(`Path not found: ${absolutePath}`);
-        }
-        // Get project info
-        const projectInfo = this.getProjectInfo(absolutePath);
-        // Discover tools using Python script
-        const discovery = await this.discoverTools(absolutePath);
-        // Extract all tools from discovery
-        const tools = this.extractTools(discovery);
-        return {
-            ...projectInfo,
-            discovery,
-            tools,
-        };
-    }
-    /**
-     * Get project information by checking for Python project files
-     */
-    getProjectInfo(dirPath) {
-        const info = {
-            path: dirPath,
-            platform: 'python3',
-            projectType: 'unknown',
-            hasVenv: false,
-            fastMCP: false,
-        };
-        // Check for virtual environment
-        info.hasVenv =
-            fs.existsSync(path.join(dirPath, '.venv')) ||
-                fs.existsSync(path.join(dirPath, 'venv'));
-        // Check Python project type and FastMCP presence
-        const pyprojectPath = path.join(dirPath, 'pyproject.toml');
-        const requirementsPath = path.join(dirPath, 'requirements.txt');
-        if (fs.existsSync(pyprojectPath)) {
-            info.projectType = 'pyproject';
-            const content = fs.readFileSync(pyprojectPath, 'utf-8');
-            if (content.includes('fastmcp')) {
-                info.fastMCP = true;
-                // Try to extract version
-                const versionMatch = content.match(/fastmcp[>=<~]*([0-9.]+)/);
-                if (versionMatch) {
-                    info.fastMCPVersion = versionMatch[1];
-                }
-            }
-        }
-        else if (fs.existsSync(requirementsPath)) {
-            info.projectType = 'requirements';
-            const content = fs.readFileSync(requirementsPath, 'utf-8');
-            if (content.includes('fastmcp')) {
-                info.fastMCP = true;
-                const versionMatch = content.match(/fastmcp[>=<~]*([0-9.]+)/);
-                if (versionMatch) {
-                    info.fastMCPVersion = versionMatch[1];
-                }
-            }
-        }
-        return info;
-    }
-    /**
-     * Discover project configuration
-     */
-    async discoverProject(targetPath) {
-        try {
-            // Check if Python is available
-            try {
-                execSync('python3 --version', { stdio: 'ignore' });
-            }
-            catch {
-                console.warn('Python 3 not found');
-                return undefined;
-            }
-            // Check if discover_tools.py exists
-            if (!fs.existsSync(this.discoverToolsScript)) {
-                console.warn(`discover_tools.py not found at ${this.discoverToolsScript}`);
-                return undefined;
-            }
-            // Run the discovery script with 'project' command
-            const result = execSync(`python3 "${this.discoverToolsScript}" project "${targetPath}"`, {
-                encoding: 'utf-8',
-                maxBuffer: 1024 * 1024, // 1MB buffer
-            });
-            return JSON.parse(result);
-        }
-        catch (error) {
-            console.error('Project discovery failed:', error);
-            return undefined;
-        }
-    }
-    /**
-     * Discover tools using the Python script
-     */
-    async discoverTools(targetPath) {
-        try {
-            // Check if Python is available
-            try {
-                execSync('python3 --version', { stdio: 'ignore' });
-            }
-            catch {
-                console.warn('Python 3 not found, skipping tool discovery');
-                return undefined;
-            }
-            // Check if discover_tools.py exists
-            if (!fs.existsSync(this.discoverToolsScript)) {
-                console.warn(`discover_tools.py not found at ${this.discoverToolsScript}`);
-                return undefined;
-            }
-            // Run the discovery script with 'tools' command
-            const result = execSync(`python3 "${this.discoverToolsScript}" tools "${targetPath}"`, {
-                encoding: 'utf-8',
-                maxBuffer: 1024 * 1024 * 10, // 10MB buffer
-            });
-            return JSON.parse(result);
-        }
-        catch (error) {
-            console.error('Tool discovery failed:', error);
-            return undefined;
-        }
-    }
-    /**
-     * Recursively find all MCP tools in a project
-     * This is a naive implementation that searches all Python files in the project tree
-     */
-    async findProjectTools(projectRoot) {
-        try {
-            // Check if Python is available
-            try {
-                execSync('python3 --version', { stdio: 'ignore' });
-            }
-            catch {
-                console.warn('Python 3 not found');
-                return null;
-            }
-            // Check if discover_tools.py exists
-            if (!fs.existsSync(this.discoverToolsScript)) {
-                console.warn(`discover_tools.py not found at ${this.discoverToolsScript}`);
-                return null;
-            }
-            // Run the discovery script with 'project-tools' command
-            const result = execSync(`python3 "${this.discoverToolsScript}" project-tools "${projectRoot}"`, {
-                encoding: 'utf-8',
-                maxBuffer: 1024 * 1024 * 10, // 10MB buffer
-            });
-            return JSON.parse(result);
-        }
-        catch (error) {
-            console.error('Project tools discovery failed:', error);
-            return null;
-        }
-    }
-    /**
-     * Extract all tools from discovery result
-     */
-    extractTools(discovery) {
-        if (!discovery)
-            return [];
-        // Check if it's a directory result
-        if ('files' in discovery) {
-            const dirResult = discovery;
-            const tools = [];
-            for (const file of dirResult.files) {
-                if (file.success && file.tools) {
-                    tools.push(...file.tools);
-                }
-            }
-            return tools;
-        }
-        // Single file result
-        const fileResult = discovery;
-        return fileResult.success ? fileResult.tools : [];
-    }
-}