claude-flow-novice 2.2.4 → 2.2.5

package/scripts/post-install-claude-md.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+/**
+ * Post-Install Script for CLAUDE.md Protection
+ *
+ * This script runs after NPX install to safely handle CLAUDE.md generation
+ * without overwriting user customizations
+ */
+
+import { NpxClaudeMdProtection } from '../src/npx/claude-md-protection.js';
+import { execSync } from 'child_process';
+import path from 'path';
+
+async function postInstall() {
+  try {
+    // Determine the target project path
+    // When running via NPX, we want to affect the user's current directory
+    const targetPath = process.env.INIT_CWD || process.cwd();
+
+    console.log('🚀 Claude Flow Novice post-install...');
+    console.log(`📁 Target directory: ${targetPath}`);
+
+    // Run the protection system
+    const protection = new NpxClaudeMdProtection(targetPath);
+    const result = await protection.protectAndGenerate();
+
+    if (result.success) {
+      console.log('✅ CLAUDE.md setup completed successfully');
+
+      if (result.action === 'npx-protection') {
+        console.log('🛡️ Protection mode: Your existing CLAUDE.md is safe');
+      } else {
+        console.log('📄 New CLAUDE.md created for your project');
+      }
+    } else {
+      console.warn('⚠️ CLAUDE.md setup encountered issues:', result.error);
+    }
+
+    // Auto-setup MCP server if Claude Code is installed
+    await setupMcpIfAvailable();
+
+  } catch (error) {
+    console.error('❌ Post-install failed:', error.message);
+    // Don't fail the entire install if this fails
+    process.exit(0);
+  }
+}
+
+async function setupMcpIfAvailable() {
+  try {
+    // Check if Claude Code CLI is available
+    execSync('which claude', { stdio: 'ignore' });
+
+    console.log('\n🔧 Claude Code detected - setting up MCP server...');
+
+    // Add claude-flow-novice MCP server
+    execSync('claude mcp add claude-flow-novice npx claude-flow-novice mcp start', {
+      stdio: 'inherit'
+    });
+
+    console.log('✅ MCP server added successfully!');
+    console.log('🎯 You can now use claude-flow-novice tools in Claude Code');
+
+  } catch (error) {
+    // Claude Code not installed or MCP add failed - that's fine
+    console.log('\n💡 To use claude-flow-novice with Claude Code:');
+    console.log('   1. Install Claude Code if you haven\'t: npm install -g @anthropic-ai/claude-code');
+    console.log('   2. Add MCP server: claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
+    console.log('   3. Or run: npx claude-flow-novice init');
+  }
+}
+
+// Execute if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  postInstall();
+}
+
+export default postInstall;

package/scripts/postinstall.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+/**
+ * Post-installation script for claude-flow-novice
+ * Copies .claude directory from node_modules to project root
+ */
+
+import { existsSync, copySync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Copy .claude directory from node_modules to project root
+ */
+function copyClaudeDirectory() {
+  try {
+    const projectRoot = process.cwd();
+    const sourceDir = join(__dirname, '../dist/.claude');
+    const targetDir = join(projectRoot, '.claude');
+
+    console.log('🚀 claude-flow-novice post-install: Setting up .claude directory...');
+
+    // Check if source directory exists
+    if (!existsSync(sourceDir)) {
+      console.error('❌ Source .claude directory not found at:', sourceDir);
+      console.log('   This indicates a broken npm package installation.');
+      process.exit(1);
+    }
+
+    // Create target directory if it doesn't exist
+    if (!existsSync(targetDir)) {
+      mkdirSync(targetDir, { recursive: true });
+      console.log('✅ Created .claude directory in project root');
+    }
+
+    // Copy all contents from source to target
+    copySync(sourceDir, targetDir, {
+      overwrite: true,
+      recursive: true
+    });
+
+    console.log('✅ Successfully copied .claude directory to project root');
+    console.log('📁 Location:', targetDir);
+    console.log('🎯 Ready to use: npx claude-flow-novice --help');
+
+    // Verify key components were copied
+    const agentsDir = join(targetDir, 'agents');
+    const commandsDir = join(targetDir, 'commands');
+    const coreDir = join(targetDir, 'core');
+
+    if (existsSync(agentsDir)) {
+      const agentFiles = require('fs').readdirSync(agentsDir).length;
+      console.log(`📋 Agents: ${agentFiles} files copied`);
+    }
+
+    if (existsSync(commandsDir)) {
+      const commandFiles = require('fs').readdirSync(commandsDir).length;
+      console.log(`⚡ Commands: ${commandFiles} files copied`);
+    }
+
+    if (existsSync(coreDir)) {
+      const coreFiles = require('fs').readdirSync(coreDir).length;
+      console.log(`🔧 Core: ${coreFiles} files copied`);
+    }
+
+    console.log('🎉 Installation complete! claude-flow-novice is ready to use.');
+
+  } catch (error) {
+    console.error('❌ Post-install script failed:', error.message);
+    console.error('   Please run manually: cp -r node_modules/.claude-flow-novice/dist/.claude .claude');
+    process.exit(1);
+  }
+}
+
+// Run the installation
+copyClaudeDirectory();

package/scripts/pre-publish-validation.cjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-Publish Validation Suite
+ * Validates all critical functionality before npm package publication
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const TIMEOUT = 60000; // 60 seconds per test suite
+
+const TEST_SUITES = [
+  {
+    name: '1. Post-Edit Pipeline Functionality',
+    type: 'manual',
+    validate: () => {
+      const pipelinePath = 'config/hooks/post-edit-pipeline.js';
+      if (!fs.existsSync(pipelinePath)) {
+        throw new Error(`Post-edit pipeline not found at ${pipelinePath}`);
+      }
+
+      // Test basic execution (create test file first)
+      const testFile = 'test-validation-temp.js';
+      fs.writeFileSync(testFile, 'console.log("test");');
+
+      try {
+        execSync(`node ${pipelinePath} ${testFile}`, {
+          timeout: 30000,
+          stdio: 'pipe'
+        });
+        fs.unlinkSync(testFile);
+        return { status: 'PASS', message: 'Pipeline executable and functional' };
+      } catch (error) {
+        if (fs.existsSync(testFile)) fs.unlinkSync(testFile);
+        return { status: 'WARN', message: `Pipeline execution failed: ${error.message.substring(0, 100)}` };
+      }
+    }
+  },
+  {
+    name: '2. Full-Stack Swarm Tests',
+    type: 'jest',
+    tests: [
+      'tests/swarm-fullstack/backend-integration.test.ts',
+      'tests/swarm-fullstack/frontend-integration.test.ts',
+      'tests/swarm-fullstack/workflows/iterative-workflow.test.ts'
+    ]
+  },
+  {
+    name: '3. CFN Loop Core Tests',
+    type: 'jest',
+    tests: [
+      'tests/unit/cfn-loop/epic-iteration-limits.test.ts',
+      'tests/unit/cfn-loop/retry-todo-manager.test.ts',
+      'tests/integration/cfn-loop/cfn-loop-orchestrator.test.ts'
+    ]
+  },
+  {
+    name: '4. CFN Loop Slash Commands',
+    type: 'jest',
+    tests: [
+      'tests/integration/slash-commands/cfn-loop-commands.test.ts',
+      'tests/integration/slash-commands/cfn-loop-integration.test.js'
+    ]
+  },
+  {
+    name: '5. Tiered Structure with z.ai',
+    type: 'manual',
+    validate: () => {
+      const required = [
+        'src/providers/tiered-router.ts',
+        'src/providers/zai-provider.ts'
+      ];
+
+      const missing = required.filter(file => !fs.existsSync(file));
+      if (missing.length > 0) {
+        return { status: 'FAIL', message: `Missing files: ${missing.join(', ')}` };
+      }
+
+      // Check test file exists
+      const testFile = 'tests/providers/tiered-routing.test.ts';
+      if (!fs.existsSync(testFile)) {
+        return { status: 'WARN', message: `Test file not found: ${testFile}` };
+      }
+
+      return { status: 'PASS', message: 'Tiered routing files present' };
+    }
+  },
+  {
+    name: '6. SDK Process with Agents',
+    type: 'manual',
+    validate: () => {
+      const sdkTests = 'tests/coordination/v2/unit/sdk';
+      if (!fs.existsSync(sdkTests)) {
+        return { status: 'WARN', message: 'SDK tests directory not found (still in development)' };
+      }
+
+      const testFiles = fs.readdirSync(sdkTests, { recursive: true })
+        .filter(file => file.endsWith('.test.ts') || file.endsWith('.test.js'));
+
+      return {
+        status: 'INFO',
+        message: `SDK in development - ${testFiles.length} test files found`
+      };
+    }
+  }
+];
+
+function runJestTest(testPath) {
+  if (!fs.existsSync(testPath)) {
+    return { status: 'SKIP', message: 'Test file not found' };
+  }
+
+  try {
+    execSync(
+      `NODE_OPTIONS='--experimental-vm-modules' npm test -- ${testPath} --bail --maxWorkers=1 --forceExit --testTimeout=30000`,
+      {
+        timeout: TIMEOUT,
+        stdio: 'pipe'
+      }
+    );
+    return { status: 'PASS', message: 'All tests passed' };
+  } catch (error) {
+    const output = error.stdout?.toString() || error.stderr?.toString() || error.message;
+    const hasTests = output.includes('Test Suites:') || output.includes('Tests:');
+
+    if (!hasTests) {
+      return { status: 'SKIP', message: 'No executable tests found' };
+    }
+
+    return { status: 'FAIL', message: output.substring(0, 200) };
+  }
+}
+
+function formatResult(status) {
+  const colors = {
+    PASS: '\x1b[32m✓\x1b[0m',
+    FAIL: '\x1b[31m✗\x1b[0m',
+    WARN: '\x1b[33m⚠\x1b[0m',
+    INFO: '\x1b[36mℹ\x1b[0m',
+    SKIP: '\x1b[90m−\x1b[0m'
+  };
+  return colors[status] || status;
+}
+
+async function main() {
+  console.log('\n🚀 Pre-Publish Validation Suite\n');
+  console.log('=' .repeat(80) + '\n');
+
+  const results = [];
+
+  for (const suite of TEST_SUITES) {
+    console.log(`\n${suite.name}`);
+    console.log('-'.repeat(80));
+
+    if (suite.type === 'manual') {
+      const result = suite.validate();
+      console.log(`${formatResult(result.status)} ${result.message}`);
+      results.push({ suite: suite.name, ...result });
+    } else if (suite.type === 'jest') {
+      for (const testPath of suite.tests) {
+        const filename = path.basename(testPath);
+        const result = runJestTest(testPath);
+        console.log(`  ${formatResult(result.status)} ${filename}`);
+        if (result.message && result.status !== 'PASS') {
+          console.log(`     ${result.message.split('\n')[0]}`);
+        }
+        results.push({ suite: suite.name, test: filename, ...result });
+      }
+    }
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(80));
+  console.log('\n📊 SUMMARY\n');
+
+  const summary = {
+    PASS: results.filter(r => r.status === 'PASS').length,
+    FAIL: results.filter(r => r.status === 'FAIL').length,
+    WARN: results.filter(r => r.status === 'WARN').length,
+    INFO: results.filter(r => r.status === 'INFO').length,
+    SKIP: results.filter(r => r.status === 'SKIP').length
+  };
+
+  console.log(`${formatResult('PASS')} Passed:  ${summary.PASS}`);
+  console.log(`${formatResult('FAIL')} Failed:  ${summary.FAIL}`);
+  console.log(`${formatResult('WARN')} Warnings: ${summary.WARN}`);
+  console.log(`${formatResult('INFO')} Info:     ${summary.INFO}`);
+  console.log(`${formatResult('SKIP')} Skipped:  ${summary.SKIP}`);
+
+  console.log('\n' + '='.repeat(80));
+
+  // Critical failures block publication
+  if (summary.FAIL > 0) {
+    console.log('\n❌ CRITICAL: Tests failed. Fix before publishing.\n');
+    process.exit(1);
+  }
+
+  if (summary.PASS === 0 && summary.WARN > 0) {
+    console.log('\n⚠️  WARNING: No tests passed, only warnings. Review before publishing.\n');
+    process.exit(1);
+  }
+
+  console.log('\n✅ Validation complete. Ready for publication.\n');
+  process.exit(0);
+}
+
+main().catch(error => {
+  console.error('\n❌ Validation suite failed:', error.message);
+  process.exit(1);
+});