@agents-at-scale/ark 0.1.35 → 0.1.36

package/dist/lib/commands.spec.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+// Mock chalk to avoid ANSI codes in tests
+jest.unstable_mockModule('chalk', () => ({
+    default: {
+        gray: (str) => str,
+    },
+}));
+// Mock execa using unstable_mockModule
+jest.unstable_mockModule('execa', () => ({
+    execa: jest.fn(),
+}));
+// Dynamic imports after mock
+const { execa } = await import('execa');
+const { checkCommandExists, execute } = await import('./commands.js');
+// Type the mock properly
+const mockExeca = execa;
+describe('commands', () => {
+    describe('checkCommandExists', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+        it('returns true when command executes successfully', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'v1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('helm', ['version']);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['version']);
+        });
+        it('returns false when command fails', async () => {
+            mockExeca.mockRejectedValue(new Error('Command not found'));
+            const result = await checkCommandExists('nonexistent', ['--version']);
+            expect(result).toBe(false);
+            expect(mockExeca).toHaveBeenCalledWith('nonexistent', ['--version']);
+        });
+        it('uses default --version arg when no args provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '1.0.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('node');
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('node', ['--version']);
+        });
+        it('uses custom args when provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'Client Version: v1.28.0',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('kubectl', [
+                'version',
+                '--client',
+            ]);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', [
+                'version',
+                '--client',
+            ]);
+        });
+        it('handles empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const result = await checkCommandExists('echo', []);
+            expect(result).toBe(true);
+            expect(mockExeca).toHaveBeenCalledWith('echo', []);
+        });
+    });
+    describe('execute', () => {
+        let mockConsoleLog;
+        beforeEach(() => {
+            jest.clearAllMocks();
+            mockConsoleLog = jest.spyOn(console, 'log').mockImplementation(() => { });
+        });
+        afterEach(() => {
+            mockConsoleLog.mockRestore();
+        });
+        it('executes command without verbose output by default', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' });
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('prints command when verbose is true', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'success',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('helm', ['install', 'test'], { stdio: 'inherit' }, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ helm install test');
+            expect(mockExeca).toHaveBeenCalledWith('helm', ['install', 'test'], {
+                stdio: 'inherit',
+            });
+        });
+        it('works with empty args array', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('ls', [], {}, { verbose: true });
+            expect(mockConsoleLog).toHaveBeenCalledWith('$ ls ');
+            expect(mockExeca).toHaveBeenCalledWith('ls', [], {});
+        });
+        it('passes through execa options correctly', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+            });
+            const execaOpts = { stdio: 'pipe', timeout: 5000, cwd: '/tmp' };
+            await execute('kubectl', ['get', 'pods'], execaOpts);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('kubectl', ['get', 'pods'], execaOpts);
+        });
+        it('handles command failure', async () => {
+            const error = new Error('Command failed');
+            mockExeca.mockRejectedValue(error);
+            await expect(execute('fail', ['now'])).rejects.toThrow('Command failed');
+            expect(mockExeca).toHaveBeenCalledWith('fail', ['now'], {});
+        });
+        it('defaults to no verbose when additionalOptions not provided', async () => {
+            mockExeca.mockResolvedValue({
+                stdout: 'ok',
+                stderr: '',
+                exitCode: 0,
+            });
+            await execute('echo', ['test']);
+            expect(mockConsoleLog).not.toHaveBeenCalled();
+            expect(mockExeca).toHaveBeenCalledWith('echo', ['test'], {});
+        });
+    });
+});

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/errors.js

@@ -162,9 +162,9 @@ export class InputValidator {
         if (!kebabRegex.test(trimmed)) {
             const suggestions = [];
             const normalized = trimmed
+                .replace(/([a-z])([A-Z])/g, '$1-$2') // Handle camelCase first
                 .toLowerCase()
                 .replace(/[\s_]+/g, '-')
-                .replace(/([a-z])([A-Z])/g, '$1-$2')
                 .replace(/-{2,}/g, '-') // Replace 2+ consecutive hyphens with single hyphen (ReDoS-safe)
                 .replace(/^-/, '') // Remove single leading hyphen (ReDoS-safe)
                 .replace(/-$/, ''); // Remove single trailing hyphen (ReDoS-safe)

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

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