claude-flow-novice 2.2.4 → 2.2.5

package/scripts/auto-setup.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+/**
+ * Automatic Setup Script for Redis & SQLite
+ *
+ * Runs automatically during npm postinstall
+ * - Non-interactive mode with smart defaults
+ * - Fails gracefully without breaking installation
+ * - Detects existing installations
+ * - Platform-specific optimizations
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir, platform } from 'os';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Detect if this is CI/npm publish environment
+const isCI = process.env.CI === 'true' || process.env.CI === '1';
+const isNpmPublish = process.env.npm_lifecycle_event === 'publish' || process.env.npm_lifecycle_event === 'prepublishOnly';
+const skipAutoSetup = process.env.SKIP_AUTO_SETUP === 'true' || isCI || isNpmPublish;
+
+// Allow users to opt-out via env var
+const userOptOut = process.env.CLAUDE_FLOW_NO_AUTO_SETUP === 'true';
+
+class AutoSetup {
+  constructor() {
+    this.platform = platform();
+    this.homeDir = homedir();
+    this.configDir = join(this.homeDir, '.claude-flow-novice', 'config');
+    this.logFile = join(this.homeDir, '.claude-flow-novice', 'setup.log');
+    this.logs = [];
+  }
+
+  log(message, level = 'info') {
+    const timestamp = new Date().toISOString();
+    const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+    this.logs.push(logEntry);
+
+    if (level === 'error') {
+      console.error(`❌ ${message}`);
+    } else if (level === 'warn') {
+      console.warn(`⚠️  ${message}`);
+    } else {
+      console.log(`ℹ️  ${message}`);
+    }
+  }
+
+  async run() {
+    // Skip if environment indicates we shouldn't run
+    if (skipAutoSetup) {
+      this.log('Auto-setup skipped (CI/npm publish environment)', 'info');
+      return { success: true, skipped: true, reason: 'ci-environment' };
+    }
+
+    if (userOptOut) {
+      this.log('Auto-setup disabled by user (CLAUDE_FLOW_NO_AUTO_SETUP=true)', 'info');
+      return { success: true, skipped: true, reason: 'user-opt-out' };
+    }
+
+    console.log('🚀 Claude Flow Novice - Automatic Setup\n');
+
+    try {
+      // Create config directory
+      await this.ensureConfigDirectory();
+
+      // Setup SQLite (automatic via better-sqlite3 package)
+      const sqliteResult = await this.setupSQLite();
+
+      // Setup Redis (with fallback)
+      const redisResult = await this.setupRedis();
+
+      // Sync agent profiles from package
+      const agentSyncResult = await this.syncAgentProfiles();
+
+      // Write setup status
+      await this.writeSetupStatus({ sqlite: sqliteResult, redis: redisResult, agents: agentSyncResult });
+
+      // Save logs
+      await this.saveLogs();
+
+      console.log('\n✅ Automatic setup completed!');
+      console.log(`📝 Setup log: ${this.logFile}\n`);
+
+      if (!redisResult.success) {
+        console.log('💡 To manually setup Redis later, run:');
+        console.log('   npm run redis:setup\n');
+      }
+
+      return { success: true, sqlite: sqliteResult, redis: redisResult };
+
+    } catch (error) {
+      this.log(`Setup error: ${error.message}`, 'error');
+      await this.saveLogs();
+
+      // Don't fail the npm install - just warn
+      console.warn('\n⚠️  Automatic setup encountered issues but npm install will continue.');
+      console.warn('📝 Run "npm run quick-install" to complete setup manually.\n');
+
+      return { success: false, error: error.message };
+    }
+  }
+
+  async ensureConfigDirectory() {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+      this.log(`Created config directory: ${this.configDir}`);
+    }
+  }
+
+  async setupSQLite() {
+    this.log('Setting up SQLite...');
+
+    try {
+      // SQLite is automatic via better-sqlite3 npm package
+      // Just verify it's installed
+      const packageJson = join(process.cwd(), 'package.json');
+      const pkg = JSON.parse(require('fs').readFileSync(packageJson, 'utf8'));
+
+      if (pkg.dependencies && pkg.dependencies['better-sqlite3']) {
+        this.log('SQLite (better-sqlite3) is installed', 'info');
+
+        // Create default database directory
+        const dbDir = join(this.homeDir, '.claude-flow-novice', 'data');
+        if (!existsSync(dbDir)) {
+          mkdirSync(dbDir, { recursive: true });
+          this.log(`Created SQLite database directory: ${dbDir}`);
+        }
+
+        return {
+          success: true,
+          version: pkg.dependencies['better-sqlite3'],
+          message: 'SQLite ready (better-sqlite3 installed)'
+        };
+      } else {
+        this.log('SQLite package not found', 'warn');
+        return { success: false, message: 'better-sqlite3 not in dependencies' };
+      }
+    } catch (error) {
+      this.log(`SQLite setup error: ${error.message}`, 'error');
+      return { success: false, error: error.message };
+    }
+  }
+
+  async setupRedis() {
+    this.log('Checking Redis installation...');
+
+    try {
+      // Check if Redis is already installed and running
+      try {
+        execSync('redis-cli ping', { stdio: 'pipe', timeout: 5000 });
+        this.log('Redis is already installed and running!', 'info');
+
+        const version = execSync('redis-server --version', { encoding: 'utf8' }).trim();
+        return {
+          success: true,
+          version,
+          status: 'already-installed',
+          message: 'Redis detected and running'
+        };
+      } catch {
+        // Redis not running or not installed
+      }
+
+      // Check if Redis is installed but not running
+      try {
+        const version = execSync('redis-server --version', { encoding: 'utf8', timeout: 5000 }).trim();
+        this.log('Redis installed but not running', 'info');
+
+        // Try to start it
+        try {
+          if (this.platform === 'darwin') {
+            execSync('brew services start redis', { stdio: 'pipe', timeout: 10000 });
+          } else if (this.platform === 'linux') {
+            execSync('sudo systemctl start redis', { stdio: 'pipe', timeout: 10000 });
+          } else if (this.platform === 'win32') {
+            execSync('net start Redis', { stdio: 'pipe', timeout: 10000 });
+          }
+
+          this.log('Redis started successfully!', 'info');
+          return { success: true, version, status: 'started', message: 'Redis started' };
+        } catch (startError) {
+          this.log('Could not start Redis automatically', 'warn');
+          return {
+            success: false,
+            version,
+            status: 'installed-not-running',
+            message: 'Redis installed but failed to start automatically',
+            manualStart: true
+          };
+        }
+      } catch {
+        // Redis not installed at all
+      }
+
+      // Redis not installed - provide installation instructions
+      this.log('Redis not found - installation required', 'warn');
+
+      const instructions = this.getRedisInstallInstructions();
+
+      return {
+        success: false,
+        status: 'not-installed',
+        message: 'Redis not installed',
+        instructions
+      };
+
+    } catch (error) {
+      this.log(`Redis check error: ${error.message}`, 'error');
+      return { success: false, error: error.message };
+    }
+  }
+
+  getRedisInstallInstructions() {
+    const instructions = {
+      darwin: [
+        'Install via Homebrew:',
+        '  brew install redis',
+        '  brew services start redis'
+      ],
+      linux: [
+        'Install via package manager:',
+        '  Ubuntu/Debian: sudo apt-get install redis-server',
+        '  CentOS/RHEL: sudo yum install redis',
+        '  Start: sudo systemctl start redis'
+      ],
+      win32: [
+        'Install via:',
+        '  1. Download Redis from: https://github.com/microsoftarchive/redis/releases',
+        '  2. Or use WSL2: wsl --install then install Redis in Ubuntu',
+        '  3. Or use Docker: docker run -d -p 6379:6379 redis'
+      ]
+    };
+
+    return instructions[this.platform] || instructions.linux;
+  }
+
+  async writeSetupStatus(results) {
+    const statusFile = join(this.configDir, 'setup-status.json');
+    const status = {
+      timestamp: new Date().toISOString(),
+      platform: this.platform,
+      autoSetup: true,
+      sqlite: results.sqlite,
+      redis: results.redis,
+      version: this.getPackageVersion()
+    };
+
+    writeFileSync(statusFile, JSON.stringify(status, null, 2));
+    this.log(`Setup status saved: ${statusFile}`);
+  }
+
+  async saveLogs() {
+    try {
+      const logDir = dirname(this.logFile);
+      if (!existsSync(logDir)) {
+        mkdirSync(logDir, { recursive: true });
+      }
+
+      writeFileSync(this.logFile, this.logs.join('\n'), 'utf8');
+    } catch (error) {
+      console.error(`Failed to save logs: ${error.message}`);
+    }
+  }
+
+  async syncAgentProfiles() {
+    this.log('Syncing agent profiles from package...');
+
+    try {
+      // Import the agent sync module
+      const AgentSync = (await import('./sync-agents.js')).default;
+
+      // Run sync with automatic overwrite
+      const syncer = new AgentSync({
+        projectRoot: process.cwd(),
+        skipBackup: false,  // Create backups of overwritten agents
+        verbose: false
+      });
+
+      const result = await syncer.sync();
+
+      if (result.success) {
+        const { created, overwritten, preserved } = result.stats;
+        this.log(`Agent profiles synced: ${created.length} new, ${overwritten.length} updated, ${preserved.length} unchanged`);
+
+        return {
+          success: true,
+          created: created.length,
+          overwritten: overwritten.length,
+          preserved: preserved.length,
+          backupDir: join(process.cwd(), '.claude', 'agents', '.backup')
+        };
+      } else {
+        this.log(`Agent sync failed: ${result.error}`, 'warn');
+        return { success: false, error: result.error };
+      }
+    } catch (error) {
+      this.log(`Agent sync error: ${error.message}`, 'error');
+      return { success: false, error: error.message };
+    }
+  }
+
+  getPackageVersion() {
+    try {
+      const packageJson = join(process.cwd(), 'package.json');
+      const pkg = JSON.parse(require('fs').readFileSync(packageJson, 'utf8'));
+      return pkg.version;
+    } catch {
+      return 'unknown';
+    }
+  }
+}
+
+// Run auto-setup if called directly
+async function main() {
+  const setup = new AutoSetup();
+  const result = await setup.run();
+
+  // Exit with 0 even on failure to not break npm install
+  process.exit(0);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+
+export default AutoSetup;

package/scripts/build/README.md

@@ -0,0 +1,167 @@
+# Build Scripts
+
+This directory contains all build-related scripts for the Claude Flow project.
+
+## Scripts
+
+### Core Build Scripts
+
+#### `unified-builder.sh` - Universal Build Script
+**Primary build script** consolidating all build operations into a single, powerful tool.
+
+```bash
+# Available modes
+scripts/build/unified-builder.sh [mode] [options]
+
+# Modes:
+# workaround  - Build with deprecation warning workarounds
+# filter      - Build with filtered output (removes warnings)
+# safe        - Build with automatic backup and rollback (default)
+# force       - Force build ignoring errors
+# migration   - Build with migration compatibility
+# clean       - Clean build artifacts before building
+# monitor     - Build with continuous monitoring
+
+# Examples
+scripts/build/unified-builder.sh safe --verbose
+scripts/build/unified-builder.sh clean filter
+npm run build                    # Uses safe mode
+npm run build:workaround         # Uses workaround mode
+```
+
+#### `typescript-fixer.js` - Universal TypeScript Error Fixer
+**Comprehensive TypeScript error resolution** with multiple fix strategies.
+
+```bash
+# Available strategies
+node scripts/build/typescript-fixer.js [strategy] [options]
+
+# Strategies:
+# basic       - Standard TypeScript error patterns
+# advanced    - Complex TypeScript error patterns
+# targeted    - File-specific targeted fixes
+# quick       - Fast common pattern fixes
+# batch       - Bulk operation fixes
+# all         - Apply all fix strategies (default)
+
+# Examples
+node scripts/build/typescript-fixer.js --dry-run
+npm run fix:typescript           # Uses default strategy
+npm run fix:typescript:quick     # Quick fixes only
+```
+
+#### `performance-monitor.js` - Build Performance Testing
+**Performance testing and monitoring** during build processes.
+
+```bash
+# Available commands
+node scripts/build/performance-monitor.js [command] [options]
+
+# Commands:
+# test [type]      - Run performance tests (basic|load|stress|endurance)
+# monitor          - Start build monitoring
+# report [format]  - Generate performance report (summary|detailed|json)
+# metrics          - Show current metrics
+
+# Examples
+npm run test:performance:basic   # Basic performance tests
+npm run performance:monitor      # Start continuous monitoring
+```
+
+### Build Configuration
+
+#### `build-config.js`
+Build configuration settings and environment setup.
+
+#### `build-prompt-copier.sh`
+Copies build prompts and templates for consistent build messaging.
+
+### Publishing & Release
+
+#### `prepare-publish.js`
+Prepares the package for publishing to NPM registry.
+
+#### `update-bin-version.js`
+Updates binary version numbers across the project.
+
+## Package.json Integration
+
+All build scripts are integrated into package.json for easy access:
+
+```json
+{
+  "scripts": {
+    "build": "scripts/build/unified-builder.sh safe",
+    "build:workaround": "scripts/build/unified-builder.sh workaround",
+    "build:force": "scripts/build/unified-builder.sh force",
+    "build:monitor": "scripts/build/unified-builder.sh monitor",
+    "fix:typescript": "node scripts/build/typescript-fixer.js",
+    "fix:typescript:basic": "node scripts/build/typescript-fixer.js basic",
+    "fix:typescript:advanced": "node scripts/build/typescript-fixer.js advanced",
+    "test:performance:basic": "node scripts/build/performance-monitor.js test basic",
+    "performance:monitor": "node scripts/build/performance-monitor.js monitor"
+  }
+}
+```
+
+## Features
+
+### Coordination Integration
+All build scripts include Claude Flow coordination hooks:
+- Pre-task initialization
+- Post-edit reporting
+- Task completion tracking
+- Session state management
+
+### Error Recovery
+- Automatic backup and rollback capabilities
+- Comprehensive error logging
+- Recovery strategies for build failures
+- Safe mode operations
+
+### Performance Optimization
+- Build time monitoring
+- Resource usage tracking
+- Performance regression detection
+- Optimization recommendations
+
+## Usage Guidelines
+
+1. **Prefer npm scripts** over direct script execution
+2. **Use safe mode** for production builds
+3. **Run performance tests** before major releases
+4. **Check TypeScript errors** with the fixer before commits
+5. **Monitor builds** during CI/CD operations
+
+## Troubleshooting
+
+### Common Issues
+
+**Build Failures:**
+```bash
+# Try safe mode with verbose output
+npm run build -- --verbose
+
+# Force build if necessary
+npm run build:force
+```
+
+**TypeScript Errors:**
+```bash
+# Quick fix common issues
+npm run fix:typescript:quick
+
+# Comprehensive fix
+npm run fix:typescript
+```
+
+**Performance Issues:**
+```bash
+# Check performance metrics
+npm run performance:monitor
+
+# Run performance tests
+npm run test:performance:basic
+```
+
+For legacy build scripts, see `../legacy/` directory.

package/scripts/build/build-config.js

@@ -0,0 +1,27 @@
+/**
+ * Build Configuration for Claude Flow
+ * 
+ * This configuration handles module resolution for dual Node.js/Deno support
+ */
+
+export const buildConfig = {
+  // Module aliases for Node.js build
+  moduleAliases: {
+    '@cliffy/ansi/colors': './src/adapters/cliffy-node.ts',
+    '@cliffy/prompt': './src/adapters/cliffy-node.ts',
+    '@cliffy/table': './src/adapters/cliffy-node.ts',
+  },
+  
+  // Modules to exclude from Node.js build
+  excludeModules: [
+    'vscode', // VS Code extension API
+  ],
+  
+  // External modules that should not be bundled
+  externals: [
+    '@modelcontextprotocol/sdk',
+    'better-sqlite3',
+    'node-pty',
+    'blessed',
+  ],
+};

package/scripts/build/build-prompt-copier.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Build script for prompt copier CLI
+set -e
+
+echo "Building prompt copier CLI..."
+
+# Ensure bin directory exists
+mkdir -p bin
+
+# Check if Deno is available
+if ! command -v deno &> /dev/null; then
+    echo "Error: Deno is required but not installed"
+    echo "Please install Deno: https://deno.land/manual/getting_started/installation"
+    exit 1
+fi
+
+# Compile the prompt CLI
+echo "Compiling prompt-copier..."
+PATH="/home/codespace/.deno/bin:$PATH" deno compile \
+    --allow-all \
+    --no-check \
+    --output=bin/prompt-copier \
+    src/swarm/prompt-cli.ts
+
+# Make executable
+chmod +x bin/prompt-copier
+
+echo "✅ prompt-copier CLI built successfully"
+echo "Usage: ./bin/prompt-copier --help"