@agents-at-scale/ark 0.1.33 → 0.1.35-rc.1

package/dist/lib/config.js

@@ -1,223 +1,86 @@
-/**
- * Configuration management for ARK CLI
- */
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { SecurityUtils } from './security.js';
-import { ValidationError } from './errors.js';
-export const DEFAULT_CONFIG = {
-    defaultProjectType: 'with-samples',
-    defaultDestination: process.cwd(),
-    skipGitByDefault: false,
-    skipModelsbyDefault: false,
-    preferredEditor: process.env.EDITOR || 'code',
-    colorOutput: true,
-    verboseOutput: false,
-    defaultModelProvider: 'azure',
-    customTemplates: {},
-    parallelOperations: true,
-    maxConcurrentFiles: 10,
-    fileWatchingEnabled: false,
-    telemetryEnabled: false,
-    errorReporting: false,
-};
-export class ConfigManager {
-    constructor() {
-        this.configPath = this.getConfigPath();
-        this.config = this.loadConfig();
-    }
-    /**
-     * Get the path to the configuration file
-     */
-    getConfigPath() {
-        const configDir = process.env.ARK_CONFIG_DIR || path.join(os.homedir(), '.config', 'ark');
-        // Ensure config directory exists
-        if (!fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true, mode: 0o755 });
-        }
-        return path.join(configDir, 'config.json');
-    }
-    /**
-     * Load configuration from file or create with defaults
-     */
-    loadConfig() {
+import yaml from 'yaml';
+/**
+ * Load configuration from multiple sources with proper precedence:
+ * 1. Defaults
+ * 2. ~/.arkrc.yaml (user config)
+ * 3. .arkrc.yaml (project config)
+ * 4. Environment variables (override all)
+ */
+export function loadConfig() {
+    // Start with defaults
+    const config = {
+        chat: {
+            streaming: true,
+            outputFormat: 'text',
+        },
+    };
+    // Load user config from home directory
+    const userConfigPath = path.join(os.homedir(), '.arkrc.yaml');
+    if (fs.existsSync(userConfigPath)) {
         try {
-            if (fs.existsSync(this.configPath)) {
-                const configContent = fs.readFileSync(this.configPath, 'utf-8');
-                const userConfig = JSON.parse(configContent);
-                // Merge with defaults to ensure all properties exist
-                return { ...DEFAULT_CONFIG, ...userConfig };
-            }
+            const userConfig = yaml.parse(fs.readFileSync(userConfigPath, 'utf-8'));
+            mergeConfig(config, userConfig);
         }
-        catch (error) {
-            console.warn(`Warning: Failed to load config from ${this.configPath}: ${error}`);
+        catch (_e) {
+            // Silently ignore invalid config files
         }
-        // Return defaults and save them
-        this.saveConfig(DEFAULT_CONFIG);
-        return { ...DEFAULT_CONFIG };
     }
-    /**
-     * Save configuration to file
-     */
-    saveConfig(config) {
+    // Load project config from current directory
+    const projectConfigPath = path.join(process.cwd(), '.arkrc.yaml');
+    if (fs.existsSync(projectConfigPath)) {
         try {
-            const configContent = JSON.stringify(config, null, 2);
-            SecurityUtils.validatePath(this.configPath, 'config file');
-            fs.writeFileSync(this.configPath, configContent, {
-                mode: 0o600, // Owner read/write only
-                flag: 'w',
-            });
+            const projectConfig = yaml.parse(fs.readFileSync(projectConfigPath, 'utf-8'));
+            mergeConfig(config, projectConfig);
         }
-        catch (error) {
-            throw new ValidationError(`Failed to save configuration: ${error}`, 'config', [
-                'Check file permissions',
-                'Ensure config directory exists',
-                'Verify disk space',
-            ]);
+        catch (_e) {
+            // Silently ignore invalid config files
         }
     }
-    /**
-     * Get the current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-        this.saveConfig(this.config);
-    }
-    /**
-     * Reset configuration to defaults
-     */
-    resetConfig() {
-        this.config = { ...DEFAULT_CONFIG };
-        this.saveConfig(this.config);
+    // Apply environment variable overrides
+    if (process.env.ARK_CHAT_STREAMING !== undefined) {
+        config.chat = config.chat || {};
+        config.chat.streaming =
+            process.env.ARK_CHAT_STREAMING === '1' ||
+                process.env.ARK_CHAT_STREAMING === 'true';
     }
-    /**
-     * Get a specific configuration value
-     */
-    get(key) {
-        return this.config[key];
-    }
-    /**
-     * Set a specific configuration value
-     */
-    set(key, value) {
-        this.config[key] = value;
-        this.saveConfig(this.config);
-    }
-    /**
-     * Validate configuration values
-     */
-    validateConfig() {
-        const config = this.config;
-        // Validate project type
-        if (!['empty', 'with-samples'].includes(config.defaultProjectType)) {
-            throw new ValidationError(`Invalid defaultProjectType: ${config.defaultProjectType}`, 'defaultProjectType', ['Must be "empty" or "with-samples"']);
-        }
-        // Validate model provider
-        const validProviders = ['azure', 'openai', 'claude', 'gemini', 'custom'];
-        if (!validProviders.includes(config.defaultModelProvider)) {
-            throw new ValidationError(`Invalid defaultModelProvider: ${config.defaultModelProvider}`, 'defaultModelProvider', [`Must be one of: ${validProviders.join(', ')}`]);
-        }
-        // Validate numeric values
-        if (config.maxConcurrentFiles < 1 || config.maxConcurrentFiles > 100) {
-            throw new ValidationError(`Invalid maxConcurrentFiles: ${config.maxConcurrentFiles}`, 'maxConcurrentFiles', ['Must be between 1 and 100']);
-        }
-        // Validate paths
-        if (config.defaultDestination) {
-            SecurityUtils.validatePath(config.defaultDestination, 'default destination');
-        }
-        if (config.templateDirectory) {
-            SecurityUtils.validatePath(config.templateDirectory, 'template directory');
-        }
-    }
-    /**
-     * Get environment variable overrides
-     */
-    getEnvironmentOverrides() {
-        const overrides = {};
-        // Check for environment variable overrides
-        if (process.env.ARK_DEFAULT_PROJECT_TYPE) {
-            const projectType = process.env.ARK_DEFAULT_PROJECT_TYPE;
-            if (['empty', 'with-samples'].includes(projectType)) {
-                overrides.defaultProjectType = projectType;
-            }
-        }
-        if (process.env.ARK_DEFAULT_DESTINATION) {
-            overrides.defaultDestination = process.env.ARK_DEFAULT_DESTINATION;
+    if (process.env.ARK_CHAT_OUTPUT_FORMAT !== undefined) {
+        config.chat = config.chat || {};
+        const format = process.env.ARK_CHAT_OUTPUT_FORMAT.toLowerCase();
+        if (format === 'markdown' || format === 'text') {
+            config.chat.outputFormat = format;
         }
-        if (process.env.ARK_SKIP_GIT) {
-            overrides.skipGitByDefault = process.env.ARK_SKIP_GIT === 'true';
-        }
-        if (process.env.ARK_SKIP_MODELS) {
-            overrides.skipModelsbyDefault = process.env.ARK_SKIP_MODELS === 'true';
-        }
-        if (process.env.ARK_COLOR_OUTPUT) {
-            overrides.colorOutput = process.env.ARK_COLOR_OUTPUT !== 'false';
-        }
-        if (process.env.ARK_VERBOSE) {
-            overrides.verboseOutput = process.env.ARK_VERBOSE === 'true';
-        }
-        if (process.env.ARK_DEFAULT_MODEL_PROVIDER) {
-            const provider = process.env.ARK_DEFAULT_MODEL_PROVIDER;
-            const validProviders = [
-                'azure',
-                'openai',
-                'claude',
-                'gemini',
-                'custom',
-            ];
-            if (validProviders.includes(provider)) {
-                overrides.defaultModelProvider =
-                    provider;
-            }
-        }
-        return overrides;
     }
-    /**
-     * Get merged configuration with environment overrides
-     */
-    getMergedConfig() {
-        const envOverrides = this.getEnvironmentOverrides();
-        return { ...this.config, ...envOverrides };
-    }
-    /**
-     * Export configuration for backup
-     */
-    exportConfig() {
-        return JSON.stringify(this.config, null, 2);
-    }
-    /**
-     * Import configuration from backup
-     */
-    importConfig(configJson) {
-        try {
-            const importedConfig = JSON.parse(configJson);
-            // Validate the imported config
-            const tempManager = new ConfigManager();
-            tempManager.config = { ...DEFAULT_CONFIG, ...importedConfig };
-            tempManager.validateConfig();
-            // If validation passes, update our config
-            this.config = tempManager.config;
-            this.saveConfig(this.config);
+    return config;
+}
+/**
+ * Merge source config into target config (mutates target)
+ */
+function mergeConfig(target, source) {
+    if (source.chat) {
+        target.chat = target.chat || {};
+        if (source.chat.streaming !== undefined) {
+            target.chat.streaming = source.chat.streaming;
         }
-        catch (error) {
-            throw new ValidationError(`Failed to import configuration: ${error}`, 'config', [
-                'Check JSON syntax',
-                'Ensure all required fields are present',
-                'Verify configuration values are valid',
-            ]);
+        if (source.chat.outputFormat !== undefined) {
+            target.chat.outputFormat = source.chat.outputFormat;
         }
     }
-    /**
-     * Get configuration file path for CLI display
-     */
-    getConfigFilePath() {
-        return this.configPath;
-    }
+}
+/**
+ * Get the paths checked for config files
+ */
+export function getConfigPaths() {
+    return {
+        user: path.join(os.homedir(), '.arkrc.yaml'),
+        project: path.join(process.cwd(), '.arkrc.yaml'),
+    };
+}
+/**
+ * Format config as YAML for display
+ */
+export function formatConfig(config) {
+    return yaml.stringify(config);
 }

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

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

package/dist/lib/config.test.js

@@ -0,0 +1,93 @@
+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/dev/tools/analyzer.d.ts

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

@@ -0,0 +1,190 @@
+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 : [];
+    }
+}