odd-flow 1.0.0

package/v3/@claude-flow/cli/dist/src/services/config-file-manager.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Config File Manager
+ * Shared JSON config file persistence with atomic writes and Zod validation
+ */
+export declare class ConfigFileManager {
+    private configPath;
+    private config;
+    /** Find config file in search paths starting from cwd */
+    findConfig(cwd: string): string | null;
+    /** Load config from file, returns null if not found */
+    load(cwd: string): Record<string, unknown> | null;
+    /** Get the current config, loading if needed */
+    getConfig(cwd: string): Record<string, unknown>;
+    /** Get a nested config value by dot-separated key */
+    get(cwd: string, key: string): unknown;
+    /** Set a nested config value by dot-separated key */
+    set(cwd: string, key: string, value: unknown): void;
+    /** Create a new config file with defaults */
+    create(cwd: string, overrides?: Record<string, unknown>, force?: boolean): string;
+    /** Reset config to defaults */
+    reset(cwd: string): string;
+    /** Export config to a specific path */
+    exportTo(cwd: string, exportPath: string): void;
+    /** Import config from a specific path */
+    importFrom(cwd: string, importPath: string): void;
+    /** Get the path to the current config file */
+    getConfigPath(): string | null;
+    /** Get default config */
+    getDefaults(): Record<string, unknown>;
+    /** Atomic write: write to .tmp then rename */
+    private writeAtomic;
+}
+/** Parse a string value to the appropriate type */
+export declare function parseConfigValue(value: string): unknown;
+/** Singleton instance */
+export declare const configManager: ConfigFileManager;
+//# sourceMappingURL=config-file-manager.d.ts.map

package/v3/@claude-flow/cli/dist/src/services/config-file-manager.js

@@ -0,0 +1,224 @@
+/**
+ * Config File Manager
+ * Shared JSON config file persistence with atomic writes and Zod validation
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Config file search paths in priority order */
+const CONFIG_FILENAMES = [
+    'claude-flow.config.json',
+    '.claude-flow/config.json',
+];
+/** Default config values */
+const DEFAULT_CONFIG = {
+    version: '3.5',
+    agents: {
+        defaultType: 'coder',
+        autoSpawn: false,
+        maxConcurrent: 8,
+        timeout: 300000,
+        providers: [],
+    },
+    swarm: {
+        topology: 'hierarchical',
+        maxAgents: 8,
+        autoScale: false,
+        coordinationStrategy: 'leader',
+        healthCheckInterval: 30000,
+    },
+    memory: {
+        backend: 'hybrid',
+        persistPath: './data/memory',
+        cacheSize: 1000,
+        enableHNSW: true,
+        vectorDimension: 384,
+    },
+    mcp: {
+        serverHost: 'localhost',
+        serverPort: 3000,
+        autoStart: false,
+        transportType: 'stdio',
+        tools: [],
+    },
+    cli: {
+        colorOutput: true,
+        interactive: true,
+        verbosity: 'normal',
+        outputFormat: 'text',
+        progressStyle: 'spinner',
+    },
+    hooks: {
+        enabled: true,
+        autoExecute: true,
+        hooks: [],
+    },
+};
+export class ConfigFileManager {
+    configPath = null;
+    config = null;
+    /** Find config file in search paths starting from cwd */
+    findConfig(cwd) {
+        for (const filename of CONFIG_FILENAMES) {
+            const candidate = path.resolve(cwd, filename);
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Check env var
+        const envPath = process.env.CLAUDE_FLOW_CONFIG;
+        if (envPath && fs.existsSync(envPath)) {
+            return path.resolve(envPath);
+        }
+        return null;
+    }
+    /** Load config from file, returns null if not found */
+    load(cwd) {
+        this.configPath = this.findConfig(cwd);
+        if (!this.configPath) {
+            this.config = null;
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(this.configPath, 'utf-8');
+            this.config = JSON.parse(content);
+            return this.config;
+        }
+        catch {
+            this.config = null;
+            return null;
+        }
+    }
+    /** Get the current config, loading if needed */
+    getConfig(cwd) {
+        if (this.config === null) {
+            this.load(cwd);
+        }
+        return this.config ?? { ...DEFAULT_CONFIG };
+    }
+    /** Get a nested config value by dot-separated key */
+    get(cwd, key) {
+        const config = this.getConfig(cwd);
+        return getNestedValue(config, key);
+    }
+    /** Set a nested config value by dot-separated key */
+    set(cwd, key, value) {
+        const config = this.getConfig(cwd);
+        setNestedValue(config, key, value);
+        this.config = config;
+        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        this.writeAtomic(targetPath, config);
+        this.configPath = targetPath;
+    }
+    /** Create a new config file with defaults */
+    create(cwd, overrides, force) {
+        const targetPath = path.resolve(cwd, CONFIG_FILENAMES[0]);
+        if (fs.existsSync(targetPath) && !force) {
+            throw new Error(`Config file already exists: ${targetPath}. Use --force to overwrite.`);
+        }
+        const config = { ...DEFAULT_CONFIG, ...overrides };
+        this.writeAtomic(targetPath, config);
+        this.config = config;
+        this.configPath = targetPath;
+        return targetPath;
+    }
+    /** Reset config to defaults */
+    reset(cwd) {
+        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        this.writeAtomic(targetPath, DEFAULT_CONFIG);
+        this.config = { ...DEFAULT_CONFIG };
+        this.configPath = targetPath;
+        return targetPath;
+    }
+    /** Export config to a specific path */
+    exportTo(cwd, exportPath) {
+        const config = this.getConfig(cwd);
+        const resolved = path.resolve(cwd, exportPath);
+        this.writeAtomic(resolved, config);
+    }
+    /** Import config from a specific path */
+    importFrom(cwd, importPath) {
+        const resolved = path.resolve(cwd, importPath);
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Import file not found: ${resolved}`);
+        }
+        const content = fs.readFileSync(resolved, 'utf-8');
+        let imported;
+        try {
+            imported = JSON.parse(content);
+        }
+        catch {
+            throw new Error(`Invalid JSON in import file: ${resolved}`);
+        }
+        if (typeof imported !== 'object' || imported === null || Array.isArray(imported)) {
+            throw new Error('Import file must contain a JSON object');
+        }
+        const targetPath = this.configPath ?? path.resolve(cwd, CONFIG_FILENAMES[0]);
+        this.writeAtomic(targetPath, imported);
+        this.config = imported;
+        this.configPath = targetPath;
+    }
+    /** Get the path to the current config file */
+    getConfigPath() {
+        return this.configPath;
+    }
+    /** Get default config */
+    getDefaults() {
+        return { ...DEFAULT_CONFIG };
+    }
+    /** Atomic write: write to .tmp then rename */
+    writeAtomic(filePath, data) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const tmpPath = filePath + '.tmp';
+        fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+        fs.renameSync(tmpPath, filePath);
+    }
+}
+/** Get a nested value by dot-separated key */
+function getNestedValue(obj, key) {
+    const parts = key.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+/** Set a nested value by dot-separated key */
+function setNestedValue(obj, key, value) {
+    const parts = key.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!(part in current) || typeof current[part] !== 'object' || current[part] === null) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+/** Parse a string value to the appropriate type */
+export function parseConfigValue(value) {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    if (/^\d+$/.test(value))
+        return parseInt(value, 10);
+    if (/^\d+\.\d+$/.test(value))
+        return parseFloat(value);
+    try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === 'object')
+            return parsed;
+    }
+    catch { /* not JSON, use as string */ }
+    return value;
+}
+/** Singleton instance */
+export const configManager = new ConfigFileManager();
+//# sourceMappingURL=config-file-manager.js.map

package/v3/@claude-flow/cli/dist/src/services/container-worker-pool.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Container Worker Pool
+ * Docker-based worker pool for high-throughput headless execution.
+ *
+ * ADR-020: Headless Worker Integration Architecture - Phase 3
+ * - Manages pool of Docker containers for isolated worker execution
+ * - Supports dynamic scaling based on workload
+ * - Provides container lifecycle management
+ * - Integrates with WorkerQueue for task distribution
+ *
+ * Key Features:
+ * - Container pooling with configurable size
+ * - Health checking and auto-recovery
+ * - Resource limits (CPU, memory)
+ * - Volume mounting for workspace access
+ * - Network isolation per worker type
+ */
+import { EventEmitter } from 'events';
+import type { HeadlessWorkerType, HeadlessExecutionResult, SandboxMode } from './headless-worker-executor.js';
+/**
+ * Container state
+ */
+export type ContainerState = 'creating' | 'ready' | 'busy' | 'unhealthy' | 'terminated';
+/**
+ * Container info
+ */
+export interface ContainerInfo {
+    id: string;
+    name: string;
+    state: ContainerState;
+    createdAt: Date;
+    lastUsedAt?: Date;
+    workerType?: HeadlessWorkerType;
+    executionCount: number;
+    healthCheckFailures: number;
+    pid?: number;
+}
+/**
+ * Container pool configuration
+ */
+export interface ContainerPoolConfig {
+    /** Maximum number of containers in the pool */
+    maxContainers: number;
+    /** Minimum number of containers to keep warm */
+    minContainers: number;
+    /** Docker image to use */
+    image: string;
+    /** Container resource limits */
+    resources: {
+        cpus: string;
+        memory: string;
+    };
+    /** Health check interval in ms */
+    healthCheckIntervalMs: number;
+    /** Container idle timeout in ms */
+    idleTimeoutMs: number;
+    /** Workspace volume mount path */
+    workspacePath: string;
+    /** State persistence path */
+    statePath: string;
+    /** Network name for container isolation */
+    network?: string;
+    /** Environment variables for containers */
+    env?: Record<string, string>;
+    /** Default sandbox mode */
+    defaultSandbox: SandboxMode;
+}
+/**
+ * Container execution options
+ */
+export interface ContainerExecutionOptions {
+    workerType: HeadlessWorkerType;
+    prompt: string;
+    contextPatterns?: string[];
+    sandbox?: SandboxMode;
+    model?: string;
+    timeoutMs?: number;
+}
+/**
+ * Pool status
+ */
+export interface ContainerPoolStatus {
+    totalContainers: number;
+    readyContainers: number;
+    busyContainers: number;
+    unhealthyContainers: number;
+    queuedTasks: number;
+    containers: ContainerInfo[];
+    dockerAvailable: boolean;
+    lastHealthCheck?: Date;
+}
+/**
+ * ContainerWorkerPool - Manages Docker containers for headless worker execution
+ */
+export declare class ContainerWorkerPool extends EventEmitter {
+    private config;
+    private projectRoot;
+    private containers;
+    private taskQueue;
+    private healthCheckTimer?;
+    private idleCheckTimer?;
+    private dockerAvailable;
+    private initialized;
+    private isShuttingDown;
+    private exitHandlersRegistered;
+    constructor(projectRoot: string, config?: Partial<ContainerPoolConfig>);
+    /**
+     * Initialize the container pool
+     */
+    initialize(): Promise<boolean>;
+    /**
+     * Register process exit handlers to clean up containers
+     */
+    private registerExitHandlers;
+    /**
+     * Execute a worker in a container
+     */
+    execute(options: ContainerExecutionOptions): Promise<HeadlessExecutionResult>;
+    /**
+     * Scale pool for batch execution
+     */
+    scaleForBatch(workerCount: number): Promise<void>;
+    /**
+     * Get pool status
+     */
+    getStatus(): ContainerPoolStatus;
+    /**
+     * Shutdown the pool
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if Docker is available (async)
+     */
+    private checkDockerAvailable;
+    /**
+     * Ensure the container image exists (async)
+     */
+    private ensureImage;
+    /**
+     * Create a new container
+     */
+    private createContainer;
+    /**
+     * Terminate a container (async)
+     */
+    private terminateContainer;
+    /**
+     * Get a ready container
+     */
+    private getReadyContainer;
+    /**
+     * Scale to minimum containers
+     */
+    private scaleToMinimum;
+    /**
+     * Execute worker in a specific container
+     */
+    private executeInContainer;
+    /**
+     * Execute command in container
+     */
+    private execInContainer;
+    /**
+     * Build worker command for container execution
+     */
+    private buildWorkerCommand;
+    /**
+     * Process queued tasks
+     */
+    private processQueue;
+    /**
+     * Start health check timer
+     */
+    private startHealthChecks;
+    /**
+     * Run health checks on all containers
+     */
+    private runHealthChecks;
+    /**
+     * Start idle check timer
+     */
+    private startIdleChecks;
+    /**
+     * Terminate idle containers above minimum
+     */
+    private runIdleChecks;
+    /**
+     * Try to parse JSON from output
+     */
+    private tryParseJson;
+    /**
+     * Create an error result
+     */
+    private createErrorResult;
+}
+export default ContainerWorkerPool;
+//# sourceMappingURL=container-worker-pool.d.ts.map