claude-flow-novice 2.0.3 → 2.0.5

package/dist/src/cli/commands/swarm.js

@@ -4,7 +4,7 @@
 import { promises as fs } from "node:fs";
 import { success, error, warning } from "../cli-core.js";
 import { BackgroundExecutor } from "../../coordination/background-executor.js";
-import { SwarmMemoryManager } from "../../memory/swarm-memory.js";
+import { SwarmMemoryManager } from "../../swarm/memory.js";
 import { setSwarmCoordinator } from "../../coordination/swarm-coordinator-factory.js";
 import { requireSwarmInit } from "../../validators/swarm-init-validator.js";
 export async function swarmAction(ctx) {

package/dist/src/cli/main.js

@@ -2,7 +2,7 @@
 /**
  * Claude-Flow CLI - Main entry point for Node.js
  */ import { CLI } from "./cli-core.js";
-import { setupCommands } from "./commands/index.js";
+import { setupCommands } from "./commands";
 import { fileURLToPath } from "node:url";
 import { dirname } from "node:path";
 async function main() {

package/dist/src/coordination/byzantine-memory-channels.js

@@ -607,4 +607,28 @@ export class ByzantineMemoryChannel extends EventEmitter {
   }
 
   generateNodeId() {
-    return `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  generateProposalId() {\n    return `proposal_${this.consensus.currentRound}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n  }\n\n  signData(data) {\n    // Simple signature simulation - in production use proper cryptographic signatures\n    const dataStr = JSON.stringify(data);\n    return `sig_${Buffer.from(dataStr).toString('base64').substr(0, 16)}`;\n  }\n\n  updateMetrics(operation, duration, success) {\n    if (success) {\n      // Update success metrics\n    } else {\n      // Update failure metrics\n    }\n  }\n\n  updateAverage(currentAvg, newValue, count) {\n    return ((currentAvg * (count - 1)) + newValue) / count;\n  }\n}\n\n/**\n * Message Router for Byzantine communication\n */\nclass MessageRouter extends EventEmitter {\n  constructor(channelId) {\n    super();\n    this.channelId = channelId;\n    this.nodeId = null;\n    this.initialized = false;\n  }\n\n  async initialize(nodeId) {\n    this.nodeId = nodeId;\n    this.initialized = true;\n  }\n\n  async broadcast(message) {\n    // Simulate message broadcasting\n    this.emit('broadcast', { ...message, channelId: this.channelId });\n  }\n\n  async shutdown() {\n    this.initialized = false;\n    this.removeAllListeners();\n  }\n}\n\n/**\n * Consensus Manager for Byzantine fault tolerance\n */\nclass ConsensusManager {\n  constructor(threshold) {\n    this.threshold = threshold;\n  }\n\n  analyzeVotes(votes) {\n    if (votes.size === 0) {\n      return {\n        consensus: false,\n        reason: 'No votes received',\n        byzantineDetected: false\n      };\n    }\n\n    // Simple consensus analysis - in production use proper Byzantine algorithms\n    const voteArray = Array.from(votes.values());\n    const approvalVotes = voteArray.filter(vote => vote.approval === true).length;\n    const totalVotes = voteArray.length;\n    const approvalRatio = approvalVotes / totalVotes;\n\n    // Check for Byzantine behavior (conflicting votes from same node)\n    const byzantineNodes = this.detectByzantineBehavior(voteArray);\n\n    return {\n      consensus: approvalRatio >= this.threshold,\n      votes: voteArray,\n      approvalRatio,\n      byzantineDetected: byzantineNodes.size > 0,\n      byzantineNodes,\n      reason: approvalRatio >= this.threshold ? 'Consensus reached' : 'Insufficient approval'\n    };\n  }\n\n  detectByzantineBehavior(votes) {\n    const byzantineNodes = new Set();\n    const nodeVotes = new Map();\n\n    // Group votes by node\n    for (const vote of votes) {\n      if (!nodeVotes.has(vote.nodeId)) {\n        nodeVotes.set(vote.nodeId, []);\n      }\n      nodeVotes.get(vote.nodeId).push(vote);\n    }\n\n    // Check for conflicting votes from same node\n    for (const [nodeId, nodeVoteList] of nodeVotes.entries()) {\n      if (nodeVoteList.length > 1) {\n        // Check for contradictory votes\n        const approvals = nodeVoteList.map(v => v.approval);\n        if (approvals.includes(true) && approvals.includes(false)) {\n          byzantineNodes.add(nodeId);\n        }\n      }\n    }\n\n    return byzantineNodes;\n  }\n}\n\n/**\n * Byzantine Memory Channel Manager\n * Manages multiple channels with coordination\n */\nexport class ByzantineChannelManager extends EventEmitter {\n  constructor(options = {}) {\n    super();\n\n    this.options = {\n      maxChannels: options.maxChannels || 50,\n      defaultByzantineThreshold: options.defaultByzantineThreshold || 0.67,\n      enableCrossChannelConsensus: options.enableCrossChannelConsensus !== false,\n      ...options\n    };\n\n    this.channels = new Map();\n    this.crossChannelConsensus = new Map();\n    this.isInitialized = false;\n  }\n\n  /**\n   * Initialize channel manager\n   */\n  async initialize() {\n    if (this.isInitialized) return;\n\n    this.isInitialized = true;\n\n    this.emit('initialized', {\n      maxChannels: this.options.maxChannels,\n      crossChannelConsensus: this.options.enableCrossChannelConsensus\n    });\n\n    console.log('✅ Byzantine Channel Manager initialized');\n\n    return { success: true };\n  }\n\n  /**\n   * Create new Byzantine memory channel\n   */\n  async createChannel(channelId, options = {}) {\n    this.ensureInitialized();\n\n    if (this.channels.has(channelId)) {\n      throw new Error(`Channel ${channelId} already exists`);\n    }\n\n    if (this.channels.size >= this.options.maxChannels) {\n      throw new Error('Maximum number of channels reached');\n    }\n\n    const channelOptions = {\n      ...options,\n      byzantineThreshold: options.byzantineThreshold || this.options.defaultByzantineThreshold\n    };\n\n    const channel = new ByzantineMemoryChannel(channelId, channelOptions);\n    await channel.initialize();\n\n    this.channels.set(channelId, channel);\n\n    // Set up cross-channel event handling\n    channel.on('consensusReached', (data) => {\n      this.emit('channelConsensus', { channelId, ...data });\n    });\n\n    channel.on('byzantineDetected', (data) => {\n      this.emit('channelByzantine', { channelId, ...data });\n      this.handleCrossChannelByzantine(channelId, data);\n    });\n\n    this.emit('channelCreated', { channelId, options: channelOptions });\n\n    return channel;\n  }\n\n  /**\n   * Get channel by ID\n   */\n  getChannel(channelId) {\n    return this.channels.get(channelId);\n  }\n\n  /**\n   * Get all channels\n   */\n  getAllChannels() {\n    return Array.from(this.channels.values());\n  }\n\n  /**\n   * Store data across multiple channels with cross-channel consensus\n   */\n  async crossChannelStore(channelIds, key, value, options = {}) {\n    this.ensureInitialized();\n\n    if (!this.options.enableCrossChannelConsensus) {\n      throw new Error('Cross-channel consensus is disabled');\n    }\n\n    const channels = channelIds.map(id => this.getChannel(id)).filter(Boolean);\n\n    if (channels.length !== channelIds.length) {\n      throw new Error('Some channels not found');\n    }\n\n    // Execute storage across all channels\n    const storePromises = channels.map(channel =>\n      channel.store(key, value, {\n        ...options,\n        crossChannelConsensus: true,\n        participatingChannels: channelIds\n      })\n    );\n\n    const results = await Promise.allSettled(storePromises);\n    const successful = results.filter(r => r.status === 'fulfilled').length;\n    const successRate = successful / channels.length;\n\n    // Require majority success for cross-channel consensus\n    const consensusThreshold = 0.51;\n    if (successRate >= consensusThreshold) {\n      this.emit('crossChannelConsensus', {\n        key,\n        channels: channelIds,\n        successRate,\n        consensusReached: true\n      });\n\n      return {\n        success: true,\n        channels: channelIds,\n        successRate,\n        crossChannelConsensus: true\n      };\n    } else {\n      throw new Error(`Cross-channel consensus failed: ${successRate * 100}% success rate`);\n    }\n  }\n\n  /**\n   * Handle Byzantine detection across channels\n   */\n  async handleCrossChannelByzantine(channelId, byzantineData) {\n    // Propagate Byzantine intelligence to other channels\n    for (const [otherChannelId, channel] of this.channels.entries()) {\n      if (otherChannelId !== channelId) {\n        channel.emit('externalByzantine', {\n          sourceChannel: channelId,\n          ...byzantineData\n        });\n      }\n    }\n  }\n\n  /**\n   * Get comprehensive manager statistics\n   */\n  async getStats() {\n    this.ensureInitialized();\n\n    const channelStats = {};\n\n    for (const [channelId, channel] of this.channels.entries()) {\n      try {\n        channelStats[channelId] = await channel.getStats();\n      } catch (error) {\n        channelStats[channelId] = { error: error.message };\n      }\n    }\n\n    return {\n      manager: {\n        initialized: this.isInitialized,\n        channelCount: this.channels.size,\n        maxChannels: this.options.maxChannels,\n        crossChannelEnabled: this.options.enableCrossChannelConsensus\n      },\n      channels: channelStats\n    };\n  }\n\n  /**\n   * Shutdown all channels\n   */\n  async shutdown() {\n    if (!this.isInitialized) return;\n\n    const shutdownPromises = Array.from(this.channels.values()).map(\n      channel => channel.shutdown()\n    );\n\n    await Promise.allSettled(shutdownPromises);\n\n    this.channels.clear();\n    this.crossChannelConsensus.clear();\n    this.isInitialized = false;\n\n    this.emit('shutdown');\n    console.log('✅ Byzantine Channel Manager shut down successfully');\n  }\n\n  ensureInitialized() {\n    if (!this.isInitialized) {\n      throw new Error('Byzantine Channel Manager not initialized. Call initialize() first.');\n    }\n  }\n}\n\n// Factory functions\nexport function createByzantineChannel(channelId, options = {}) {\n  return new ByzantineMemoryChannel(channelId, options);\n}\n\nexport function createChannelManager(options = {}) {\n  return new ByzantineChannelManager(options);\n}\n\n// Test function\nexport async function testByzantineChannels() {\n  try {\n    const manager = new ByzantineChannelManager({\n      maxChannels: 5,\n      defaultByzantineThreshold: 0.67\n    });\n\n    await manager.initialize();\n\n    // Create test channel\n    const channel = await manager.createChannel('test-channel', {\n      enableFallback: true,\n      byzantineThreshold: 0.67\n    });\n\n    // Test storage\n    const storeResult = await channel.store('test-key', 'test-value', {\n      namespace: 'test'\n    });\n\n    // Test retrieval\n    const retrieved = await channel.retrieve('test-key', { namespace: 'test' });\n\n    // Get stats\n    const stats = await manager.getStats();\n\n    // Shutdown\n    await manager.shutdown();\n\n    return {\n      byzantine: true,\n      channelCreated: true,\n      storeSuccessful: storeResult.success,\n      retrieveSuccessful: retrieved === 'test-value',\n      consensusEnabled: storeResult.byzantineVerified !== undefined,\n      fallbackReady: stats.channels['test-channel']?.channel?.fallbackEnabled || false,\n      error: null\n    };\n  } catch (error) {\n    return {\n      byzantine: false,\n      error: error.message\n    };\n  }\n}\n\nexport default ByzantineMemoryChannel;
+    return `node_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  generateProposalId() {
+    return `proposal_${this.consensus.currentRound}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  signData(data) {
+    // Simple signature simulation - in production use proper cryptographic signatures
+    const dataStr = JSON.stringify(data);
+    return `sig_${Buffer.from(dataStr).toString('base64').substr(0, 16)}`;
+  }
+
+  updateMetrics(operation, duration, success) {
+    if (success) {
+      // Update success metrics
+    } else {
+      // Update failure metrics
+    }
+  }
+
+  updateAverage(currentAvg, newValue, count) {
+    return ((currentAvg * (count - 1)) + newValue) / count;
+  }
+}\n\n/**\n * Message Router for Byzantine communication\n */\nclass MessageRouter extends EventEmitter {\n  constructor(channelId) {\n    super();\n    this.channelId = channelId;\n    this.nodeId = null;\n    this.initialized = false;\n  }\n\n  async initialize(nodeId) {\n    this.nodeId = nodeId;\n    this.initialized = true;\n  }\n\n  async broadcast(message) {\n    // Simulate message broadcasting\n    this.emit('broadcast', { ...message, channelId: this.channelId });\n  }\n\n  async shutdown() {\n    this.initialized = false;\n    this.removeAllListeners();\n  }\n}\n\n/**\n * Consensus Manager for Byzantine fault tolerance\n */\nclass ConsensusManager {\n  constructor(threshold) {\n    this.threshold = threshold;\n  }\n\n  analyzeVotes(votes) {\n    if (votes.size === 0) {\n      return {\n        consensus: false,\n        reason: 'No votes received',\n        byzantineDetected: false\n      };\n    }\n\n    // Simple consensus analysis - in production use proper Byzantine algorithms\n    const voteArray = Array.from(votes.values());\n    const approvalVotes = voteArray.filter(vote => vote.approval === true).length;\n    const totalVotes = voteArray.length;\n    const approvalRatio = approvalVotes / totalVotes;\n\n    // Check for Byzantine behavior (conflicting votes from same node)\n    const byzantineNodes = this.detectByzantineBehavior(voteArray);\n\n    return {\n      consensus: approvalRatio >= this.threshold,\n      votes: voteArray,\n      approvalRatio,\n      byzantineDetected: byzantineNodes.size > 0,\n      byzantineNodes,\n      reason: approvalRatio >= this.threshold ? 'Consensus reached' : 'Insufficient approval'\n    };\n  }\n\n  detectByzantineBehavior(votes) {\n    const byzantineNodes = new Set();\n    const nodeVotes = new Map();\n\n    // Group votes by node\n    for (const vote of votes) {\n      if (!nodeVotes.has(vote.nodeId)) {\n        nodeVotes.set(vote.nodeId, []);\n      }\n      nodeVotes.get(vote.nodeId).push(vote);\n    }\n\n    // Check for conflicting votes from same node\n    for (const [nodeId, nodeVoteList] of nodeVotes.entries()) {\n      if (nodeVoteList.length > 1) {\n        // Check for contradictory votes\n        const approvals = nodeVoteList.map(v => v.approval);\n        if (approvals.includes(true) && approvals.includes(false)) {\n          byzantineNodes.add(nodeId);\n        }\n      }\n    }\n\n    return byzantineNodes;\n  }\n}\n\n/**\n * Byzantine Memory Channel Manager\n * Manages multiple channels with coordination\n */\nexport class ByzantineChannelManager extends EventEmitter {\n  constructor(options = {}) {\n    super();\n\n    this.options = {\n      maxChannels: options.maxChannels || 50,\n      defaultByzantineThreshold: options.defaultByzantineThreshold || 0.67,\n      enableCrossChannelConsensus: options.enableCrossChannelConsensus !== false,\n      ...options\n    };\n\n    this.channels = new Map();\n    this.crossChannelConsensus = new Map();\n    this.isInitialized = false;\n  }\n\n  /**\n   * Initialize channel manager\n   */\n  async initialize() {\n    if (this.isInitialized) return;\n\n    this.isInitialized = true;\n\n    this.emit('initialized', {\n      maxChannels: this.options.maxChannels,\n      crossChannelConsensus: this.options.enableCrossChannelConsensus\n    });\n\n    console.log('✅ Byzantine Channel Manager initialized');\n\n    return { success: true };\n  }\n\n  /**\n   * Create new Byzantine memory channel\n   */\n  async createChannel(channelId, options = {}) {\n    this.ensureInitialized();\n\n    if (this.channels.has(channelId)) {\n      throw new Error(`Channel ${channelId} already exists`);\n    }\n\n    if (this.channels.size >= this.options.maxChannels) {\n      throw new Error('Maximum number of channels reached');\n    }\n\n    const channelOptions = {\n      ...options,\n      byzantineThreshold: options.byzantineThreshold || this.options.defaultByzantineThreshold\n    };\n\n    const channel = new ByzantineMemoryChannel(channelId, channelOptions);\n    await channel.initialize();\n\n    this.channels.set(channelId, channel);\n\n    // Set up cross-channel event handling\n    channel.on('consensusReached', (data) => {\n      this.emit('channelConsensus', { channelId, ...data });\n    });\n\n    channel.on('byzantineDetected', (data) => {\n      this.emit('channelByzantine', { channelId, ...data });\n      this.handleCrossChannelByzantine(channelId, data);\n    });\n\n    this.emit('channelCreated', { channelId, options: channelOptions });\n\n    return channel;\n  }\n\n  /**\n   * Get channel by ID\n   */\n  getChannel(channelId) {\n    return this.channels.get(channelId);\n  }\n\n  /**\n   * Get all channels\n   */\n  getAllChannels() {\n    return Array.from(this.channels.values());\n  }\n\n  /**\n   * Store data across multiple channels with cross-channel consensus\n   */\n  async crossChannelStore(channelIds, key, value, options = {}) {\n    this.ensureInitialized();\n\n    if (!this.options.enableCrossChannelConsensus) {\n      throw new Error('Cross-channel consensus is disabled');\n    }\n\n    const channels = channelIds.map(id => this.getChannel(id)).filter(Boolean);\n\n    if (channels.length !== channelIds.length) {\n      throw new Error('Some channels not found');\n    }\n\n    // Execute storage across all channels\n    const storePromises = channels.map(channel =>\n      channel.store(key, value, {\n        ...options,\n        crossChannelConsensus: true,\n        participatingChannels: channelIds\n      })\n    );\n\n    const results = await Promise.allSettled(storePromises);\n    const successful = results.filter(r => r.status === 'fulfilled').length;\n    const successRate = successful / channels.length;\n\n    // Require majority success for cross-channel consensus\n    const consensusThreshold = 0.51;\n    if (successRate >= consensusThreshold) {\n      this.emit('crossChannelConsensus', {\n        key,\n        channels: channelIds,\n        successRate,\n        consensusReached: true\n      });\n\n      return {\n        success: true,\n        channels: channelIds,\n        successRate,\n        crossChannelConsensus: true\n      };\n    } else {\n      throw new Error(`Cross-channel consensus failed: ${successRate * 100}% success rate`);\n    }\n  }\n\n  /**\n   * Handle Byzantine detection across channels\n   */\n  async handleCrossChannelByzantine(channelId, byzantineData) {\n    // Propagate Byzantine intelligence to other channels\n    for (const [otherChannelId, channel] of this.channels.entries()) {\n      if (otherChannelId !== channelId) {\n        channel.emit('externalByzantine', {\n          sourceChannel: channelId,\n          ...byzantineData\n        });\n      }\n    }\n  }\n\n  /**\n   * Get comprehensive manager statistics\n   */\n  async getStats() {\n    this.ensureInitialized();\n\n    const channelStats = {};\n\n    for (const [channelId, channel] of this.channels.entries()) {\n      try {\n        channelStats[channelId] = await channel.getStats();\n      } catch (error) {\n        channelStats[channelId] = { error: error.message };\n      }\n    }\n\n    return {\n      manager: {\n        initialized: this.isInitialized,\n        channelCount: this.channels.size,\n        maxChannels: this.options.maxChannels,\n        crossChannelEnabled: this.options.enableCrossChannelConsensus\n      },\n      channels: channelStats\n    };\n  }\n\n  /**\n   * Shutdown all channels\n   */\n  async shutdown() {\n    if (!this.isInitialized) return;\n\n    const shutdownPromises = Array.from(this.channels.values()).map(\n      channel => channel.shutdown()\n    );\n\n    await Promise.allSettled(shutdownPromises);\n\n    this.channels.clear();\n    this.crossChannelConsensus.clear();\n    this.isInitialized = false;\n\n    this.emit('shutdown');\n    console.log('✅ Byzantine Channel Manager shut down successfully');\n  }\n\n  ensureInitialized() {\n    if (!this.isInitialized) {\n      throw new Error('Byzantine Channel Manager not initialized. Call initialize() first.');\n    }\n  }\n}\n\n// Factory functions\nexport function createByzantineChannel(channelId, options = {}) {\n  return new ByzantineMemoryChannel(channelId, options);\n}\n\nexport function createChannelManager(options = {}) {\n  return new ByzantineChannelManager(options);\n}\n\n// Test function\nexport async function testByzantineChannels() {\n  try {\n    const manager = new ByzantineChannelManager({\n      maxChannels: 5,\n      defaultByzantineThreshold: 0.67\n    });\n\n    await manager.initialize();\n\n    // Create test channel\n    const channel = await manager.createChannel('test-channel', {\n      enableFallback: true,\n      byzantineThreshold: 0.67\n    });\n\n    // Test storage\n    const storeResult = await channel.store('test-key', 'test-value', {\n      namespace: 'test'\n    });\n\n    // Test retrieval\n    const retrieved = await channel.retrieve('test-key', { namespace: 'test' });\n\n    // Get stats\n    const stats = await manager.getStats();\n\n    // Shutdown\n    await manager.shutdown();\n\n    return {\n      byzantine: true,\n      channelCreated: true,\n      storeSuccessful: storeResult.success,\n      retrieveSuccessful: retrieved === 'test-value',\n      consensusEnabled: storeResult.byzantineVerified !== undefined,\n      fallbackReady: stats.channels['test-channel']?.channel?.fallbackEnabled || false,\n      error: null\n    };\n  } catch (error) {\n    return {\n      byzantine: false,\n      error: error.message\n    };\n  }\n}\n\nexport default ByzantineMemoryChannel;

package/dist/src/index.js

@@ -1,36 +1,385 @@
 /**
- * Claude Flow Novice - Main Entry Point
- *
- * AI agent orchestration framework for beginners
- */ // Core exports
-export { AgentManager } from "./agents/agent-manager.js";
-export { SimpleAgent } from "./agents/simple-agent.js";
-export { ProjectManager } from "./core/project-manager.js";
-// Constants
-export const AgentType = {
-    CODER: 'coder',
-    TESTER: 'tester',
-    REVIEWER: 'reviewer',
-    PLANNER: 'planner',
-    ARCHITECT: 'architect',
-    RESEARCHER: 'researcher',
-    SECURITY_SPECIALIST: 'security-specialist',
-    PERF_ANALYZER: 'perf-analyzer',
-    DEVOPS_ENGINEER: 'devops-engineer',
-    CICD_ENGINEER: 'cicd-engineer',
-    API_DOCS: 'api-docs',
-    BACKEND_DEV: 'backend-dev',
-    FRONTEND_DEV: 'frontend-dev',
-    MOBILE_DEV: 'mobile-dev'
-};
-// Version
-export const VERSION = '2.0.3';
-// Default configuration
-export const defaultConfig = {
-    maxAgents: 7,
-    strategy: 'development',
-    mode: 'mesh',
-    persistence: true,
-    consensusThreshold: 0.90,
-    gateThreshold: 0.75
-};
+ * Content Filtering System - Main Entry Point
+ * Comprehensive solution for .md file overload and tone processing
+ */
+
+// Core Filtering Components
+export { ContentFilters } from './filters/content-filters.js';
+export { ToneProcessors } from './filters/tone-processors.js';
+
+// Integration and Hooks
+export { FilterIntegrationHooks } from './hooks/filter-integration.js';
+export { HooksIntegrationSystem } from './integration/hooks-integration.js';
+
+// Configuration and Preferences
+export { FilterConfiguration } from './config/filter-config.js';
+export { PreferenceManager } from './utils/preference-manager.js';
+
+// Real-time Processing
+export { RealtimeFilterMiddleware } from './middleware/realtime-filter.js';
+
+// Concurrent Processing
+export { ConcurrentFilterPipeline } from './concurrent/filter-pipeline.js';
+
+// Audit and Logging
+export { ContentAuditSystem } from './audit/content-audit.js';
+
+/**
+ * Main FilteringSystem class that orchestrates all components
+ */
+class FilteringSystem {
+  constructor(projectRoot = process.cwd(), options = {}) {
+    this.projectRoot = projectRoot;
+    this.options = {
+      enableRealtime: true,
+      enableConcurrency: true,
+      enableAudit: true,
+      enableHooksIntegration: true,
+      ...options,
+    };
+
+    this.initialized = false;
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Initialize all system components
+   */
+  async initializeComponents() {
+    // Core components
+    const { ContentFilters } = await import('./filters/content-filters.js');
+    const { ToneProcessors } = await import('./filters/tone-processors.js');
+
+    this.contentFilters = new ContentFilters();
+    this.toneProcessors = new ToneProcessors();
+
+    // Configuration
+    const { FilterConfiguration } = await import('./config/filter-config.js');
+    const { PreferenceManager } = await import('./utils/preference-manager.js');
+
+    this.filterConfig = new FilterConfiguration(this.projectRoot);
+    this.preferenceManager = new PreferenceManager(this.projectRoot);
+
+    // Integration
+    if (this.options.enableHooksIntegration) {
+      const { HooksIntegrationSystem } = await import('./integration/hooks-integration.js');
+      this.hooksIntegration = new HooksIntegrationSystem(this.projectRoot);
+    }
+
+    // Real-time processing
+    if (this.options.enableRealtime) {
+      const { RealtimeFilterMiddleware } = await import('./middleware/realtime-filter.js');
+      this.realtimeFilter = new RealtimeFilterMiddleware(this.projectRoot);
+    }
+
+    // Concurrent processing
+    if (this.options.enableConcurrency) {
+      const { ConcurrentFilterPipeline } = await import('./concurrent/filter-pipeline.js');
+      this.concurrentPipeline = new ConcurrentFilterPipeline(this.options.concurrent);
+    }
+
+    // Audit system
+    if (this.options.enableAudit) {
+      const { ContentAuditSystem } = await import('./audit/content-audit.js');
+      this.auditSystem = new ContentAuditSystem(this.projectRoot);
+    }
+
+    // Setup event listeners
+    this.setupEventHandlers();
+
+    this.initialized = true;
+  }
+
+  /**
+   * Setup event handlers between components
+   */
+  setupEventHandlers() {
+    if (this.realtimeFilter && this.auditSystem) {
+      this.realtimeFilter.on('contentProcessed', (result) => {
+        this.auditSystem.logFilterAction('REALTIME_PROCESSED', result);
+      });
+
+      this.realtimeFilter.on('contentBlocked', (result) => {
+        this.auditSystem.logFilterAction('REALTIME_BLOCKED', result);
+      });
+    }
+
+    if (this.concurrentPipeline && this.auditSystem) {
+      this.concurrentPipeline.on('jobCompleted', (job) => {
+        this.auditSystem.logFilterAction('CONCURRENT_JOB_COMPLETED', job);
+      });
+    }
+  }
+
+  /**
+   * Process single document
+   */
+  async processDocument(filePath, content, metadata = {}) {
+    await this.ensureInitialized();
+
+    const preferences = this.preferenceManager.getContextualPreferences(metadata);
+
+    // Apply content filtering
+    const filterResult = this.contentFilters.filterDocumentRequest(filePath, content, metadata);
+
+    if (!filterResult.allowed) {
+      return filterResult;
+    }
+
+    // Apply tone processing
+    const toneResult = this.toneProcessors.processMessage(
+      filterResult.content,
+      preferences.userPreferences.tonePreset,
+      preferences.userPreferences,
+    );
+
+    return {
+      ...filterResult,
+      content: toneResult.processed,
+      toneChanges: toneResult.changes,
+      processed: toneResult.processed !== content,
+    };
+  }
+
+  /**
+   * Process multiple documents concurrently
+   */
+  async processDocumentsConcurrently(documents, metadata = {}) {
+    await this.ensureInitialized();
+
+    if (!this.concurrentPipeline) {
+      throw new Error('Concurrent processing not enabled');
+    }
+
+    return this.concurrentPipeline.processParallel(documents, metadata);
+  }
+
+  /**
+   * Create real-time processing stream
+   */
+  createProcessingStream(options = {}) {
+    if (!this.realtimeFilter) {
+      throw new Error('Real-time processing not enabled');
+    }
+
+    return this.realtimeFilter.createStreamingProcessor(options);
+  }
+
+  /**
+   * Get comprehensive system status
+   */
+  getSystemStatus() {
+    const status = {
+      initialized: this.initialized,
+      uptime: Date.now() - this.startTime,
+      components: {},
+    };
+
+    if (this.contentFilters) {
+      status.components.contentFilters = this.contentFilters.getFilterStats();
+    }
+
+    if (this.toneProcessors) {
+      status.components.toneProcessors = this.toneProcessors.getProcessingStats();
+    }
+
+    if (this.realtimeFilter) {
+      status.components.realtimeFilter = this.realtimeFilter.getStats();
+    }
+
+    if (this.concurrentPipeline) {
+      status.components.concurrentPipeline = this.concurrentPipeline.getStats();
+    }
+
+    if (this.auditSystem) {
+      status.components.auditSystem = this.auditSystem.getDashboardData();
+    }
+
+    if (this.preferenceManager) {
+      status.components.preferences = this.preferenceManager.getUsageStatistics();
+    }
+
+    return status;
+  }
+
+  /**
+   * Generate comprehensive report
+   */
+  async generateSystemReport(timeframe = '24h') {
+    await this.ensureInitialized();
+
+    const report = {
+      timestamp: new Date().toISOString(),
+      timeframe,
+      systemStatus: this.getSystemStatus(),
+      auditReport: this.auditSystem?.generateAuditReport(timeframe),
+      preferences: this.preferenceManager?.exportPreferences(),
+      configuration: this.filterConfig?.exportConfig(),
+      recommendations: this.generateRecommendations(),
+    };
+
+    return report;
+  }
+
+  /**
+   * Generate system recommendations
+   */
+  generateRecommendations() {
+    const recommendations = [];
+
+    if (this.auditSystem) {
+      const stats = this.auditSystem.getDashboardData();
+
+      if (stats.overview.filteredToday > 50) {
+        recommendations.push({
+          type: 'performance',
+          priority: 'high',
+          message:
+            'High filtering activity detected. Consider adjusting filter rules to reduce false positives.',
+          action: 'review_filter_rules',
+        });
+      }
+
+      if (stats.overview.errorRate > 0.1) {
+        recommendations.push({
+          type: 'reliability',
+          priority: 'medium',
+          message: 'Error rate is elevated. Check system logs for recurring issues.',
+          action: 'check_error_logs',
+        });
+      }
+    }
+
+    if (this.concurrentPipeline) {
+      const stats = this.concurrentPipeline.getStats();
+
+      if (stats.workerUtilization > 90) {
+        recommendations.push({
+          type: 'scalability',
+          priority: 'medium',
+          message: 'High worker utilization. Consider scaling up worker pool.',
+          action: 'scale_workers',
+        });
+      }
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Update system configuration
+   */
+  async updateConfiguration(section, updates) {
+    await this.ensureInitialized();
+
+    switch (section) {
+      case 'contentFilters':
+        this.contentFilters.updateLimits(updates);
+        break;
+      case 'toneProcessors':
+        this.toneProcessors.updateConfig(updates);
+        break;
+      case 'preferences':
+        this.preferenceManager.updateActivePreferences('userPreferences', updates);
+        break;
+      case 'global':
+        this.filterConfig.updateConfig(section, updates);
+        break;
+      default:
+        throw new Error(`Unknown configuration section: ${section}`);
+    }
+
+    return this.filterConfig.exportConfig();
+  }
+
+  /**
+   * Ensure system is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initializeComponents();
+    }
+  }
+
+  /**
+   * Graceful system shutdown
+   */
+  async shutdown() {
+    if (this.realtimeFilter) {
+      await this.realtimeFilter.shutdown();
+    }
+
+    if (this.concurrentPipeline) {
+      await this.concurrentPipeline.shutdown();
+    }
+
+    if (this.auditSystem) {
+      // Flush any pending audit data
+      this.auditSystem.logFilterAction('SYSTEM_SHUTDOWN', {
+        timestamp: new Date().toISOString(),
+        uptime: Date.now() - this.startTime,
+      });
+    }
+
+    this.initialized = false;
+  }
+}
+
+export { FilteringSystem };
+export default FilteringSystem;
+
+/**
+ * Quick setup function for common use cases
+ */
+export function createFilteringSystem(options = {}) {
+  return new FilteringSystem(process.cwd(), options);
+}
+
+/**
+ * Express.js middleware factory
+ */
+export function createExpressMiddleware(options = {}) {
+  const system = new FilteringSystem(process.cwd(), options);
+
+  return async (req, res, next) => {
+    await system.ensureInitialized();
+
+    if (system.realtimeFilter) {
+      const middleware = system.realtimeFilter.createExpressMiddleware();
+      return middleware(req, res, next);
+    }
+
+    next();
+  };
+}
+
+/**
+ * CLI command factory
+ */
+export function createCliCommands(system) {
+  return {
+    async processFile(filePath, content, options = {}) {
+      return system.processDocument(filePath, content, options);
+    },
+
+    async batchProcess(documents, options = {}) {
+      return system.processDocumentsConcurrently(documents, options);
+    },
+
+    async getStatus() {
+      return system.getSystemStatus();
+    },
+
+    async generateReport(timeframe = '24h') {
+      return system.generateSystemReport(timeframe);
+    },
+
+    async updateConfig(section, updates) {
+      return system.updateConfiguration(section, updates);
+    },
+
+    async shutdown() {
+      return system.shutdown();
+    },
+  };
+}

package/dist/src/utils/error-handler.js

@@ -1,36 +1,2 @@
-/**
- * Utility for proper error handling in TypeScript
- */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-import { getErrorMessage as getErrorMsg, getErrorStack as getErrorStk, isError as isErr } from "./type-guards.js";
-export class AppError extends Error {
-    constructor(message, code, statusCode){
-        super(message), _define_property(this, "code", void 0), _define_property(this, "statusCode", void 0), this.code = code, this.statusCode = statusCode;
-        this.name = 'AppError';
-        Object.setPrototypeOf(this, AppError.prototype);
-    }
-}
-// Re-export from type-guards for backward compatibility
-export const isError = isErr;
-export const getErrorMessage = getErrorMsg;
-export const getErrorStack = getErrorStk;
-export function handleError(error, context) {
-    const message = getErrorMessage(error);
-    const stack = getErrorStack(error);
-    console.error(`Error${context ? ` in ${context}` : ''}: ${message}`);
-    if (stack && process.env.NODE_ENV === 'development') {
-        console.error('Stack trace:', stack);
-    }
-    process.exit(1);
-}
+// Re-export from TypeScript file
+export * from './error-handler.ts';