claude-flow-novice 2.18.5 → 2.18.7

package/.claude/state/cfn-expert-last-commit

@@ -0,0 +1,2 @@
+1b98eb95a62461ad327e0533b6b2e8cbd30b8d21
+2025-12-08T20:27:43Z

package/fix-node_modules.md

@@ -0,0 +1,68 @@
+# Node Modules Centralization Plan
+
+## Problem
+- Duplicate node_modules directories across 88 locations in .claude/
+- Total size: 11GB+ in .claude/ + 720MB at root
+- Prevents including .claude/ in npm package
+
+## Root Cause Analysis
+1. Individual skill directories have their own package.json files
+2. Each runs `npm install` independently
+3. No workspace/yarn.lock configuration to share dependencies
+
+## Solution Steps
+
+### 1. Cleanup Duplicate node_modules
+```bash
+# Remove all node_modules in .claude/ directory
+find .claude -name "node_modules" -type d -exec rm -rf {} + 2>/dev/null
+
+# Also remove package-lock.json files in .claude/
+find .claude -name "package-lock.json" -delete 2>/dev/null
+```
+
+### 2. Implement Workspace Configuration
+```json
+// Add to root package.json
+{
+  "workspaces": [
+    ".claude/skills/*",
+    ".claude/skills/*/lib/*"
+  ]
+}
+```
+
+### 3. Consolidate Dependencies
+- Move common dependencies to root package.json
+- Remove local package.json files from skill subdirectories
+- Keep only essential skill-specific dependencies locally
+
+### 4. Update Import Paths
+- Adjust require/import statements to use root dependencies
+- Update any relative paths that assume local node_modules
+
+### 5. Update .npmignore
+```
+# Allow .claude/ but exclude build artifacts
+!.claude/
+!.claude/**
+
+# Only exclude build artifacts and temp files
+.claude/**/target/
+.claude/**/dist/
+.claude/**/.ruvector/
+.claude/**/index.db
+.claude/**/*.sqlite
+.claude/**/*.sqlite3
+```
+
+## Expected Outcome
+- Single node_modules at root (~1-2GB)
+- .claude/ can be included in npm package
+- Drastically reduced npm package size
+- Proper dependency management
+
+## Implementation Notes
+- Test each skill after consolidation
+- Maintain backward compatibility
+- Update CI/CD pipelines if needed

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "claude-flow-novice",
-  "version": "2.18.5",
-  "description": "Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture\n\nNOTE: The .claude/ directory is excluded from npm due to size constraints. For full functionality including Local RuVector and CFN skills, clone the repository from GitHub.",
+  "version": "2.18.7",
+  "description": "Claude Flow Novice - Advanced orchestration platform for multi-agent AI workflows with CFN Loop architecture\n\nIncludes Local RuVector Accelerator and all CFN skills for complete functionality.",
   "main": "index.js",
   "type": "module",
+  "bin": {
+    "cfn-init": "./scripts/cfn-init.js"
+  },
   "scripts": {
     "test": "npm run test:unit && npm run test:integration && npm run test:e2e",
     "test:unit": "jest --testPathPattern=tests/unit --coverage --coverageDirectory=coverage/unit",
@@ -86,62 +89,63 @@
     "@anthropic-ai/sdk": "^0.67.0",
     "@types/node": "^20.10.0",
     "axios": "^1.6.0",
-    "ioredis": "^5.3.2",
-    "lodash": "^4.17.21",
-    "ws": "^8.14.2",
-    "winston": "^3.11.0",
-    "yaml": "^2.3.4",
-    "commander": "^11.1.0",
-    "inquirer": "^9.2.11",
+    "bcryptjs": "^2.4.3",
+    "bull": "^4.12.2",
+    "cerebras": "^1.0.0",
     "chalk": "^5.3.0",
+    "claude-flow-novice": "^2.18.6",
+    "commander": "^11.1.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.1.5",
     "glob": "^10.3.10",
-    "semver": "^7.5.4",
+    "helmet": "^7.1.0",
+    "inquirer": "^9.2.11",
+    "ioredis": "^5.3.2",
     "joi": "^17.11.0",
     "jsonwebtoken": "^9.0.2",
-    "bcryptjs": "^2.4.3",
-    "uuid": "^9.0.1",
+    "knex": "^3.0.1",
+    "lodash": "^4.17.21",
     "node-cron": "^3.0.3",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "cors": "^2.8.5",
-    "helmet": "^7.1.0",
-    "compression": "^1.7.4",
-    "express-rate-limit": "^7.1.5",
-    "sqlite3": "^5.1.6",
     "pg": "^8.11.3",
-    "knex": "^3.0.1",
-    "bull": "^4.12.2",
-    "cerebras": "^1.0.0"
+    "semver": "^7.5.4",
+    "sqlite3": "^5.1.6",
+    "uuid": "^9.0.1",
+    "winston": "^3.11.0",
+    "ws": "^8.14.2",
+    "yaml": "^2.3.4"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.8",
-    "@types/lodash": "^4.14.202",
-    "@types/ws": "^8.5.10",
-    "@types/express": "^4.17.21",
-    "@types/cors": "^2.8.17",
+    "@types/bcryptjs": "^2.4.6",
     "@types/compression": "^1.7.5",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/inquirer": "^9.0.7",
+    "@types/jest": "^29.5.8",
     "@types/jsonwebtoken": "^9.0.5",
-    "@types/bcryptjs": "^2.4.6",
-    "@types/uuid": "^9.0.7",
+    "@types/lodash": "^4.14.202",
     "@types/node-cron": "^3.0.11",
-    "@types/inquirer": "^9.0.7",
     "@types/semver": "^7.5.6",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.1",
-    "ts-node": "^10.9.1",
-    "tsx": "^4.6.0",
-    "typescript": "^5.3.2",
-    "nodemon": "^3.0.2",
-    "eslint": "^8.54.0",
+    "@types/supertest": "^2.0.16",
+    "@types/uuid": "^9.0.7",
+    "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^6.12.0",
     "@typescript-eslint/parser": "^6.12.0",
-    "prettier": "^3.1.0",
     "concurrently": "^8.2.2",
+    "eslint": "^8.54.0",
     "http-server": "^14.1.1",
-    "typedoc": "^0.25.7",
+    "jest": "^29.7.0",
+    "nodemon": "^3.0.2",
     "open-cli": "^7.2.0",
+    "prettier": "^3.1.0",
     "supertest": "^6.3.3",
-    "@types/supertest": "^2.0.16"
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsx": "^4.6.0",
+    "typedoc": "^0.25.7",
+    "typescript": "^5.3.2"
   },
   "engines": {
     "node": ">=18.0.0",

package/readme/COMPONENT_NPM_STATUS.md

@@ -66,7 +66,7 @@ package/
 │
 ├── dist/                         ← ✅ 101 compiled JS files
 ├── scripts/
-│   ├── init-project.js           ← ✅ cfn-init binary
+│   ├── cfn-init.js               ← ✅ cfn-init binary
 │   └── ... (essential scripts)
 ├── package.json
 ├── README.md

package/readme/installation-process.md

@@ -168,7 +168,7 @@ node_modules/claude-flow-novice/
 │   └── cfn-data/                   # SQLite databases, playbook data
 │
 ├── scripts/
-│   ├── init-project.js             # cfn-init script
+│   ├── cfn-init.js                 # cfn-init script
 │   └── ... (essential scripts)
 ├── package.json                    # Package metadata
 ├── README.md                       # User documentation

package/scripts/cfn-init.js

@@ -0,0 +1,377 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promisify } from 'util';
+import { spawnSync } from 'child_process';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const cpAsync = promisify(fs.cp);
+const mkdirAsync = promisify(fs.mkdir);
+const existsAsync = promisify(fs.exists);
+
+// Find the CFN package root (works both in dev and installed contexts)
+function findCfnRoot() {
+  // During postinstall, we're inside the package being installed
+  const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (pkg.name === 'claude-flow-novice') {
+        // We're running from within the claude-flow-novice package (postinstall)
+        return path.resolve(__dirname, '..');
+      }
+    } catch (e) {
+      // Not a valid package.json, continue
+    }
+  }
+
+  // We're running from a project that has installed claude-flow-novice
+  return path.resolve(process.cwd(), 'node_modules', 'claude-flow-novice');
+}
+
+const cfnRoot = findCfnRoot();
+
+// Configuration for CFN initialization paths
+// Source directly from .claude/ folder (no need for separate claude-assets)
+const CFN_PATHS = {
+  agents: {
+    src: path.join(cfnRoot, '.claude/agents/cfn-dev-team'),
+    dest: '.claude/agents/cfn-dev-team'
+  },
+  skills: {
+    src: path.join(cfnRoot, '.claude/skills'),
+    dest: '.claude/skills',
+    pattern: 'cfn-*'
+  },
+  hooks: {
+    src: path.join(cfnRoot, '.claude/hooks'),
+    dest: '.claude/hooks',
+    pattern: 'cfn-*'
+  },
+  commands: {
+    src: path.join(cfnRoot, '.claude/commands'),
+    dest: '.claude/commands',
+    selectiveCopy: true // Copy all files to root, overwriting cfn-prefixed ones
+  },
+  cfnExtras: {
+    src: path.join(cfnRoot, '.claude/cfn-extras'),
+    dest: '.claude/cfn-extras'
+  },
+  core: {
+    src: path.join(cfnRoot, '.claude/core'),
+    dest: '.claude/core',
+    pattern: 'cfn-*'
+  },
+  helpers: {
+    src: path.join(cfnRoot, '.claude/helpers'),
+    dest: '.claude/helpers',
+    pattern: 'cfn-*'
+  }
+};
+
+async function ensureDirectories() {
+  const dirs = [
+    '.claude/agents/cfn-dev-team',
+    '.claude/skills',
+    '.claude/hooks',
+    '.claude/commands',
+    '.claude/cfn-extras',
+    '.claude/core',
+    '.claude/helpers'
+  ];
+
+  for (const dir of dirs) {
+    if (!await existsAsync(dir)) {
+      await mkdirAsync(dir, { recursive: true });
+      console.log(chalk.green(`✅ Created directory: ${dir}`));
+    }
+  }
+}
+
+async function verifyCfnInstallation() {
+  // Check if cfnRoot exists (works during postinstall and after install)
+  if (!fs.existsSync(cfnRoot)) {
+    console.error(chalk.red('❌ claude-flow-novice package root not found'));
+    console.error(chalk.yellow('cfnRoot:', cfnRoot));
+    process.exit(1);
+  }
+
+  // Verify critical directories exist
+  const criticalPaths = [
+    path.join(cfnRoot, '.claude/agents/cfn-dev-team'),
+    path.join(cfnRoot, '.claude/skills')
+  ];
+
+  for (const p of criticalPaths) {
+    if (!fs.existsSync(p)) {
+      console.error(chalk.red(`❌ Critical path missing: ${p}`));
+      process.exit(1);
+    }
+  }
+}
+
+async function copyFiles(src, dest, pattern, forceOverwrite = true, selectiveCopy = false) {
+  try {
+    if (!fs.existsSync(src)) {
+      console.warn(chalk.yellow(`⚠️ Source not found: ${src}`));
+      return false;
+    }
+
+    if (pattern) {
+      // Copy only files/dirs matching pattern (e.g., cfn-*)
+      const items = fs.readdirSync(src);
+      const matched = items.filter(item => item.startsWith(pattern.replace('*', '')));
+
+      for (const item of matched) {
+        const itemSrc = path.join(src, item);
+        const itemDest = path.join(dest, item);
+
+        // For cfn-prefixed items, remove existing to ensure clean update
+        if (forceOverwrite && fs.existsSync(itemDest)) {
+          fs.rmSync(itemDest, { recursive: true, force: true });
+        }
+
+        await mkdirAsync(path.dirname(itemDest), { recursive: true });
+        await cpAsync(itemSrc, itemDest, { recursive: true, force: true });
+      }
+      console.log(chalk.green(`✅ Copied ${matched.length} ${pattern} items from ${src} (overwrite: ${forceOverwrite})`));
+    } else if (selectiveCopy) {
+      // Copy all files to dest, but only overwrite files starting with 'cfn-' or 'CFN_'
+      await mkdirAsync(dest, { recursive: true });
+      const items = fs.readdirSync(src);
+      let copiedCount = 0;
+      let skippedCount = 0;
+
+      for (const item of items) {
+        const itemSrc = path.join(src, item);
+        const itemDest = path.join(dest, item);
+        const isCfnFile = item.startsWith('cfn-') || item.startsWith('CFN_');
+
+        // Skip if non-CFN file exists and we shouldn't overwrite
+        if (!isCfnFile && fs.existsSync(itemDest)) {
+          console.log(chalk.yellow(`  ⏭️  Skipped ${item} (non-CFN file exists)`));
+          skippedCount++;
+          continue;
+        }
+
+        // For CFN files, always overwrite
+        if (isCfnFile && fs.existsSync(itemDest)) {
+          fs.rmSync(itemDest, { recursive: true, force: true });
+        }
+
+        await cpAsync(itemSrc, itemDest, { recursive: true, force: true });
+        copiedCount++;
+      }
+      console.log(chalk.green(`✅ Copied ${copiedCount} files to ${dest} (skipped ${skippedCount} existing non-CFN files)`));
+    } else {
+      // Copy entire directory (e.g., cfn-dev-team)
+      // Remove existing destination to ensure clean update
+      if (forceOverwrite && fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true, force: true });
+      }
+
+      await mkdirAsync(path.dirname(dest), { recursive: true });
+      await cpAsync(src, dest, { recursive: true, force: true });
+      console.log(chalk.green(`✅ Copied ${src} → ${dest} (overwrite: ${forceOverwrite})`));
+    }
+    return true;
+  } catch (error) {
+    console.error(chalk.red(`❌ Error copying ${src}: ${error.message}`));
+    return false;
+  }
+}
+
+async function copyCfnClaudeMarkdown() {
+  const cfnClaudeMdPath = path.join(cfnRoot, '.claude/root-claude-distribute/CFN-CLAUDE.md');
+  const destPath = path.resolve(process.cwd(), 'CFN-CLAUDE.md');
+
+  if (fs.existsSync(cfnClaudeMdPath)) {
+    try {
+      await cpAsync(cfnClaudeMdPath, destPath);
+      console.log(chalk.green('📄 CFN-CLAUDE.md copied to project root'));
+      console.log(chalk.yellow('💡 Activate CFN workflows: cp CFN-CLAUDE.md CLAUDE.md'));
+    } catch (error) {
+      console.error(chalk.red(`❌ Failed to copy CFN-CLAUDE.md: ${error.message}`));
+    }
+  } else {
+    console.warn(chalk.yellow('⚠️ CFN-CLAUDE.md not found in source'));
+  }
+}
+
+async function installLizard() {
+  console.log(chalk.blue('\n🔧 Installing lizard (complexity analyzer)...'));
+
+  // Check if lizard is already installed
+  const checkResult = spawnSync('which', ['lizard'], { encoding: 'utf-8' });
+  if (checkResult.status === 0) {
+    console.log(chalk.green('✅ Lizard already installed'));
+    return;
+  }
+
+  // Try to install lizard via pip3
+  const pipCommands = [
+    ['pip3', 'install', '--user', '--break-system-packages', 'lizard'],
+    ['pip3', 'install', '--user', 'lizard'],
+    ['pip', 'install', '--user', 'lizard']
+  ];
+
+  for (const cmd of pipCommands) {
+    const result = spawnSync(cmd[0], cmd.slice(1), { encoding: 'utf-8' });
+    if (result.status === 0) {
+      console.log(chalk.green('✅ Lizard installed successfully'));
+      console.log(chalk.yellow('💡 Add to PATH: export PATH="$HOME/.local/bin:$PATH"'));
+      return;
+    }
+  }
+
+  // If all attempts failed, provide instructions
+  console.log(chalk.yellow('⚠️ Could not auto-install lizard. Manual installation required:'));
+  console.log(chalk.gray('   pip3 install --user lizard'));
+  console.log(chalk.gray('   or run: ./scripts/install-lizard.sh'));
+}
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    force: false,
+    help: false
+  };
+
+  for (const arg of args) {
+    if (arg === '--force' || arg === '-f') {
+      options.force = true;
+    }
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    }
+  }
+
+  return options;
+}
+
+function showHelp() {
+  console.log(chalk.blue('\n🚀 Claude Flow Novice - CFN Initialization\n'));
+  console.log('Usage: cfn-init [options]\n');
+  console.log('Options:');
+  console.log('  --force, -f     Force reinitialize even if already initialized');
+  console.log('  --help, -h      Show this help message\n');
+  console.log('Examples:');
+  console.log('  npx cfn-init              # Standard initialization');
+  console.log('  npx cfn-init --force      # Force reinitialize\n');
+}
+
+async function initializeCfnProject() {
+  // Parse command line arguments
+  const options = parseArgs();
+
+  // Show help if requested
+  if (options.help) {
+    showHelp();
+    return;
+  }
+
+  // Check initialization status and handle incomplete setups
+  const markerPath = '.claude/.cfn-initialized';
+  const requiredPaths = [
+    '.claude/agents/cfn-dev-team',
+    '.claude/skills',
+    '.claude/hooks',
+    '.claude/commands'
+  ];
+
+  if (fs.existsSync(markerPath)) {
+    // Check if initialization appears complete
+    const missingPaths = requiredPaths.filter(path => !fs.existsSync(path));
+
+    if (missingPaths.length === 0 && !options.force) {
+      console.log(chalk.green('✅ CFN already properly initialized'));
+      console.log(chalk.gray('   Use --force to reinitialize'));
+      return;
+    } else if (options.force) {
+      console.log(chalk.yellow('🚀 Force reinitializing CFN...'));
+      console.log(chalk.gray('Removing previous installation...'));
+      fs.rmSync(markerPath, { force: true });
+      // Remove existing directories for clean reinitialization
+      requiredPaths.forEach(path => {
+        if (fs.existsSync(path)) {
+          fs.rmSync(path, { recursive: true, force: true });
+        }
+      });
+      console.log(chalk.gray('Previous installation removed'));
+    } else {
+      console.log(chalk.yellow('⚠️ CFN initialization incomplete - reinitializing...'));
+      console.log(chalk.gray(`Missing components: ${missingPaths.join(', ')}`));
+      console.log(chalk.gray('Removing incomplete initialization marker...'));
+      fs.rmSync(markerPath, { force: true });
+      // Continue with full initialization
+    }
+  } else {
+    if (options.force) {
+      console.log(chalk.yellow('🚀 Force initializing CFN...'));
+    }
+  }
+
+  console.log(chalk.blue('\n🚀 Claude Flow Novice CFN Initialization\n'));
+
+  try {
+    // Verify prerequisites
+    await verifyCfnInstallation();
+    await ensureDirectories();
+
+    // Track copied files/directories
+    const copyResults = [];
+
+    // Copy CFN files
+    for (const [key, config] of Object.entries(CFN_PATHS)) {
+      const result = await copyFiles(
+        config.src,
+        config.dest,
+        config.pattern,
+        true, // forceOverwrite
+        config.selectiveCopy || false
+      );
+      copyResults.push(result);
+    }
+
+    // Copy CFN-CLAUDE.md
+    await copyCfnClaudeMarkdown();
+
+    // Summary
+    const successCount = copyResults.filter(Boolean).length;
+    const totalPaths = Object.keys(CFN_PATHS).length;
+
+    console.log(chalk.green(`\n✅ CFN Installation Complete`));
+    console.log(chalk.blue(`   Copied ${successCount}/${totalPaths} paths successfully`));
+
+    // Install lizard for complexity analysis
+    await installLizard();
+
+    // Create marker file to prevent re-initialization
+    fs.writeFileSync('.claude/.cfn-initialized', new Date().toISOString());
+
+    console.log(chalk.yellow('\n🔍 Next Steps:'));
+    console.log('   1. Review CFN-CLAUDE.md in project root');
+    console.log('   2. Run your first CFN Loop: npx cfn-loop "Task description"');
+    console.log('   3. Check available agents: ls .claude/agents/cfn-dev-team/*/\n');
+
+  } catch (error) {
+    console.error(chalk.red('❌ CFN Initialization Failed'), error);
+    process.exit(1);
+  }
+}
+
+// Make script executable
+if (import.meta.url === `file://${__filename}`) {
+  initializeCfnProject().catch((error) => {
+    console.error('❌ Initialization error:', error);
+    process.exit(1);
+  });
+}
+
+export default initializeCfnProject;