claude-flow-novice 2.2.4 → 2.2.5

package/scripts/utils/clean-build-artifacts.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+# Build Artifacts Cleanup Script
+# Safe removal of regenerable build artifacts
+# Author: CI/CD Pipeline Engineer
+# Generated: 2025-09-26
+
+set -e
+
+echo "🧹 Claude Flow Build Artifacts Cleanup"
+echo "======================================"
+
+# Verify we're in the right directory
+if [ ! -f "package.json" ]; then
+    echo "❌ Error: Not in project root directory"
+    exit 1
+fi
+
+# Function to safely remove if exists
+safe_remove() {
+    local path="$1"
+    local description="$2"
+
+    if [ -e "$path" ]; then
+        echo "🗑️  Removing $description: $path"
+        rm -rf "$path"
+        echo "✅ Removed successfully"
+    else
+        echo "ℹ️  Not found: $path"
+    fi
+}
+
+# Function to calculate size before removal
+calculate_size() {
+    local path="$1"
+    if [ -e "$path" ]; then
+        du -sh "$path" 2>/dev/null | cut -f1
+    else
+        echo "0"
+    fi
+}
+
+echo ""
+echo "📊 Calculating space to be recovered..."
+
+# Calculate sizes
+DIST_SIZE=$(calculate_size "dist")
+BUILD_CONSOLIDATED_SIZE=$(calculate_size "build-consolidated.js")
+STALE_PNPM_SIZE=$(calculate_size "pnpm-lock.yaml")
+
+echo "📁 dist/ directory: $DIST_SIZE"
+echo "📄 build-consolidated.js: $BUILD_CONSOLIDATED_SIZE"
+echo "📄 pnpm-lock.yaml (stale): $STALE_PNPM_SIZE"
+
+echo ""
+echo "🚀 Starting cleanup..."
+
+# 1. Remove main build output directory
+safe_remove "dist" "TypeScript compiled output directory"
+
+# 2. Remove temporary build script
+safe_remove "build-consolidated.js" "temporary build script"
+
+# 3. Remove stale PNPM lockfile (npm is being used)
+if [ -f "pnpm-lock.yaml" ] && [ -f "package-lock.json" ]; then
+    echo "🔍 Found both pnpm-lock.yaml and package-lock.json"
+    echo "📅 pnpm-lock.yaml is older (Sep 24) vs package-lock.json (Sep 26)"
+    safe_remove "pnpm-lock.yaml" "stale PNPM lockfile"
+fi
+
+# 4. Remove any temporary directories created during build
+safe_remove ".crdt-data" "temporary CRDT data"
+safe_remove ".demo-crdt-data" "temporary demo CRDT data"
+
+# 5. Remove TypeScript incremental build info (if any)
+find . -name "*.tsbuildinfo" -not -path "./node_modules/*" -delete 2>/dev/null || true
+
+# 6. Remove any Jest cache (if present)
+safe_remove ".jest" "Jest cache directory"
+
+# 7. Remove any coverage reports (if present)
+safe_remove "coverage" "test coverage reports"
+safe_remove ".nyc_output" "NYC coverage output"
+
+echo ""
+echo "✅ Build artifacts cleanup completed!"
+echo ""
+echo "🔧 To regenerate build artifacts:"
+echo "   npm run build       # Rebuilds dist/ directory"
+echo "   npm test            # Regenerates test artifacts"
+echo ""
+echo "📈 Space recovered: ~$DIST_SIZE + additional temp files"
+echo ""
+echo "⚠️  Note: All removed files can be regenerated via npm scripts"

package/scripts/utils/cleanup-root.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# Claude-Flow Root Directory Cleanup Script
+# This script organizes test files and documentation into appropriate directories
+
+echo "🧹 Starting Claude-Flow root directory cleanup..."
+
+# Create archive directories if they don't exist
+mkdir -p archive/reports
+mkdir -p archive/test-files
+mkdir -p archive/debug-docs
+
+# Move test reports and debugging documentation to archive
+echo "📁 Moving test reports and debug documentation..."
+mv -v CONFIGURATION_SUMMARY.md archive/reports/ 2>/dev/null || true
+mv -v DEPENDENCY_RESOLUTION_GUIDE.md archive/reports/ 2>/dev/null || true
+mv -v DOCKER_TEST_REPORT.md archive/reports/ 2>/dev/null || true
+mv -v ERROR_HANDLING_IMPLEMENTATION_REPORT.md archive/reports/ 2>/dev/null || true
+mv -v QA_TEST_REPORT.md archive/reports/ 2>/dev/null || true
+mv -v ROLLBACK_PLAN.md archive/reports/ 2>/dev/null || true
+mv -v WEB_UI_IMPLEMENTATION.md archive/reports/ 2>/dev/null || true
+mv -v debug-findings.md archive/debug-docs/ 2>/dev/null || true
+mv -v debug-hooks-system-SOLUTION.md archive/debug-docs/ 2>/dev/null || true
+mv -v mcp-validation-report.md archive/reports/ 2>/dev/null || true
+mv -v ruv-swarm-performance-analysis.md archive/reports/ 2>/dev/null || true
+
+# Move test JavaScript files to test archive
+echo "📁 Moving test JavaScript files..."
+mv -v test*.js archive/test-files/ 2>/dev/null || true
+mv -v test*.cjs archive/test-files/ 2>/dev/null || true
+mv -v terminal-test.cjs archive/test-files/ 2>/dev/null || true
+
+# Move deployment audit log
+echo "📁 Moving audit logs..."
+mv -v deployment-audit.log archive/reports/ 2>/dev/null || true
+
+# Keep only essential files in root:
+# - README.md (main documentation)
+# - CHANGELOG.md (version history)
+# - CLAUDE.md (Claude Code integration guide)
+# - LICENSE
+# - package.json, package-lock.json
+# - configuration files
+# - main entry points
+
+echo ""
+echo "✅ Essential files kept in root:"
+echo "- README.md (main documentation)"
+echo "- CHANGELOG.md (version history)"
+echo "- CLAUDE.md (Claude Code integration)"
+echo "- LICENSE"
+echo "- package.json & package-lock.json"
+echo "- Configuration files (.gitignore, .npmignore, etc.)"
+echo "- Main entry points (cli.js, claude-flow)"
+
+echo ""
+echo "📊 Cleanup Summary:"
+echo "- Test reports moved to: archive/reports/"
+echo "- Test files moved to: archive/test-files/"
+echo "- Debug docs moved to: archive/debug-docs/"
+
+# Show current root directory status
+echo ""
+echo "📂 Current root directory (*.md files):"
+ls -la *.md 2>/dev/null | grep -v "^d" || echo "No .md files remaining"
+
+echo ""
+echo "🧹 Cleanup complete! Root directory is now organized."
+echo "💡 To restore files, check the archive/ directory"

package/scripts/utils/fix-cliffy-imports.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix Cliffy imports by creating a compatibility layer
+ * This allows using Deno's Cliffy modules in Node.js
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Create Cliffy compatibility modules
+const cliffyModules = {
+  '@cliffy/command': `
+export class Command {
+  constructor() {
+    this._name = '';
+    this._version = '';
+    this._description = '';
+    this._options = [];
+    this._commands = new Map();
+    this._action = null;
+  }
+
+  name(name) {
+    this._name = name;
+    return this;
+  }
+
+  version(version) {
+    this._version = version;
+    return this;
+  }
+
+  description(description) {
+    this._description = description;
+    return this;
+  }
+
+  arguments(args) {
+    this._arguments = args;
+    return this;
+  }
+
+  option(flags, description, options) {
+    this._options.push({ flags, description, options });
+    return this;
+  }
+
+  action(fn) {
+    this._action = fn;
+    return this;
+  }
+
+  command(name, command) {
+    if (command) {
+      this._commands.set(name, command);
+    }
+    return command || new Command();
+  }
+
+  async parse(args) {
+    // Simple parse implementation
+    const parsed = { options: {}, args: [] };
+    return parsed;
+  }
+
+  help() {
+    console.log(\`Command: \${this._name}\`);
+    console.log(\`Version: \${this._version}\`);
+    console.log(\`Description: \${this._description}\`);
+  }
+
+  showHelp() {
+    this.help();
+  }
+}
+`,
+  '@cliffy/table': `
+export class Table {
+  constructor() {
+    this._headers = [];
+    this._rows = [];
+    this._options = {};
+  }
+
+  static from(data) {
+    const table = new Table();
+    if (Array.isArray(data) && data.length > 0) {
+      if (typeof data[0] === 'object') {
+        table._headers = Object.keys(data[0]);
+        table._rows = data.map(row => Object.values(row));
+      } else {
+        table._rows = data;
+      }
+    }
+    return table;
+  }
+
+  header(headers) {
+    this._headers = headers;
+    return this;
+  }
+
+  body(rows) {
+    this._rows = rows;
+    return this;
+  }
+
+  push(...rows) {
+    this._rows.push(...rows);
+    return this;
+  }
+
+  padding(padding) {
+    this._options.padding = padding;
+    return this;
+  }
+
+  indent(indent) {
+    this._options.indent = indent;
+    return this;
+  }
+
+  border(border) {
+    this._options.border = border;
+    return this;
+  }
+
+  toString() {
+    // Simple table rendering
+    let result = '';
+    if (this._headers.length) {
+      result += this._headers.join(' | ') + '\\n';
+      result += '-'.repeat(this._headers.join(' | ').length) + '\\n';
+    }
+    for (const row of this._rows) {
+      result += row.join(' | ') + '\\n';
+    }
+    return result;
+  }
+
+  render() {
+    console.log(this.toString());
+  }
+}
+`,
+  '@cliffy/ansi/colors': `
+const colorize = (code) => (text) => \`\\x1b[\${code}m\${text}\\x1b[0m\`;
+
+export const red = colorize('31');
+export const green = colorize('32');
+export const yellow = colorize('33');
+export const blue = colorize('34');
+export const magenta = colorize('35');
+export const cyan = colorize('36');
+export const white = colorize('37');
+export const gray = colorize('90');
+export const bold = colorize('1');
+export const dim = colorize('2');
+export const italic = colorize('3');
+export const underline = colorize('4');
+export const inverse = colorize('7');
+export const hidden = colorize('8');
+export const strikethrough = colorize('9');
+export const bgRed = colorize('41');
+export const bgGreen = colorize('42');
+export const bgYellow = colorize('43');
+export const bgBlue = colorize('44');
+export const bgMagenta = colorize('45');
+export const bgCyan = colorize('46');
+export const bgWhite = colorize('47');
+
+export const colors = {
+  red, green, yellow, blue, magenta, cyan, white, gray,
+  bold, dim, italic, underline, inverse, hidden, strikethrough,
+  bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite
+};
+`,
+  '@cliffy/prompt': `
+export const prompt = async (questions) => {
+  const answers = {};
+  for (const q of questions) {
+    console.log(q.message);
+    // Simplified implementation
+    answers[q.name] = q.default || '';
+  }
+  return answers;
+};
+
+export const confirm = async (options) => {
+  console.log(options.message);
+  return options.default !== false;
+};
+
+export const input = async (options) => {
+  console.log(options.message);
+  return options.default || '';
+};
+
+export const number = async (options) => {
+  console.log(options.message);
+  return options.default || 0;
+};
+
+export const secret = async (options) => {
+  console.log(options.message);
+  return options.default || '';
+};
+
+export const select = async (options) => {
+  console.log(options.message);
+  return options.options?.[0] || options.default || '';
+};
+
+export const checkbox = async (options) => {
+  console.log(options.message);
+  return options.default || [];
+};
+
+// Add class exports
+export class Select {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return select(this.options);
+  }
+}
+
+export class Input {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return input(this.options);
+  }
+}
+
+export class Confirm {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return confirm(this.options);
+  }
+}
+
+export class Number {
+  constructor(options) {
+    this.options = options;
+  }
+  async prompt() {
+    return number(this.options);
+  }
+}
+`
+};
+
+async function createCliffyModules() {
+  const nodeModulesDir = path.join(__dirname, '..', 'node_modules');
+  const cliffyDir = path.join(nodeModulesDir, '@cliffy');
+
+  // Create @cliffy directory
+  await fs.mkdir(cliffyDir, { recursive: true });
+
+  // Create each module
+  for (const [modulePath, content] of Object.entries(cliffyModules)) {
+    const parts = modulePath.split('/');
+    const moduleName = parts[1];
+    const subPath = parts[2];
+
+    const moduleDir = path.join(cliffyDir, moduleName);
+    await fs.mkdir(moduleDir, { recursive: true });
+
+    if (subPath) {
+      // Create subdirectory for nested modules
+      const fullPath = path.join(moduleDir, subPath + '.js');
+      const dirPath = path.dirname(fullPath);
+      await fs.mkdir(dirPath, { recursive: true });
+      await fs.writeFile(fullPath, content.trim());
+    } else {
+      // Create main module file
+      await fs.writeFile(path.join(moduleDir, 'index.js'), content.trim());
+    }
+
+    // Create package.json for the module
+    const packageJson = {
+      name: modulePath,
+      version: '0.22.2',
+      main: subPath ? `${subPath}.js` : 'index.js',
+      type: 'module'
+    };
+    await fs.writeFile(
+      path.join(moduleDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+  }
+
+  console.log('✅ Created Cliffy compatibility modules');
+}
+
+// Run the script
+createCliffyModules().catch(console.error);

package/scripts/utils/fix-duplicate-imports.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+
+/**
+ * Script to fix duplicate imports in the codebase
+ */
+
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+async function removeDuplicateImports(filePath) {
+  try {
+    let content = await fs.readFile(filePath, 'utf-8');
+    let modified = false;
+
+    // Remove duplicate error handler imports
+    const errorHandlerRegex = /import\s+{\s*getErrorMessage\s*}\s+from\s+['"].*?error-handler\.js['"];\s*\n/g;
+    const matches = content.match(errorHandlerRegex);
+    
+    if (matches && matches.length > 1) {
+      // Keep only the first import
+      let firstFound = false;
+      content = content.replace(errorHandlerRegex, (match) => {
+        if (!firstFound) {
+          firstFound = true;
+          return match;
+        }
+        modified = true;
+        return '';
+      });
+    }
+
+    // Remove duplicate fs imports
+    const fsImportRegex = /import\s+{\s*promises\s+as\s+fs\s*}\s+from\s+['"]node:fs['"];\s*\n/g;
+    const fsMatches = content.match(fsImportRegex);
+    
+    if (fsMatches && fsMatches.length > 1) {
+      // Keep only the first import
+      let firstFound = false;
+      content = content.replace(fsImportRegex, (match) => {
+        if (!firstFound) {
+          firstFound = true;
+          return match;
+        }
+        modified = true;
+        return '';
+      });
+    }
+
+    // Fix duplicate type imports
+    const typeImportRegex = /import\s+type\s+{\s*([^}]+)\s*}\s+from\s+['"]([^'"]+)['"];\s*\n/g;
+    const typeImports = new Map();
+    
+    content = content.replace(typeImportRegex, (match, types, from) => {
+      const key = from;
+      if (typeImports.has(key)) {
+        // Merge with existing import
+        const existing = typeImports.get(key);
+        const newTypes = types.split(',').map(t => t.trim());
+        const existingTypes = existing.split(',').map(t => t.trim());
+        const allTypes = [...new Set([...existingTypes, ...newTypes])];
+        typeImports.set(key, allTypes.join(', '));
+        modified = true;
+        return '';
+      } else {
+        typeImports.set(key, types);
+        return match;
+      }
+    });
+
+    if (modified) {
+      await fs.writeFile(filePath, content);
+      console.log(`✅ Fixed duplicate imports in: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`❌ Error processing ${filePath}:`, error.message);
+  }
+}
+
+async function findTypeScriptFiles(dir) {
+  const files = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    
+    if (entry.isDirectory() && !entry.name.includes('node_modules') && !entry.name.includes('dist')) {
+      files.push(...await findTypeScriptFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+async function main() {
+  const srcDir = join(dirname(__dirname), 'src');
+  const files = await findTypeScriptFiles(srcDir);
+  
+  console.log(`Found ${files.length} TypeScript files to check...`);
+  
+  for (const file of files) {
+    await removeDuplicateImports(file);
+  }
+  
+  console.log('✅ Duplicate import fixes complete!');
+}
+
+main().catch(console.error);

package/scripts/utils/fix-error-handling.cjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+// Find all TypeScript files
+const files = glob.sync('src/**/*.ts', { 
+  ignore: ['src/**/*.test.ts', 'src/**/*.spec.ts'] 
+});
+
+let totalFixed = 0;
+
+files.forEach(file => {
+  let content = fs.readFileSync(file, 'utf8');
+  let modified = false;
+
+  // Fix error handling patterns
+  const patterns = [
+    // Fix unknown error types in catch blocks
+    {
+      regex: /catch\s*\(\s*error\s*\)\s*{([^}]+error\.message)/g,
+      replacement: 'catch (error) {$1'
+    },
+    // Fix error.message access
+    {
+      regex: /(\$\{|`)error\.message/g,
+      replacement: '$1(error instanceof Error ? error.message : String(error))'
+    },
+    // Fix standalone error.message
+    {
+      regex: /([^`$])error\.message/g,
+      replacement: '$1(error instanceof Error ? error.message : String(error))'
+    },
+    // Fix error type annotations
+    {
+      regex: /catch\s*\(\s*error:\s*any\s*\)/g,
+      replacement: 'catch (error)'
+    },
+    // Fix error type in functions
+    {
+      regex: /\(error:\s*unknown\)/g,
+      replacement: '(error)'
+    }
+  ];
+
+  patterns.forEach(pattern => {
+    const before = content;
+    content = content.replace(pattern.regex, pattern.replacement);
+    if (before !== content) {
+      modified = true;
+    }
+  });
+
+  if (modified) {
+    // Add error handler import if needed
+    if (!content.includes("from '../utils/error-handler'") && 
+        !content.includes("from '../../utils/error-handler'") &&
+        content.includes('error instanceof Error')) {
+      const importPath = file.includes('cli/commands') ? '../../utils/error-handler' : '../utils/error-handler';
+      content = `import { getErrorMessage } from '${importPath}';\n` + content;
+    }
+
+    fs.writeFileSync(file, content);
+    totalFixed++;
+    console.log(`Fixed: ${file}`);
+  }
+});
+
+console.log(`\nTotal files fixed: ${totalFixed}`);