claude-flow-novice 2.0.4 → 2.0.5

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.4';
-// 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/mcp/DEPRECATED.js

@@ -1,50 +1,64 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
+
 /**
  * MCP Server - DEPRECATED in v2.0.0
  *
  * ⚠️ WARNING: MCP server has been completely removed in v2.0.0
- */ // Simple console colors without chalk (ES module compatible)
-const red = (text)=>`\x1b[31m${text}\x1b[0m`;
-const yellow = (text)=>`\x1b[33m${text}\x1b[0m`;
-const cyan = (text)=>`\x1b[36m${text}\x1b[0m`;
-const white = (text)=>`\x1b[37m${text}\x1b[0m`;
-const gray = (text)=>`\x1b[90m${text}\x1b[0m`;
-const green = (text)=>`\x1b[32m${text}\x1b[0m`;
-const blue = (text)=>`\x1b[34m${text}\x1b[0m`;
-const bold = (text)=>`\x1b[1m${text}\x1b[0m`;
-console.error(bold(red('\n❌ ERROR: MCP Server has been removed in v2.0.0\n')));
-console.error(yellow('The Model Context Protocol (MCP) server has been deprecated and removed.'));
-console.error(yellow('All functionality is now available via the unified CLI.\n'));
-console.error(cyan('Migration Required:\n'));
-console.error(white('  Old (MCP):'));
-console.error(gray('    node node_modules/claude-flow-novice/mcp/mcp-server.js'));
-console.error(gray('    mcp://swarm/init { objective: "Build API" }\n'));
-console.error(white('  New (CLI):'));
-console.error(green('    claude-flow-novice start'));
-console.error(green('    claude-flow-novice swarm init "Build API"\n'));
-console.error(cyan('Complete Command Mapping:\n'));
-console.error(white('  Swarm:'));
-console.error(gray('    mcp://swarm/init       →  claude-flow-novice swarm init <objective>'));
-console.error(gray('    mcp://swarm/spawn      →  claude-flow-novice swarm spawn <agent> <task>'));
-console.error(gray('    mcp://swarm/status     →  claude-flow-novice swarm status\n'));
-console.error(white('  Fleet:'));
-console.error(gray('    mcp://fleet/init       →  claude-flow-novice fleet init --max-agents <n>'));
-console.error(gray('    mcp://fleet/scale      →  claude-flow-novice fleet scale --target <n>'));
-console.error(gray('    mcp://fleet/status     →  claude-flow-novice fleet status\n'));
-console.error(white('  Memory:'));
-console.error(gray('    mcp://memory/store     →  claude-flow-novice memory store <key> --value <val>'));
-console.error(gray('    mcp://memory/retrieve  →  claude-flow-novice memory get <key>\n'));
-console.error(white('  Monitoring:'));
-console.error(gray('    mcp://monitor/metrics  →  claude-flow-novice monitor --component <name>'));
-console.error(gray('    mcp://monitor/dashboard→  claude-flow-novice dashboard start\n'));
-console.error(cyan('Programmatic Usage:\n'));
-console.error(white('  Use the new CLI wrapper SDK:\n'));
-console.error(green('    import { ClaudeFlowCLI } from \'claude-flow-novice\';\n'));
-console.error(green('    const cli = new ClaudeFlowCLI();'));
-console.error(green('    await cli.swarm.init({ objective: \'Build API\' });\n'));
-console.error(cyan('Documentation:\n'));
-console.error(white('  Migration Guide:'), blue('https://github.com/ruvnet/claude-flow-novice/blob/main/MCP_DEPRECATION_NOTICE.md'));
-console.error(white('  CLI Help:'), blue('claude-flow-novice help'));
-console.error(white('  Support:'), blue('https://github.com/ruvnet/claude-flow-novice/issues\n'));
-console.error(bold(red('MCP server cannot be started. Please migrate to CLI.\n')));
-process.exit(1);
+ */
+
+// Simple console colors without chalk (ES module compatible)
+const red = (text) => `\x1b[31m${text}\x1b[0m`;
+const yellow = (text) => `\x1b[33m${text}\x1b[0m`;
+const cyan = (text) => `\x1b[36m${text}\x1b[0m`;
+const white = (text) => `\x1b[37m${text}\x1b[0m`;
+const gray = (text) => `\x1b[90m${text}\x1b[0m`;
+const green = (text) => `\x1b[32m${text}\x1b[0m`;
+const blue = (text) => `\x1b[34m${text}\x1b[0m`;
+const bold = (text) => `\x1b[1m${text}\x1b[0m`;
+
+console.error(bold(red('\n❌ ERROR: MCP Server has been removed in v2.0.0\n')));
+console.error(yellow('The Model Context Protocol (MCP) server has been deprecated and removed.'));
+console.error(yellow('All functionality is now available via the unified CLI.\n'));
+
+console.error(cyan('Migration Required:\n'));
+console.error(white('  Old (MCP):'));
+console.error(gray('    node node_modules/claude-flow-novice/mcp/mcp-server.js'));
+console.error(gray('    mcp://swarm/init { objective: "Build API" }\n'));
+
+console.error(white('  New (CLI):'));
+console.error(green('    claude-flow-novice start'));
+console.error(green('    claude-flow-novice swarm init "Build API"\n'));
+
+console.error(cyan('Complete Command Mapping:\n'));
+console.error(white('  Swarm:'));
+console.error(gray('    mcp://swarm/init       →  claude-flow-novice swarm init <objective>'));
+console.error(gray('    mcp://swarm/spawn      →  claude-flow-novice swarm spawn <agent> <task>'));
+console.error(gray('    mcp://swarm/status     →  claude-flow-novice swarm status\n'));
+
+console.error(white('  Fleet:'));
+console.error(gray('    mcp://fleet/init       →  claude-flow-novice fleet init --max-agents <n>'));
+console.error(gray('    mcp://fleet/scale      →  claude-flow-novice fleet scale --target <n>'));
+console.error(gray('    mcp://fleet/status     →  claude-flow-novice fleet status\n'));
+
+console.error(white('  Memory:'));
+console.error(gray('    mcp://memory/store     →  claude-flow-novice memory store <key> --value <val>'));
+console.error(gray('    mcp://memory/retrieve  →  claude-flow-novice memory get <key>\n'));
+
+console.error(white('  Monitoring:'));
+console.error(gray('    mcp://monitor/metrics  →  claude-flow-novice monitor --component <name>'));
+console.error(gray('    mcp://monitor/dashboard→  claude-flow-novice dashboard start\n'));
+
+console.error(cyan('Programmatic Usage:\n'));
+console.error(white('  Use the new CLI wrapper SDK:\n'));
+console.error(green('    import { ClaudeFlowCLI } from \'claude-flow-novice\';\n'));
+console.error(green('    const cli = new ClaudeFlowCLI();'));
+console.error(green('    await cli.swarm.init({ objective: \'Build API\' });\n'));
+
+console.error(cyan('Documentation:\n'));
+console.error(white('  Migration Guide:'), blue('https://github.com/ruvnet/claude-flow-novice/blob/main/MCP_DEPRECATION_NOTICE.md'));
+console.error(white('  CLI Help:'), blue('claude-flow-novice help'));
+console.error(white('  Support:'), blue('https://github.com/ruvnet/claude-flow-novice/issues\n'));
+
+console.error(bold(red('MCP server cannot be started. Please migrate to CLI.\n')));
+
+process.exit(1);