claude-flow-novice 2.3.1 → 2.3.3

package/scripts/fix-js-extensions.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * Post-build script to fix .js extensions in ES module imports
+ *
+ * SWC strips .js extensions from imports during compilation,
+ * which breaks ES modules that require explicit extensions.
+ *
+ * This script adds .js extensions to relative imports in the compiled output.
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const DIST_DIR = path.join(__dirname, '..', 'dist');
+
+// Patterns to match and fix relative imports without .js extension
+const IMPORT_PATTERNS = [
+  // import { x } from './module' or from "./module" (also handles directory imports like './commands')
+  {
+    pattern: /from\s+(['"])(\.\.[\/\\][^'"\s]+|\.\/[^'"\s]+)(['"])/g,
+    type: 'from',
+  },
+  // import './module' or import "./module"
+  {
+    pattern: /import\s+(['"])(\.\.[\/\\][^'"\s]+|\.\/[^'"\s]+)(['"])/g,
+    type: 'import',
+  },
+  // export { x } from './module' or from "./module"
+  {
+    pattern: /export\s+{[^}]*}\s+from\s+(['"])(\.\.[\/\\][^'"\s]+|\.\/[^'"\s]+)(['"])/g,
+    type: 'export-from',
+  },
+  // export * from './module' or from "./module"
+  {
+    pattern: /export\s+\*\s+from\s+(['"])(\.\.[\/\\][^'"\s]+|\.\/[^'"\s]+)(['"])/g,
+    type: 'export-star',
+  },
+];
+
+async function fixFileExtensions(filePath) {
+  try {
+    let content = await fs.readFile(filePath, 'utf8');
+    let modified = false;
+
+    for (const { pattern, type } of IMPORT_PATTERNS) {
+      content = content.replace(pattern, (match, quote1, modulePath, quote2) => {
+        // Skip if already has .js extension
+        if (modulePath.endsWith('.js')) {
+          return match;
+        }
+
+        // If it's a .ts extension in a .js file, change to .js
+        if (modulePath.endsWith('.ts')) {
+          const fixedModulePath = modulePath.replace('.ts', '.js');
+          const fixed = match.replace(modulePath, fixedModulePath);
+          modified = true;
+          return fixed;
+        }
+
+        // Skip if it's a JSON or other file type
+        if (modulePath.match(/\.(json|css|svg|png|jpg|jpeg|gif|wasm)$/)) {
+          return match;
+        }
+
+        // For directory imports like './commands', add '/index.js'
+        // For file imports like './module', add '.js'
+        let fixedModulePath;
+
+        // Check if this looks like a directory import (no file extension and no dots in last segment)
+        const lastSegment = modulePath.split('/').pop();
+        const looksLikeDirectory = !lastSegment.includes('.');
+
+        if (looksLikeDirectory && !modulePath.endsWith('/index')) {
+          // Directory import: './commands' → './commands/index.js'
+          fixedModulePath = modulePath + '/index.js';
+        } else {
+          // File import: './module' → './module.js'
+          fixedModulePath = modulePath + '.js';
+        }
+
+        const fixed = match.replace(modulePath, fixedModulePath);
+        modified = true;
+        return fixed;
+      });
+    }
+
+    if (modified) {
+      await fs.writeFile(filePath, content, 'utf8');
+      return true;
+    }
+
+    return false;
+  } catch (error) {
+    console.error(`Error processing ${filePath}:`, error.message);
+    return false;
+  }
+}
+
+async function processDirectory(dir) {
+  let fixedCount = 0;
+  let totalFiles = 0;
+
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      // Skip node_modules directories
+      if (entry.isDirectory() && entry.name === 'node_modules') {
+        continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+
+      if (entry.isDirectory()) {
+        // Recursively process subdirectories
+        const result = await processDirectory(fullPath);
+        fixedCount += result.fixedCount;
+        totalFiles += result.totalFiles;
+      } else if (entry.isFile() && entry.name.endsWith('.js')) {
+        totalFiles++;
+        const wasFixed = await fixFileExtensions(fullPath);
+        if (wasFixed) {
+          fixedCount++;
+          console.log(`✓ Fixed: ${path.relative(DIST_DIR, fullPath)}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.error(`Error processing directory ${dir}:`, error.message);
+  }
+
+  return { fixedCount, totalFiles };
+}
+
+async function main() {
+  console.log('🔧 Fixing .js extensions in compiled output...\n');
+
+  try {
+    // Check if dist directory exists
+    await fs.access(DIST_DIR);
+  } catch {
+    console.error(`❌ Distribution directory not found: ${DIST_DIR}`);
+    process.exit(1);
+  }
+
+  const { fixedCount, totalFiles } = await processDirectory(DIST_DIR);
+
+  console.log(`\n📊 Summary:`);
+  console.log(`   Total files processed: ${totalFiles}`);
+  console.log(`   Files fixed: ${fixedCount}`);
+  console.log(`   Files unchanged: ${totalFiles - fixedCount}`);
+
+  if (fixedCount > 0) {
+    console.log(`\n✅ Successfully fixed ${fixedCount} file(s)`);
+  } else {
+    console.log('\n✅ All files already have correct extensions');
+  }
+}
+
+main().catch((error) => {
+  console.error('❌ Fatal error:', error);
+  process.exit(1);
+});

package/scripts/generate-basic-types.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/**
+ * Generate basic type declarations when TypeScript compiler fails
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const projectRoot = path.resolve(__dirname, '..');
+const typesDir = path.join(projectRoot, '.claude-flow-novice/dist');
+
+// Create basic index.d.ts
+const indexDts = `/**
+ * Claude Flow Novice - Type Declarations
+ */
+
+export interface AgentConfig {
+  id: string;
+  name: string;
+  type: string;
+  capabilities?: string[];
+}
+
+export interface SwarmConfig {
+  maxAgents?: number;
+  strategy?: string;
+  mode?: string;
+  persistence?: boolean;
+}
+
+export declare class AgentManager {
+  constructor(config?: SwarmConfig);
+  spawnAgent(config: AgentConfig): Promise<string>;
+  destroyAgent(id: string): Promise<void>;
+  listAgents(): string[];
+}
+
+export declare class SimpleAgent {
+  constructor(config: AgentConfig);
+  execute(task: string): Promise<any>;
+}
+
+export declare const AgentType: {
+  CODER: string;
+  TESTER: string;
+  REVIEWER: string;
+  PLANNER: string;
+};
+
+export declare class ProjectManager {
+  createProject(name: string): Promise<void>;
+  loadProject(name: string): Promise<void>;
+  saveProject(): Promise<void>;
+}
+
+export { default as cli } from './src/cli/main.js';
+export { default as mcpServer } from './mcp/mcp-server-sdk.js';
+`;
+
+// Ensure types directory exists
+if (!fs.existsSync(typesDir)) {
+  fs.mkdirSync(typesDir, { recursive: true });
+}
+
+// Write type declarations
+fs.writeFileSync(path.join(typesDir, 'index.d.ts'), indexDts);
+
+console.log('✅ Created basic type declarations');

package/scripts/generate-changelog.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+
+/**
+ * Automated Changelog Generator
+ * Generates changelog entries based on git commit history and conventional commits
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+const currentVersion = packageJson.version;
+
+class ChangelogGenerator {
+  constructor() {
+    this.changelogPath = path.join(rootDir, 'CHANGELOG.md');
+    this.changelog = this.loadExistingChangelog();
+    this.categories = {
+      feat: 'Features',
+      fix: 'Bug Fixes',
+      docs: 'Documentation',
+      style: 'Style Changes',
+      refactor: 'Code Refactoring',
+      perf: 'Performance Improvements',
+      test: 'Testing',
+      build: 'Build System',
+      ci: 'Continuous Integration',
+      chore: 'Chores',
+      deps: 'Dependencies',
+      security: 'Security',
+      breaking: 'Breaking Changes'
+    };
+  }
+
+  loadExistingChangelog() {
+    try {
+      if (fs.existsSync(this.changelogPath)) {
+        const content = fs.readFileSync(this.changelogPath, 'utf8');
+        const sections = content.split('\n## ');
+        return {
+          header: sections[0] || '',
+          releases: sections.slice(1).map(section => {
+            const lines = section.split('\n');
+            const versionLine = lines[0];
+            const version = versionLine.match(/\[(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)\]/)?.[1];
+            const date = versionLine.match(/\((\d{4}-\d{2}-\d{2})\)/)?.[1];
+
+            return {
+              version,
+              date,
+              content: lines.slice(1).join('\n').trim()
+            };
+          })
+        };
+      }
+    } catch (error) {
+      console.warn('Warning: Could not load existing changelog:', error.message);
+    }
+
+    return {
+      header: '# Changelog\n\nAll notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n',
+      releases: []
+    };
+  }
+
+  getGitHistory(sinceVersion) {
+    try {
+      const lastTag = this.getLastTag();
+      let range = 'HEAD';
+
+      if (sinceVersion && lastTag) {
+        range = `${lastTag}..HEAD`;
+      } else if (lastTag) {
+        range = `${lastTag}..HEAD`;
+      }
+
+      const gitLog = execSync(
+        `git log ${range} --pretty=format:"%H|%s|%b|%an|%ad" --date=short`,
+        { encoding: 'utf8', cwd: rootDir }
+      );
+
+      return gitLog.trim().split('\n').map(line => {
+        const [hash, subject, body, author, date] = line.split('|');
+        return { hash, subject, body, author, date };
+      });
+    } catch (error) {
+      console.warn('Warning: Could not get git history:', error.message);
+      return [];
+    }
+  }
+
+  getLastTag() {
+    try {
+      return execSync('git describe --tags --abbrev=0', { encoding: 'utf8', cwd: rootDir }).trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  parseCommit(commit) {
+    const { subject, body, hash } = commit;
+
+    // Parse conventional commit format
+    const conventionalMatch = subject.match(/^(\w+)(\(.+\))?:\s*(.+)$/);
+    if (!conventionalMatch) {
+      return { type: 'chore', description: subject, breaking: false };
+    }
+
+    const [, type, scope, description] = conventionalMatch;
+    const breaking = subject.includes('BREAKING CHANGE:') ||
+                    (body && body.includes('BREAKING CHANGE:'));
+
+    return {
+      type: type.toLowerCase(),
+      scope: scope ? scope.replace(/[()]/g, '') : null,
+      description,
+      breaking,
+      body,
+      hash: hash.substring(0, 7)
+    };
+  }
+
+  categorizeCommits(commits) {
+    const categorized = {};
+
+    commits.forEach(commit => {
+      const parsed = this.parseCommit(commit);
+      let category = this.categories[parsed.type] || this.categories.chore;
+
+      if (parsed.breaking) {
+        category = this.categories.breaking;
+      }
+
+      if (!categorized[category]) {
+        categorized[category] = [];
+      }
+
+      categorized[category].push(parsed);
+    });
+
+    return categorized;
+  }
+
+  formatReleaseEntry(version, date, categorizedCommits) {
+    let entry = `## [${version}] - ${date}\n\n`;
+
+    const order = [
+      'Breaking Changes',
+      'Features',
+      'Bug Fixes',
+      'Security',
+      'Performance Improvements',
+      'Documentation',
+      'Code Refactoring',
+      'Testing',
+      'Build System',
+      'Continuous Integration',
+      'Dependencies',
+      'Style Changes',
+      'Chores'
+    ];
+
+    order.forEach(categoryName => {
+      const commits = categorizedCommits[categoryName];
+      if (commits && commits.length > 0) {
+        entry += `### ${categoryName}\n\n`;
+
+        commits.forEach(commit => {
+          let line = `- ${commit.description}`;
+
+          if (commit.scope) {
+            line = `- **${commit.scope}:** ${commit.description}`;
+          }
+
+          if (commit.breaking) {
+            line = `**${line}**`;
+          }
+
+          if (commit.hash) {
+            line += ` (${commit.hash})`;
+          }
+
+          entry += line + '\n';
+
+          // Add breaking change details
+          if (commit.body && commit.body.includes('BREAKING CHANGE:')) {
+            const breakingMatch = commit.body.match(/BREAKING CHANGE:\s*(.+)/s);
+            if (breakingMatch) {
+              entry += `  - Breaking change details: ${breakingMatch[1].trim()}\n`;
+            }
+          }
+        });
+
+        entry += '\n';
+      }
+    });
+
+    return entry;
+  }
+
+  updateChangelog(newVersion, date = new Date().toISOString().split('T')[0]) {
+    const commits = this.getGitHistory();
+    const categorizedCommits = this.categorizeCommits(commits);
+
+    if (Object.keys(categorizedCommits).length === 0) {
+      console.log('No commits found to add to changelog');
+      return;
+    }
+
+    const newEntry = this.formatReleaseEntry(newVersion, date, categorizedCommits);
+
+    // Update changelog structure
+    const newRelease = {
+      version: newVersion,
+      date,
+      content: newEntry.replace(/^## \[.+\] - .+\n\n/, '')
+    };
+
+    // Insert new release at the beginning
+    this.changelog.releases.unshift(newRelease);
+
+    // Write updated changelog
+    let content = this.changelog.header;
+    this.changelog.releases.forEach(release => {
+      content += `## [${release.version}] - ${release.date}\n\n`;
+      content += release.content + '\n';
+    });
+
+    fs.writeFileSync(this.changelogPath, content, 'utf8');
+    console.log(`✅ Changelog updated for version ${newVersion}`);
+
+    // Show summary
+    Object.entries(categorizedCommits).forEach(([category, commits]) => {
+      console.log(`  ${category}: ${commits.length} commits`);
+    });
+  }
+
+  validateChangelog() {
+    try {
+      const content = fs.readFileSync(this.changelogPath, 'utf8');
+
+      // Check for required sections
+      if (!content.includes('# Changelog')) {
+        throw new Error('Changelog must have a header');
+      }
+
+      if (!content.includes('## [')) {
+        throw new Error('Changelog must have at least one release section');
+      }
+
+      // Check for proper format
+      const releaseSections = content.match(/## \[([^\]]+)\] - (\d{4}-\d{2}-\d{2})/g);
+      if (!releaseSections) {
+        throw new Error('Release sections must follow format: ## [version] - YYYY-MM-DD');
+      }
+
+      console.log('✅ Changelog validation passed');
+      return true;
+    } catch (error) {
+      console.error('❌ Changelog validation failed:', error.message);
+      return false;
+    }
+  }
+}
+
+// CLI Interface
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'update';
+
+  const generator = new ChangelogGenerator();
+
+  switch (command) {
+    case 'update':
+      const version = args[1] || currentVersion;
+      const date = args[2] || new Date().toISOString().split('T')[0];
+      generator.updateChangelog(version, date);
+      break;
+
+    case 'validate':
+      generator.validateChangelog();
+      break;
+
+    case 'init':
+      // Initialize changelog if it doesn't exist
+      if (!fs.existsSync(generator.changelogPath)) {
+        fs.writeFileSync(generator.changelogPath, generator.changelog.header, 'utf8');
+        console.log('✅ Changelog initialized');
+      } else {
+        console.log('Changelog already exists');
+      }
+      break;
+
+    default:
+      console.log(`
+Usage: node generate-changelog.js [command] [options]
+
+Commands:
+  update [version] [date]    Update changelog with new version (default: current package version)
+  validate                  Validate changelog format and content
+  init                      Initialize changelog file
+
+Examples:
+  node generate-changelog.js update
+  node generate-changelog.js update 1.2.3 2024-01-15
+  node generate-changelog.js validate
+  node generate-changelog.js init
+      `);
+  }
+}
+
+main();

package/scripts/git-hooks/pre-commit.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+# Pre-commit hook for Claude Flow Novice
+# Runs validation checks before allowing commits
+
+set -e
+
+echo "🔍 Running pre-commit validation..."
+echo "======================================"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Get staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACMR)
+
+if [ -z "$STAGED_FILES" ]; then
+  echo -e "${YELLOW}⚠️  No files staged for commit${NC}"
+  exit 0
+fi
+
+# Check if npm is available
+if ! command -v npm &> /dev/null; then
+  echo -e "${RED}❌ npm not found${NC}"
+  exit 1
+fi
+
+# Run security scan on staged files
+echo ""
+echo "🔒 Security Scan..."
+if npm run security:check --silent; then
+  echo -e "${GREEN}✅ Security check passed${NC}"
+else
+  echo -e "${RED}❌ Security issues found${NC}"
+  exit 1
+fi
+
+# Run linting on staged JS/TS files
+STAGED_JS_FILES=$(echo "$STAGED_FILES" | grep -E '\.(js|ts|jsx|tsx)$' || true)
+
+if [ -n "$STAGED_JS_FILES" ]; then
+  echo ""
+  echo "📝 Linting staged files..."
+
+  if npm run lint --silent; then
+    echo -e "${GREEN}✅ Linting passed${NC}"
+  else
+    echo -e "${YELLOW}⚠️  Linting issues found (not blocking)${NC}"
+  fi
+fi
+
+# Check for hardcoded secrets in staged files
+echo ""
+echo "🔐 Checking for hardcoded secrets..."
+SECRETS_FOUND=0
+
+# Patterns to check for secrets
+declare -a SECRET_PATTERNS=(
+  "api[_-]?key\s*[:=]\s*['\"][a-zA-Z0-9]{20,}['\"]"
+  "password\s*[:=]\s*['\"][^'\"]{8,}['\"]"
+  "secret[_-]?token\s*[:=]\s*['\"][a-zA-Z0-9]{20,}['\"]"
+  "-----BEGIN (RSA )?PRIVATE KEY-----"
+  "AKIA[0-9A-Z]{16}"
+)
+
+for file in $STAGED_FILES; do
+  if [ -f "$file" ]; then
+    for pattern in "${SECRET_PATTERNS[@]}"; do
+      if grep -qE "$pattern" "$file" 2>/dev/null; then
+        echo -e "${RED}❌ Potential secret found in: $file${NC}"
+        SECRETS_FOUND=1
+      fi
+    done
+  fi
+done
+
+if [ $SECRETS_FOUND -eq 1 ]; then
+  echo -e "${RED}❌ Commit blocked: Remove hardcoded secrets${NC}"
+  exit 1
+fi
+
+echo -e "${GREEN}✅ No secrets found${NC}"
+
+# Check for large files (>1MB)
+echo ""
+echo "📦 Checking file sizes..."
+LARGE_FILES=0
+
+for file in $STAGED_FILES; do
+  if [ -f "$file" ]; then
+    FILE_SIZE=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file" 2>/dev/null || echo 0)
+    if [ $FILE_SIZE -gt 1048576 ]; then
+      echo -e "${YELLOW}⚠️  Large file detected: $file ($(($FILE_SIZE / 1024))KB)${NC}"
+      LARGE_FILES=1
+    fi
+  fi
+done
+
+if [ $LARGE_FILES -eq 1 ]; then
+  echo -e "${YELLOW}⚠️  Consider using Git LFS for large files${NC}"
+fi
+
+# Check for package.json changes
+if echo "$STAGED_FILES" | grep -q "package.json"; then
+  echo ""
+  echo "📦 package.json changed - validating..."
+
+  if node -e "JSON.parse(require('fs').readFileSync('package.json', 'utf8'))" 2>/dev/null; then
+    echo -e "${GREEN}✅ package.json is valid JSON${NC}"
+  else
+    echo -e "${RED}❌ package.json is invalid${NC}"
+    exit 1
+  fi
+
+  # Check if package-lock.json should be updated
+  if [ -f "package-lock.json" ] && ! echo "$STAGED_FILES" | grep -q "package-lock.json"; then
+    echo -e "${YELLOW}⚠️  package.json changed but package-lock.json not staged${NC}"
+    echo -e "${YELLOW}   Consider running: npm install && git add package-lock.json${NC}"
+  fi
+fi
+
+# Check for CLAUDE.md changes
+if echo "$STAGED_FILES" | grep -q "CLAUDE.md"; then
+  echo ""
+  echo "📋 CLAUDE.md changed - validating format..."
+
+  if grep -q "## 1) Critical Rules" "CLAUDE.md" && grep -q "## 2) When Agents Are Mandatory" "CLAUDE.md"; then
+    echo -e "${GREEN}✅ CLAUDE.md format valid${NC}"
+  else
+    echo -e "${RED}❌ CLAUDE.md appears to be malformed${NC}"
+    exit 1
+  fi
+fi
+
+# Final summary
+echo ""
+echo "======================================"
+echo -e "${GREEN}✅ Pre-commit validation passed${NC}"
+echo "======================================"
+
+exit 0