claude-flow-novice 1.5.12 → 1.5.14

package/.claude-flow-novice/dist/src/preferences/user-preference-manager.js

@@ -0,0 +1,371 @@
+/**
+ * User Preference Storage Manager
+ *
+ * A simple preference manager for storing user-specific settings.
+ * Follows the architecture patterns from config-manager.ts
+ *
+ * @module UserPreferenceManager
+ */ import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+import { EventEmitter } from "events";
+/**
+ * Custom error for preference operations
+ */ export class PreferenceError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "PreferenceError";
+    }
+}
+/**
+ * Default preferences for new installations
+ */ const DEFAULT_PREFERENCES = {
+    theme: "light",
+    language: "en",
+    notifications: true,
+    autoSave: true,
+    maxHistoryItems: 50
+};
+/**
+ * User Preference Manager
+ *
+ * Manages user-specific preferences with automatic persistence,
+ * error handling, and type safety.
+ */ export class UserPreferenceManager extends EventEmitter {
+    preferences;
+    storagePath;
+    autoSave;
+    cacheEnabled;
+    isInitialized;
+    /**
+   * Creates a new UserPreferenceManager instance
+   *
+   * @param options - Configuration options for the preference manager
+   */ constructor(options = {}){
+        super();
+        this.preferences = new Map();
+        this.storagePath = options.storagePath || path.join(os.homedir(), ".claude-flow", "user-preferences.json");
+        this.autoSave = options.autoSave ?? true;
+        this.cacheEnabled = options.cacheEnabled ?? true;
+        this.isInitialized = false;
+    }
+    /**
+   * Initializes the preference manager and loads existing preferences
+   *
+   * @returns Promise that resolves when initialization is complete
+   * @throws {PreferenceError} If initialization fails
+   */ async initialize() {
+        try {
+            // Ensure storage directory exists
+            const dir = path.dirname(this.storagePath);
+            await fs.mkdir(dir, {
+                recursive: true
+            });
+            // Load existing preferences or create defaults
+            try {
+                await this.load();
+            } catch (error) {
+                // No existing preferences file, load defaults
+                await this.loadDefaults();
+                if (this.autoSave) {
+                    await this.save();
+                }
+            }
+            this.isInitialized = true;
+            this.emit("initialized", {
+                timestamp: new Date()
+            });
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to initialize preference manager: ${errorMessage}`);
+        }
+    }
+    /**
+   * Retrieves a preference value by key
+   *
+   * @param key - The preference key to retrieve
+   * @param defaultValue - Optional default value if preference doesn't exist
+   * @returns The preference value or defaultValue if not found
+   * @throws {PreferenceError} If manager is not initialized
+   */ getPreference(key, defaultValue) {
+        this.ensureInitialized();
+        try {
+            const preference = this.preferences.get(key);
+            if (!preference) {
+                this.emit("preferenceNotFound", {
+                    key,
+                    timestamp: new Date()
+                });
+                return defaultValue;
+            }
+            this.emit("preferenceRetrieved", {
+                key,
+                type: preference.type,
+                timestamp: new Date()
+            });
+            return preference.value;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to get preference '${key}': ${errorMessage}`);
+        }
+    }
+    /**
+   * Sets a preference value
+   *
+   * @param key - The preference key to set
+   * @param value - The value to store
+   * @returns Promise that resolves when preference is set (and saved if autoSave is enabled)
+   * @throws {PreferenceError} If manager is not initialized or value is invalid
+   */ async setPreference(key, value) {
+        this.ensureInitialized();
+        try {
+            // Validate input
+            if (!key || typeof key !== "string") {
+                throw new PreferenceError("Preference key must be a non-empty string");
+            }
+            if (value === undefined) {
+                throw new PreferenceError("Preference value cannot be undefined");
+            }
+            // Determine value type
+            const valueType = this.determineType(value);
+            // Create preference object
+            const preference = {
+                key,
+                value,
+                type: valueType,
+                timestamp: Date.now()
+            };
+            // Store in map
+            const oldValue = this.preferences.get(key);
+            this.preferences.set(key, preference);
+            // Emit change event
+            this.emit("preferenceChanged", {
+                key,
+                oldValue: oldValue?.value,
+                newValue: value,
+                timestamp: new Date()
+            });
+            // Auto-save if enabled
+            if (this.autoSave) {
+                await this.save();
+            }
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to set preference '${key}': ${errorMessage}`);
+        }
+    }
+    /**
+   * Removes a preference by key
+   *
+   * @param key - The preference key to remove
+   * @returns Promise that resolves when preference is removed
+   * @throws {PreferenceError} If manager is not initialized
+   */ async removePreference(key) {
+        this.ensureInitialized();
+        try {
+            const existed = this.preferences.has(key);
+            if (existed) {
+                const preference = this.preferences.get(key);
+                this.preferences.delete(key);
+                this.emit("preferenceRemoved", {
+                    key,
+                    value: preference?.value,
+                    timestamp: new Date()
+                });
+                if (this.autoSave) {
+                    await this.save();
+                }
+            }
+            return existed;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to remove preference '${key}': ${errorMessage}`);
+        }
+    }
+    /**
+   * Loads default preferences
+   *
+   * @returns Promise that resolves when defaults are loaded
+   * @throws {PreferenceError} If loading defaults fails
+   */ async loadDefaults() {
+        try {
+            this.preferences.clear();
+            for (const [key, value] of Object.entries(DEFAULT_PREFERENCES)){
+                const preference = {
+                    key,
+                    value,
+                    type: this.determineType(value),
+                    timestamp: Date.now()
+                };
+                this.preferences.set(key, preference);
+            }
+            this.emit("defaultsLoaded", {
+                count: this.preferences.size,
+                timestamp: new Date()
+            });
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to load defaults: ${errorMessage}`);
+        }
+    }
+    /**
+   * Saves preferences to storage
+   *
+   * @returns Promise that resolves when save is complete
+   * @throws {PreferenceError} If save operation fails
+   */ async save() {
+        try {
+            // Convert Map to serializable object
+            const data = {};
+            for (const [key, preference] of this.preferences.entries()){
+                data[key] = preference;
+            }
+            // Write to file
+            const content = JSON.stringify(data, null, 2);
+            await fs.writeFile(this.storagePath, content, "utf8");
+            this.emit("preferencesSaved", {
+                count: this.preferences.size,
+                path: this.storagePath,
+                timestamp: new Date()
+            });
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to save preferences: ${errorMessage}`);
+        }
+    }
+    /**
+   * Loads preferences from storage
+   *
+   * @returns Promise that resolves when load is complete
+   * @throws {PreferenceError} If load operation fails
+   */ async load() {
+        try {
+            const content = await fs.readFile(this.storagePath, "utf8");
+            const data = JSON.parse(content);
+            this.preferences.clear();
+            for (const [key, preference] of Object.entries(data)){
+                // Validate loaded preference structure
+                if (this.isValidPreference(preference)) {
+                    this.preferences.set(key, preference);
+                }
+            }
+            this.emit("preferencesLoaded", {
+                count: this.preferences.size,
+                path: this.storagePath,
+                timestamp: new Date()
+            });
+        } catch (error) {
+            if (error.code === "ENOENT") {
+                throw new PreferenceError(`Preferences file not found: ${this.storagePath}`);
+            }
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            throw new PreferenceError(`Failed to load preferences: ${errorMessage}`);
+        }
+    }
+    /**
+   * Gets all preferences as a plain object
+   *
+   * @returns Object containing all preferences
+   */ getAllPreferences() {
+        this.ensureInitialized();
+        const result = {};
+        for (const [key, preference] of this.preferences.entries()){
+            result[key] = preference.value;
+        }
+        return result;
+    }
+    /**
+   * Resets all preferences to defaults
+   *
+   * @returns Promise that resolves when reset is complete
+   */ async reset() {
+        this.ensureInitialized();
+        await this.loadDefaults();
+        if (this.autoSave) {
+            await this.save();
+        }
+        this.emit("preferencesReset", {
+            timestamp: new Date()
+        });
+    }
+    /**
+   * Checks if a preference exists
+   *
+   * @param key - The preference key to check
+   * @returns True if preference exists, false otherwise
+   */ hasPreference(key) {
+        this.ensureInitialized();
+        return this.preferences.has(key);
+    }
+    /**
+   * Gets the storage path
+   *
+   * @returns The current storage path
+   */ getStoragePath() {
+        return this.storagePath;
+    }
+    /**
+   * Gets preference count
+   *
+   * @returns Number of stored preferences
+   */ getPreferenceCount() {
+        return this.preferences.size;
+    }
+    // Private helper methods
+    /**
+   * Ensures the manager is initialized before operations
+   *
+   * @throws {PreferenceError} If not initialized
+   */ ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new PreferenceError("PreferenceManager not initialized. Call initialize() first.");
+        }
+    }
+    /**
+   * Determines the type of a value
+   *
+   * @param value - Value to check
+   * @returns Type string
+   */ determineType(value) {
+        if (typeof value === "string") return "string";
+        if (typeof value === "number") return "number";
+        if (typeof value === "boolean") return "boolean";
+        return "object";
+    }
+    /**
+   * Validates a preference object structure
+   *
+   * @param preference - Preference to validate
+   * @returns True if valid, false otherwise
+   */ isValidPreference(preference) {
+        return preference && typeof preference === "object" && typeof preference.key === "string" && preference.value !== undefined && [
+            "string",
+            "number",
+            "boolean",
+            "object"
+        ].includes(preference.type) && typeof preference.timestamp === "number";
+    }
+}
+/**
+ * Export singleton instance factory
+ */ let defaultInstance = null;
+/**
+ * Gets the default preference manager instance
+ *
+ * @returns Singleton instance of UserPreferenceManager
+ */ export function getDefaultPreferenceManager() {
+    if (!defaultInstance) {
+        defaultInstance = new UserPreferenceManager();
+    }
+    return defaultInstance;
+}
+/**
+ * Creates a new preference manager instance
+ *
+ * @param options - Configuration options
+ * @returns New UserPreferenceManager instance
+ */ export function createPreferenceManager(options) {
+    return new UserPreferenceManager(options);
+}
+
+//# sourceMappingURL=user-preference-manager.js.map

package/.claude-flow-novice/dist/src/preferences/user-preference-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/preferences/user-preference-manager.ts"],"names":["promises","fs","path","os","EventEmitter","PreferenceError","Error","message","name","DEFAULT_PREFERENCES","theme","language","notifications","autoSave","maxHistoryItems","UserPreferenceManager","preferences","storagePath","cacheEnabled","isInitialized","options","Map","join","homedir","initialize","dir","dirname","mkdir","recursive","load","error","loadDefaults","save","emit","timestamp","Date","errorMessage","getPreference","key","defaultValue","ensureInitialized","preference","get","type","value","setPreference","undefined","valueType","determineType","now","oldValue","set","newValue","removePreference","existed","has","delete","clear","Object","entries","count","size","data","content","JSON","stringify","writeFile","readFile","parse","isValidPreference","code","getAllPreferences","result","reset","hasPreference","getStoragePath","getPreferenceCount","includes","defaultInstance","getDefaultPreferenceManager","createPreferenceManager"],"mappings":"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"}

package/.claude-flow-novice/dist/src/validators/index.js

@@ -0,0 +1,12 @@
+/**
+ * Validators Module
+ *
+ * Provides validation functionality for enforcing best practices and detecting anti-patterns.
+ *
+ * @module validators
+ */ // TodoWrite Batching Validator
+export { TodoWriteValidator, getGlobalValidator, resetGlobalValidator } from "./todowrite-batching-validator";
+// TodoWrite Integration
+export { isValidationEnabled, getIntegrationConfig, validateTodoWrite, parseValidationFlags, displayValidationHelp, todoWriteWithValidation, createValidationMiddleware, getValidationStatus } from "./todowrite-integration";
+
+//# sourceMappingURL=index.js.map

package/.claude-flow-novice/dist/src/validators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/validators/index.ts"],"names":["TodoWriteValidator","getGlobalValidator","resetGlobalValidator","isValidationEnabled","getIntegrationConfig","validateTodoWrite","parseValidationFlags","displayValidationHelp","todoWriteWithValidation","createValidationMiddleware","getValidationStatus"],"mappings":"AAAA;;;;;;CAMC,GAED,+BAA+B;AAC/B,SACEA,kBAAkB,EAClBC,kBAAkB,EAClBC,oBAAoB,QAKf,iCAAiC;AAExC,wBAAwB;AACxB,SACEC,mBAAmB,EACnBC,oBAAoB,EACpBC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,uBAAuB,EACvBC,0BAA0B,EAC1BC,mBAAmB,QAEd,0BAA0B"}

package/.claude-flow-novice/dist/src/validators/swarm-init-validator.js

@@ -0,0 +1,261 @@
+/**
+ * Swarm Initialization Validator
+ *
+ * Validates that swarm initialization is performed before spawning multiple agents.
+ * Ensures proper coordination and prevents inconsistent implementations across agents.
+ *
+ * @module validators/swarm-init-validator
+ */ import { Logger } from '../core/logger.js';
+const DEFAULT_CONFIG = {
+    requireSwarmForMultiAgent: true,
+    minAgentsRequiringSwarm: 2,
+    meshTopologyMaxAgents: 7,
+    hierarchicalTopologyMinAgents: 8
+};
+/**
+ * Validates swarm initialization before agent spawning
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional, will check environment if not provided)
+ * @param config - Validator configuration
+ * @returns Validation result with error messages and suggestions
+ *
+ * @example
+ * ```typescript
+ * const result = await validateSwarmInit(3);
+ * if (!result.valid) {
+ *   console.error(result.error);
+ *   console.log(result.suggestion);
+ * }
+ * ```
+ */ export async function validateSwarmInit(agentCount, swarmStatus, config = {}) {
+    const logger = new Logger('SwarmInitValidator');
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Single agent spawning doesn't require swarm
+    if (agentCount < cfg.minAgentsRequiringSwarm) {
+        return {
+            valid: true
+        };
+    }
+    // Check if swarm is required for this agent count
+    if (!cfg.requireSwarmForMultiAgent) {
+        logger.warn('Swarm validation is disabled in configuration');
+        return {
+            valid: true
+        };
+    }
+    // Get swarm status
+    const status = swarmStatus || await getSwarmStatus();
+    // Validate swarm is initialized
+    if (!status.initialized) {
+        const topology = agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+        return {
+            valid: false,
+            error: createErrorMessage(agentCount),
+            suggestion: createSuggestion(agentCount, topology),
+            topology,
+            maxAgents: agentCount
+        };
+    }
+    // Validate topology matches agent count
+    const topologyValidation = validateTopology(agentCount, status, cfg);
+    if (!topologyValidation.valid) {
+        return topologyValidation;
+    }
+    // Validate max agents capacity
+    if (status.maxAgents && agentCount > status.maxAgents) {
+        return {
+            valid: false,
+            error: `Cannot spawn ${agentCount} agents. Swarm configured for maximum ${status.maxAgents} agents.`,
+            suggestion: `Reinitialize swarm with increased maxAgents:\n  npx claude-flow-novice swarm init --topology ${status.topology} --max-agents ${agentCount}`
+        };
+    }
+    logger.info(`Swarm validation passed for ${agentCount} agents`);
+    return {
+        valid: true
+    };
+}
+/**
+ * Validates that topology matches agent count requirements
+ */ function validateTopology(agentCount, status, config) {
+    const expectedTopology = agentCount <= config.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+    if (status.topology && status.topology !== expectedTopology) {
+        return {
+            valid: false,
+            error: `Topology mismatch: ${agentCount} agents require '${expectedTopology}' topology, but swarm is using '${status.topology}'.`,
+            suggestion: `Reinitialize swarm with correct topology:\n  npx claude-flow-novice swarm init --topology ${expectedTopology} --max-agents ${agentCount}`,
+            topology: expectedTopology,
+            maxAgents: agentCount
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Creates error message for missing swarm initialization
+ */ function createErrorMessage(agentCount) {
+    return `
+❌ SWARM INITIALIZATION REQUIRED
+
+You are attempting to spawn ${agentCount} agents without initializing swarm.
+
+Without swarm coordination:
+  • Agents work independently with no shared context
+  • Results may be inconsistent (e.g., 3 different JWT secret solutions)
+  • No consensus validation or Byzantine fault tolerance
+  • Memory coordination is disabled
+
+This violates the mandatory coordination requirements in CLAUDE.md.
+`.trim();
+}
+/**
+ * Creates suggestion message with fix command
+ */ function createSuggestion(agentCount, topology) {
+    return `
+Fix:
+1. Initialize swarm first:
+   npx claude-flow-novice swarm init --topology ${topology} --max-agents ${agentCount}
+
+2. Then spawn agents:
+   [Your agent spawning command]
+
+Topology Selection:
+  • mesh: 2-7 agents (peer-to-peer coordination)
+  • hierarchical: 8+ agents (coordinator-led structure)
+
+See CLAUDE.md section "Swarm Initialization" for coordination requirements.
+`.trim();
+}
+/**
+ * Gets current swarm status from environment or MCP server
+ */ async function getSwarmStatus() {
+    const logger = new Logger('SwarmInitValidator');
+    // Check environment variables
+    const swarmId = process.env['CLAUDE_SWARM_ID'];
+    if (!swarmId) {
+        return {
+            initialized: false
+        };
+    }
+    // Try to get status from MCP server via swarm coordinator
+    try {
+        // Import dynamically to avoid circular dependencies
+        const { getSwarmCoordinator } = await import('../coordination/swarm-coordinator-factory.js').catch(()=>({
+                getSwarmCoordinator: null
+            }));
+        if (getSwarmCoordinator) {
+            const coordinator = getSwarmCoordinator();
+            if (coordinator) {
+                const status = coordinator.getSwarmStatus();
+                return {
+                    initialized: true,
+                    swarmId,
+                    activeAgents: status.agents.total,
+                    maxAgents: status.agents.total
+                };
+            }
+        }
+    } catch (error) {
+        logger.debug('Could not get swarm status from coordinator', error);
+    }
+    // If we have a swarm ID but can't get details, assume initialized
+    return {
+        initialized: true,
+        swarmId
+    };
+}
+/**
+ * Validates swarm initialization and throws error if invalid
+ *
+ * This is a convenience wrapper for validateSwarmInit that throws on validation failure.
+ * Use this in CLI commands where you want to halt execution on validation errors.
+ *
+ * @param agentCount - Number of agents to spawn
+ * @param swarmStatus - Current swarm status (optional)
+ * @param config - Validator configuration
+ * @throws Error if validation fails
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await requireSwarmInit(3);
+ *   // Proceed with spawning agents
+ * } catch (error) {
+ *   console.error(error.message);
+ *   process.exit(1);
+ * }
+ * ```
+ */ export async function requireSwarmInit(agentCount, swarmStatus, config) {
+    const result = await validateSwarmInit(agentCount, swarmStatus, config);
+    if (!result.valid) {
+        const errorMessage = `${result.error}\n\n${result.suggestion}`;
+        throw new Error(errorMessage);
+    }
+}
+/**
+ * Gets recommended topology for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns Recommended topology
+ */ export function getRecommendedTopology(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return agentCount <= cfg.meshTopologyMaxAgents ? 'mesh' : 'hierarchical';
+}
+/**
+ * Checks if swarm initialization is required for agent count
+ *
+ * @param agentCount - Number of agents
+ * @param config - Validator configuration
+ * @returns true if swarm initialization is required
+ */ export function isSwarmRequired(agentCount, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    return cfg.requireSwarmForMultiAgent && agentCount >= cfg.minAgentsRequiringSwarm;
+}
+/**
+ * Validates swarm configuration before initialization
+ *
+ * @param topology - Requested topology
+ * @param maxAgents - Maximum number of agents
+ * @param config - Validator configuration
+ * @returns Validation result
+ */ export function validateSwarmConfig(topology, maxAgents, config = {}) {
+    const cfg = {
+        ...DEFAULT_CONFIG,
+        ...config
+    };
+    // Validate topology matches max agents
+    const recommendedTopology = getRecommendedTopology(maxAgents, config);
+    if (topology !== recommendedTopology) {
+        return {
+            valid: false,
+            error: `Topology '${topology}' is not optimal for ${maxAgents} agents.`,
+            suggestion: `Recommended topology: '${recommendedTopology}'\n  • mesh: 2-${cfg.meshTopologyMaxAgents} agents\n  • hierarchical: ${cfg.hierarchicalTopologyMinAgents}+ agents`,
+            topology: recommendedTopology,
+            maxAgents
+        };
+    }
+    return {
+        valid: true
+    };
+}
+/**
+ * Factory for creating a swarm coordinator factory module
+ * This is a placeholder that will be replaced with actual implementation
+ */ export const SwarmCoordinatorFactory = {
+    getSwarmCoordinator () {
+        return null;
+    }
+};
+
+//# sourceMappingURL=swarm-init-validator.js.map

package/.claude-flow-novice/dist/src/validators/swarm-init-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/validators/swarm-init-validator.ts"],"names":["Logger","DEFAULT_CONFIG","requireSwarmForMultiAgent","minAgentsRequiringSwarm","meshTopologyMaxAgents","hierarchicalTopologyMinAgents","validateSwarmInit","agentCount","swarmStatus","config","logger","cfg","valid","warn","status","getSwarmStatus","initialized","topology","error","createErrorMessage","suggestion","createSuggestion","maxAgents","topologyValidation","validateTopology","info","expectedTopology","trim","swarmId","process","env","getSwarmCoordinator","catch","coordinator","activeAgents","agents","total","debug","requireSwarmInit","result","errorMessage","Error","getRecommendedTopology","isSwarmRequired","validateSwarmConfig","recommendedTopology","SwarmCoordinatorFactory"],"mappings":"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"}