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

package/dist/lib/config.js

@@ -1,88 +1,223 @@
+/**
+ * Configuration management for ARK CLI
+ */
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-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)) {
+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() {
         try {
-            const userConfig = yaml.parse(fs.readFileSync(userConfigPath, 'utf-8'));
-            mergeConfig(config, userConfig);
+            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 };
+            }
         }
-        catch (e) {
-            const message = e instanceof Error ? e.message : 'Unknown error';
-            throw new Error(`Invalid YAML in ${userConfigPath}: ${message}`);
+        catch (error) {
+            console.warn(`Warning: Failed to load config from ${this.configPath}: ${error}`);
         }
+        // Return defaults and save them
+        this.saveConfig(DEFAULT_CONFIG);
+        return { ...DEFAULT_CONFIG };
     }
-    // Load project config from current directory
-    const projectConfigPath = path.join(process.cwd(), '.arkrc.yaml');
-    if (fs.existsSync(projectConfigPath)) {
+    /**
+     * Save configuration to file
+     */
+    saveConfig(config) {
         try {
-            const projectConfig = yaml.parse(fs.readFileSync(projectConfigPath, 'utf-8'));
-            mergeConfig(config, projectConfig);
+            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',
+            });
         }
-        catch (e) {
-            const message = e instanceof Error ? e.message : 'Unknown error';
-            throw new Error(`Invalid YAML in ${projectConfigPath}: ${message}`);
+        catch (error) {
+            throw new ValidationError(`Failed to save configuration: ${error}`, 'config', [
+                'Check file permissions',
+                'Ensure config directory exists',
+                'Verify disk space',
+            ]);
         }
     }
-    // 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 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);
     }
-    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;
+    /**
+     * 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');
         }
     }
-    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;
+    /**
+     * 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 (source.chat.outputFormat !== undefined) {
-            target.chat.outputFormat = source.chat.outputFormat;
+        if (process.env.ARK_DEFAULT_DESTINATION) {
+            overrides.defaultDestination = process.env.ARK_DEFAULT_DESTINATION;
         }
+        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);
+        }
+        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',
+            ]);
+        }
+    }
+    /**
+     * 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/consts.d.ts

@@ -7,3 +7,4 @@ 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,3 +11,5 @@ 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/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/exec.d.ts

@@ -1 +1,5 @@
+export declare function executeCommand(command: string, args?: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
 export declare function fileExists(path: string): boolean;

package/dist/lib/exec.js

@@ -1,4 +1,15 @@
 import fs from 'fs';
+import { execa } from 'execa';
+export async function executeCommand(command, args = []) {
+    try {
+        const result = await execa(command, args);
+        return { stdout: result.stdout, stderr: result.stderr };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Command failed: ${command} ${args.join(' ')}\n${errorMessage}`);
+    }
+}
 export function fileExists(path) {
     try {
         return fs.existsSync(path);

package/dist/lib/types.d.ts

@@ -13,18 +13,13 @@ export interface KubernetesConfig {
     namespace?: string;
     inCluster: boolean;
 }
-export type DeploymentStatus = 'available' | 'progressing' | 'replicafailure' | 'failed' | 'not found' | 'unknown';
-export type ServiceStatus = {
+export interface ServiceStatus {
     name: string;
-    status: 'healthy' | 'warning' | 'unhealthy' | 'not installed' | 'not ready';
-    deploymentStatus?: DeploymentStatus;
+    status: 'healthy' | 'unhealthy' | 'not installed';
     url?: string;
     version?: string;
-    revision?: string;
     details?: string;
-    isDev?: boolean;
-    namespace?: string;
-};
+}
 export interface DependencyStatus {
     name: string;
     installed: boolean;
@@ -34,8 +29,6 @@ export interface DependencyStatus {
 export interface StatusData {
     services: ServiceStatus[];
     dependencies: DependencyStatus[];
-    arkReady?: boolean;
-    defaultModelExists?: boolean;
 }
 export interface CommandVersionConfig {
     command: string;

package/dist/ui/MainMenu.d.ts

@@ -1,7 +1,3 @@
 import * as React from 'react';
-import type { ArkConfig } from '../lib/config.js';
-interface MainMenuProps {
-    config: ArkConfig;
-}
-declare const MainMenu: React.FC<MainMenuProps>;
+declare const MainMenu: React.FC;
 export default MainMenu;