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

package/dist/lib/config.d.ts

@@ -1,82 +1,28 @@
-/**
- * Configuration management for ARK CLI
- */
-export interface ArkConfig {
-    defaultProjectType: 'empty' | 'with-samples';
-    defaultDestination: string;
-    skipGitByDefault: boolean;
-    skipModelsbyDefault: boolean;
-    preferredEditor: string;
-    colorOutput: boolean;
-    verboseOutput: boolean;
-    defaultModelProvider: 'azure' | 'openai' | 'claude' | 'gemini' | 'custom';
-    templateDirectory?: string;
-    customTemplates: Record<string, string>;
-    parallelOperations: boolean;
-    maxConcurrentFiles: number;
-    fileWatchingEnabled: boolean;
-    telemetryEnabled: boolean;
-    errorReporting: boolean;
+import type { ClusterInfo } from './cluster.js';
+export interface ChatConfig {
+    streaming?: boolean;
+    outputFormat?: 'text' | 'markdown';
 }
-export declare const DEFAULT_CONFIG: ArkConfig;
-export declare class ConfigManager {
-    private configPath;
-    private config;
-    constructor();
-    /**
-     * Get the path to the configuration file
-     */
-    private getConfigPath;
-    /**
-     * Load configuration from file or create with defaults
-     */
-    private loadConfig;
-    /**
-     * Save configuration to file
-     */
-    private saveConfig;
-    /**
-     * Get the current configuration
-     */
-    getConfig(): ArkConfig;
-    /**
-     * Update configuration
-     */
-    updateConfig(updates: Partial<ArkConfig>): void;
-    /**
-     * Reset configuration to defaults
-     */
-    resetConfig(): void;
-    /**
-     * Get a specific configuration value
-     */
-    get<K extends keyof ArkConfig>(key: K): ArkConfig[K];
-    /**
-     * Set a specific configuration value
-     */
-    set<K extends keyof ArkConfig>(key: K, value: ArkConfig[K]): void;
-    /**
-     * Validate configuration values
-     */
-    validateConfig(): void;
-    /**
-     * Get environment variable overrides
-     */
-    getEnvironmentOverrides(): Partial<ArkConfig>;
-    /**
-     * Get merged configuration with environment overrides
-     */
-    getMergedConfig(): ArkConfig;
-    /**
-     * Export configuration for backup
-     */
-    exportConfig(): string;
-    /**
-     * Import configuration from backup
-     */
-    importConfig(configJson: string): void;
-    /**
-     * Get configuration file path for CLI display
-     */
-    getConfigFilePath(): string;
+export interface ArkConfig {
+    chat?: ChatConfig;
+    clusterInfo?: ClusterInfo;
 }
+/**
+ * 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 declare function loadConfig(): ArkConfig;
+/**
+ * Get the paths checked for config files
+ */
+export declare function getConfigPaths(): {
+    user: string;
+    project: string;
+};
+/**
+ * Format config as YAML for display
+ */
+export declare function formatConfig(config: ArkConfig): string;

package/dist/lib/config.js

@@ -1,223 +1,88 @@
-/**
- * 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) {
+            const message = e instanceof Error ? e.message : 'Unknown error';
+            throw new Error(`Invalid YAML in ${userConfigPath}: ${message}`);
         }
-        // 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) {
+            const message = e instanceof Error ? e.message : 'Unknown error';
+            throw new Error(`Invalid YAML in ${projectConfigPath}: ${message}`);
         }
     }
-    /**
-     * 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.spec.d.ts

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

package/dist/lib/config.spec.js

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

@@ -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/consts.d.ts

@@ -7,4 +7,3 @@ export declare const DEFAULT_ARK_DASHBOARD_URL = "http://localhost:3000";
 export declare const DEFAULT_ARK_A2A_URL = "http://localhost:8080";
 export declare const DEFAULT_ARK_MEMORY_URL = "http://localhost:8081";
 export declare const DEFAULT_ARK_OTEL_URL = "http://localhost:4318";
-export declare const ARK_REPO_ERROR_MESSAGE = "Error: This command must be run inside the ARK repository.";

package/dist/lib/consts.js

@@ -11,5 +11,3 @@ export const DEFAULT_ARK_DASHBOARD_URL = 'http://localhost:3000';
 export const DEFAULT_ARK_A2A_URL = 'http://localhost:8080';
 export const DEFAULT_ARK_MEMORY_URL = 'http://localhost:8081';
 export const DEFAULT_ARK_OTEL_URL = 'http://localhost:4318';
-// Error message for different ARK repo
-export const ARK_REPO_ERROR_MESSAGE = 'Error: This command must be run inside the ARK repository.';

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

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

package/dist/lib/consts.spec.js

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

@@ -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;
+}