@sethdouglasford/claude-flow/dist/config/config-manager.d.ts

Claude Code Flow - Advanced AI-powered development workflows with SPARC methodology

/**
 * Node.js-compatible Configuration management for Claude-Flow
 */
export interface Config {
    orchestrator: {
        maxConcurrentAgents: number;
        taskQueueSize: number;
        healthCheckInterval: number;
        shutdownTimeout: number;
    };
    terminal: {
        type: "auto" | "vscode" | "native";
        poolSize: number;
        recycleAfter: number;
        healthCheckInterval: number;
        commandTimeout: number;
    };
    memory: {
        backend: "sqlite" | "markdown" | "hybrid";
        cacheSizeMB: number;
        syncInterval: number;
        conflictResolution: "crdt" | "timestamp" | "manual";
        retentionDays: number;
    };
    coordination: {
        maxRetries: number;
        retryDelay: number;
        deadlockDetection: boolean;
        resourceTimeout: number;
        messageTimeout: number;
    };
    mcp: {
        transport: "stdio" | "http" | "websocket";
        port: number;
        tlsEnabled: boolean;
    };
    logging: {
        level: "debug" | "info" | "warn" | "error";
        format: "json" | "text";
        destination: "console" | "file";
    };
}
/**
 * Configuration validation error
 */
export declare class ConfigError extends Error {
    constructor(message: string);
}
/**
 * Configuration manager for Node.js
 */
export declare class ConfigManager {
    private static instance;
    private config;
    private configPath?;
    private userConfigDir;
    private constructor();
    /**
     * Gets the singleton instance
     */
    static getInstance(): ConfigManager;
    /**
     * Initialize configuration from file or create default
     */
    init(configPath?: string): Promise<void>;
    /**
     * Creates a default configuration file
     */
    createDefaultConfig(configPath: string): Promise<void>;
    /**
     * Loads configuration from file
     */
    load(configPath?: string): Promise<Config>;
    /**
     * Shows current configuration
     */
    show(): Config;
    /**
     * Gets a configuration value by path
     */
    get(path: string): any;
    /**
     * Sets a configuration value by path
     */
    set(path: string, value: any): void;
    /**
     * Saves current configuration to file
     */
    save(configPath?: string): Promise<void>;
    /**
     * Validates the configuration
     */
    validate(config: Config): void;
    /**
     * Loads configuration from environment variables
     */
    private loadFromEnv;
    /**
     * Deep clone helper
     */
    private deepClone;
    /**
     * Deep merge helper
     */
    private deepMerge;
    /**
     * Gets available configuration templates
     */
    getAvailableTemplates(): string[];
    /**
     * Creates a configuration from a template
     */
    createTemplate(templateName: string): Config;
    /**
     * Gets format parsers for different config file formats
     */
    getFormatParsers(): Record<string, {
        stringify: (obj: any) => string;
        parse: (str: string) => any;
    }>;
    /**
     * Validates a configuration file
     */
    validateFile(configPath: string): Promise<{
        valid: boolean;
        errors: string[];
    }>;
    /**
     * Backs up the current configuration
     */
    backup(backupPath?: string): Promise<string>;
    /**
     * Restores configuration from a backup
     */
    restore(backupPath: string): Promise<void>;
    /**
     * Gets configuration path history
     */
    getPathHistory(): string[];
    /**
     * Gets configuration change history
     */
    getChangeHistory(): Array<{
        timestamp: Date;
        path: string;
        oldValue: any;
        newValue: any;
    }>;
    /**
     * Simple YAML converter (basic implementation)
     */
    private toYAML;
}
export declare const configManager: ConfigManager;
//# sourceMappingURL=config-manager.d.ts.map