faf-cli 4.2.2 → 4.3.1

package/scripts/test-showcase-results.json

@@ -0,0 +1,109 @@
+{
+  "generated": "2026-02-09T01:39:39.488Z",
+  "totalRepos": 5,
+  "successCount": 0,
+  "failedCount": 5,
+  "avgImprovement": 0,
+  "categories": [
+    {
+      "name": "JavaScript/TypeScript",
+      "repos": [
+        {
+          "repo": "facebook/react",
+          "owner": "facebook",
+          "name": "react",
+          "category": "JavaScript/TypeScript",
+          "currentScore": 0,
+          "newScore": 0,
+          "improvement": 0,
+          "tier": "Failed",
+          "stack": {},
+          "projectType": "unknown",
+          "mainLanguage": "unknown",
+          "description": "",
+          "status": "failed",
+          "error": "Failed to parse output (saved to /Users/wolfejam/FAF/cli/scripts/debug-react.txt)"
+        }
+      ]
+    },
+    {
+      "name": "Python",
+      "repos": [
+        {
+          "repo": "django/django",
+          "owner": "django",
+          "name": "django",
+          "category": "Python",
+          "currentScore": 0,
+          "newScore": 0,
+          "improvement": 0,
+          "tier": "Failed",
+          "stack": {},
+          "projectType": "unknown",
+          "mainLanguage": "unknown",
+          "description": "",
+          "status": "failed",
+          "error": "Failed to parse output (saved to /Users/wolfejam/FAF/cli/scripts/debug-django.txt)"
+        }
+      ]
+    },
+    {
+      "name": "Systems/Low-level",
+      "repos": [
+        {
+          "repo": "ggml-org/whisper.cpp",
+          "owner": "ggml-org",
+          "name": "whisper.cpp",
+          "category": "Systems/Low-level",
+          "currentScore": 0,
+          "newScore": 0,
+          "improvement": 0,
+          "tier": "Failed",
+          "stack": {},
+          "projectType": "unknown",
+          "mainLanguage": "unknown",
+          "description": "",
+          "status": "failed",
+          "error": "Failed to parse output (saved to /Users/wolfejam/FAF/cli/scripts/debug-whisper.cpp.txt)"
+        },
+        {
+          "repo": "rust-lang/rust",
+          "owner": "rust-lang",
+          "name": "rust",
+          "category": "Systems/Low-level",
+          "currentScore": 0,
+          "newScore": 0,
+          "improvement": 0,
+          "tier": "Failed",
+          "stack": {},
+          "projectType": "unknown",
+          "mainLanguage": "unknown",
+          "description": "",
+          "status": "failed",
+          "error": "Failed to parse output (saved to /Users/wolfejam/FAF/cli/scripts/debug-rust.txt)"
+        }
+      ]
+    },
+    {
+      "name": "Databases",
+      "repos": [
+        {
+          "repo": "mongodb/mongo",
+          "owner": "mongodb",
+          "name": "mongo",
+          "category": "Databases",
+          "currentScore": 0,
+          "newScore": 0,
+          "improvement": 0,
+          "tier": "Failed",
+          "stack": {},
+          "projectType": "unknown",
+          "mainLanguage": "unknown",
+          "description": "",
+          "status": "failed",
+          "error": "Failed to parse output (saved to /Users/wolfejam/FAF/cli/scripts/debug-mongo.txt)"
+        }
+      ]
+    }
+  ]
+}

package/scripts/test-showcase.json

@@ -0,0 +1,32 @@
+{
+  "title": "FAF Industry Showcase - Test Run",
+  "description": "Small test of 5 diverse repos before full showcase",
+  "updated": "2026-02-08",
+  "categories": [
+    {
+      "name": "JavaScript/TypeScript",
+      "repos": [
+        "facebook/react"
+      ]
+    },
+    {
+      "name": "Python",
+      "repos": [
+        "django/django"
+      ]
+    },
+    {
+      "name": "Systems/Low-level",
+      "repos": [
+        "ggml-org/whisper.cpp",
+        "rust-lang/rust"
+      ]
+    },
+    {
+      "name": "Databases",
+      "repos": [
+        "mongodb/mongo"
+      ]
+    }
+  ]
+}

package/scripts/update-version.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+/**
+ * 🏎️ Version Update Script - Ensures all version references stay synchronized
+ * Run this BEFORE committing any version changes
+ * Usage: npm run version:update 2.8.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+
+const VERSION_PATTERN = /v?\d+\.\d+\.\d+/g;
+
+// Files that should always have the latest version
+const VERSION_FILES = [
+  {
+    path: 'package.json',
+    pattern: /"version":\s*"[\d.]+"/,
+    replacement: (version) => `"version": "${version}"`
+  },
+  {
+    path: 'src/utils/championship-style.ts',
+    patterns: [
+      {
+        pattern: /FAF CLI v\d+\.\d+\.\d+/g,
+        replacement: (version) => `FAF CLI v${version}`
+      },
+      {
+        pattern: /🏎️⚡️🏁\s+v\d+\.\d+\.\d+/g,
+        replacement: (version) => `🏎️⚡️🏁  v${version}`
+      },
+      {
+        pattern: /\(v\d+\.\d+\.\d+ [^)]+\)/g,
+        replacement: (version) => `(v${version} White Stripe Edition)`
+      }
+    ]
+  }
+];
+
+// Files that should keep their specific version references (schemas, etc.)
+const IGNORE_PATTERNS = [
+  'tests/**/*.test.ts',
+  '**/node_modules/**',
+  'dist/**',
+  '*.md' // Documentation can reference old versions
+];
+
+function updateVersion(newVersion) {
+  if (!newVersion || !newVersion.match(/^\d+\.\d+\.\d+$/)) {
+    console.error('❌ Invalid version format. Use: X.Y.Z (e.g., 2.8.0)');
+    process.exit(1);
+  }
+
+  console.log(`🏎️ Updating all version references to v${newVersion}...`);
+  
+  let updatedFiles = [];
+  
+  VERSION_FILES.forEach(file => {
+    const filePath = path.join(__dirname, '..', file.path);
+    
+    if (!fs.existsSync(filePath)) {
+      console.warn(`⚠️  File not found: ${file.path}`);
+      return;
+    }
+    
+    let content = fs.readFileSync(filePath, 'utf8');
+    let modified = false;
+    
+    if (file.pattern) {
+      // Single pattern
+      const newContent = content.replace(file.pattern, file.replacement(newVersion));
+      if (newContent !== content) {
+        content = newContent;
+        modified = true;
+      }
+    } else if (file.patterns) {
+      // Multiple patterns
+      file.patterns.forEach(patternObj => {
+        const newContent = content.replace(patternObj.pattern, patternObj.replacement(newVersion));
+        if (newContent !== content) {
+          content = newContent;
+          modified = true;
+        }
+      });
+    }
+    
+    if (modified) {
+      fs.writeFileSync(filePath, content);
+      updatedFiles.push(file.path);
+      console.log(`✅ Updated: ${file.path}`);
+    }
+  });
+  
+  // Check for any remaining old versions in critical files
+  console.log('\n🔍 Checking for stray version references...');
+  
+  const criticalFiles = glob.sync('src/**/*.ts', {
+    ignore: IGNORE_PATTERNS,
+    cwd: path.join(__dirname, '..')
+  });
+  
+  let strayVersions = [];
+  
+  criticalFiles.forEach(file => {
+    const content = fs.readFileSync(path.join(__dirname, '..', file), 'utf8');
+    const matches = content.match(/v2\.\d+\.\d+/g);
+    
+    if (matches) {
+      const nonCurrentVersions = matches.filter(v => {
+        const version = v.replace('v', '');
+        return version !== newVersion && !isSchemaVersion(version);
+      });
+      
+      if (nonCurrentVersions.length > 0) {
+        strayVersions.push({
+          file,
+          versions: [...new Set(nonCurrentVersions)]
+        });
+      }
+    }
+  });
+  
+  if (strayVersions.length > 0) {
+    console.log('\n⚠️  Found stray version references (review these manually):');
+    strayVersions.forEach(item => {
+      console.log(`   ${item.file}: ${item.versions.join(', ')}`);
+    });
+  } else {
+    console.log('✅ No stray version references found!');
+  }
+  
+  console.log(`\n🏁 Version update complete! Now at v${newVersion}`);
+  console.log('📝 Remember to:');
+  console.log('   1. Run: npm run build');
+  console.log('   2. Test: npm test');
+  console.log('   3. Commit with message: "chore: bump version to v' + newVersion + '"');
+}
+
+function isSchemaVersion(version) {
+  // These are schema versions that shouldn't change automatically
+  const schemaVersions = ['2.4.0', '2.5.0'];
+  return schemaVersions.includes(version);
+}
+
+// Get version from command line
+const newVersion = process.argv[2];
+updateVersion(newVersion);

package/scripts/verify-build.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * 🏎️ Build Verification Script
+ * Prevents stale builds from reaching npm
+ * 
+ * Checks:
+ * 1. All source commands exist in dist/
+ * 2. Dist is newer than source
+ * 3. All command imports resolve
+ * 4. Native parser has all registered commands
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Colors for output
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  orange: '\x1b[38;5;208m'
+};
+
+function log(message, color = 'reset') {
+  console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+function error(message) {
+  log(`❌ ${message}`, 'red');
+}
+
+function success(message) {
+  log(`✅ ${message}`, 'green');
+}
+
+function warning(message) {
+  log(`⚠️  ${message}`, 'yellow');
+}
+
+function info(message) {
+  log(`ℹ️  ${message}`, 'cyan');
+}
+
+// Get root directory
+const rootDir = path.join(__dirname, '..');
+const srcDir = path.join(rootDir, 'src');
+const distDir = path.join(rootDir, 'dist');
+
+let hasErrors = false;
+
+/**
+ * Check 1: Verify dist directory exists and is built
+ */
+function checkDistExists() {
+  info('Check 1: Verifying dist/ directory exists...');
+  
+  if (!fs.existsSync(distDir)) {
+    error('dist/ directory does not exist!');
+    error('Run: npm run build');
+    hasErrors = true;
+    return false;
+  }
+  
+  if (!fs.existsSync(path.join(distDir, 'cli.js'))) {
+    error('dist/cli.js does not exist!');
+    error('Run: npm run build');
+    hasErrors = true;
+    return false;
+  }
+  
+  success('dist/ directory exists');
+  return true;
+}
+
+/**
+ * Check 2: Extract all command names from cli.ts
+ */
+function extractCommandsFromSource() {
+  info('Check 2: Extracting registered commands from src/cli.ts...');
+  
+  const cliPath = path.join(srcDir, 'cli.ts');
+  if (!fs.existsSync(cliPath)) {
+    error('src/cli.ts not found!');
+    hasErrors = true;
+    return [];
+  }
+  
+  const content = fs.readFileSync(cliPath, 'utf8');
+  
+  // Extract command registrations: program.command('name')
+  const commandRegex = /program\s*\.command\('([^']+)(?:\s+\[)?/g;
+  const commands = [];
+  let match;
+  
+  while ((match = commandRegex.exec(content)) !== null) {
+    const commandName = match[1];
+    commands.push(commandName);
+  }
+  
+  // Also check for .command() with template strings (rare but possible)
+  const templateCommandRegex = /program\s*\.command\(`([^`]+)(?:\s+\[)?/g;
+  while ((match = templateCommandRegex.exec(content)) !== null) {
+    const commandName = match[1];
+    commands.push(commandName);
+  }
+  
+  // Remove duplicates and sort
+  const uniqueCommands = [...new Set(commands)].sort();
+  
+  success(`Found ${uniqueCommands.length} registered commands`);
+  uniqueCommands.forEach(cmd => {
+    console.log(`  • ${cmd}`);
+  });
+  
+  return uniqueCommands;
+}
+
+/**
+ * Check 3: Verify all commands exist in dist/commands/
+ */
+function verifyCommandsInDist(commands) {
+  info('Check 3: Verifying commands exist in dist/commands/...');
+  
+  const distCommandsDir = path.join(distDir, 'commands');
+  
+  if (!fs.existsSync(distCommandsDir)) {
+    error('dist/commands/ directory does not exist!');
+    hasErrors = true;
+    return false;
+  }
+  
+  let allExist = true;
+  
+  for (const cmd of commands) {
+    // Skip wildcard and special commands
+    if (cmd === '*' || cmd.includes('$')) continue;
+    
+    const jsPath = path.join(distCommandsDir, `${cmd}.js`);
+    const tsPath = path.join(srcDir, 'commands', `${cmd}.ts`);
+    
+    // Check if source exists first
+    if (!fs.existsSync(tsPath)) {
+      warning(`Source not found: src/commands/${cmd}.ts (inline command?)`);
+      continue;
+    }
+    
+    // Check if built version exists
+    if (!fs.existsSync(jsPath)) {
+      error(`Built command missing: dist/commands/${cmd}.js`);
+      error(`Source exists at: src/commands/${cmd}.ts`);
+      hasErrors = true;
+      allExist = false;
+    } else {
+      success(`${cmd}.js exists in dist/commands/`);
+    }
+  }
+  
+  return allExist;
+}
+
+/**
+ * Check 4: Verify dist is newer than source
+ */
+function checkDistFreshness() {
+  info('Check 4: Verifying dist/ is up-to-date...');
+  
+  const cliSrc = path.join(srcDir, 'cli.ts');
+  const cliDist = path.join(distDir, 'cli.js');
+  
+  if (!fs.existsSync(cliDist)) {
+    error('dist/cli.js does not exist!');
+    hasErrors = true;
+    return false;
+  }
+  
+  const srcStat = fs.statSync(cliSrc);
+  const distStat = fs.statSync(cliDist);
+  
+  if (srcStat.mtime > distStat.mtime) {
+    error('src/cli.ts is newer than dist/cli.js!');
+    error('Source modified: ' + srcStat.mtime.toISOString());
+    error('Build created: ' + distStat.mtime.toISOString());
+    error('Run: npm run build');
+    hasErrors = true;
+    return false;
+  }
+  
+  success('dist/cli.js is up-to-date');
+  
+  // Also check commands directory
+  const srcCommandsDir = path.join(srcDir, 'commands');
+  const distCommandsDir = path.join(distDir, 'commands');
+  
+  if (!fs.existsSync(srcCommandsDir)) {
+    warning('src/commands/ directory not found');
+    return true;
+  }
+  
+  const srcFiles = fs.readdirSync(srcCommandsDir)
+    .filter(f => f.endsWith('.ts'));
+  
+  let staleFound = false;
+  
+  for (const file of srcFiles) {
+    const srcPath = path.join(srcCommandsDir, file);
+    const distPath = path.join(distCommandsDir, file.replace('.ts', '.js'));
+    
+    if (!fs.existsSync(distPath)) {
+      warning(`${file} not built yet`);
+      continue;
+    }
+    
+    const srcStat = fs.statSync(srcPath);
+    const distStat = fs.statSync(distPath);
+    
+    if (srcStat.mtime > distStat.mtime) {
+      error(`src/commands/${file} is newer than built version!`);
+      staleFound = true;
+      hasErrors = true;
+    }
+  }
+  
+  if (staleFound) {
+    error('Stale build detected! Run: npm run build');
+    return false;
+  }
+  
+  success('All dist/commands/ files are up-to-date');
+  return true;
+}
+
+/**
+ * Check 5: Verify package.json version matches published
+ */
+function checkVersionSync() {
+  info('Check 5: Checking version synchronization...');
+  
+  const packagePath = path.join(rootDir, 'package.json');
+  const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  
+  const currentVersion = packageData.version;
+  success(`Current package.json version: ${currentVersion}`);
+  
+  // Note: We can't check npm registry without network call
+  // Just warn the user to verify
+  warning('Remember to verify this matches your last published version');
+  warning('Check with: npm view faf-cli version');
+  
+  return true;
+}
+
+/**
+ * Check 6: Verify critical imports exist
+ */
+function checkCriticalImports() {
+  info('Check 6: Verifying critical imports...');
+  
+  const criticalPaths = [
+    'dist/commands/index.js',
+    'dist/commands/init.js', 
+    'dist/commands/score.js',
+    'dist/commands/status.js',
+    'dist/utils/native-cli-parser.js',
+    'dist/fix-once/commander.js',
+    'dist/fix-once/colors.js'
+  ];
+  
+  let allExist = true;
+  
+  for (const relativePath of criticalPaths) {
+    const fullPath = path.join(rootDir, relativePath);
+    if (!fs.existsSync(fullPath)) {
+      error(`Critical file missing: ${relativePath}`);
+      hasErrors = true;
+      allExist = false;
+    } else {
+      success(`${relativePath} ✓`);
+    }
+  }
+  
+  return allExist;
+}
+
+/**
+ * Main verification
+ */
+function main() {
+  log('\n🏎️  FAF Build Verification - Championship Grade', 'cyan');
+  log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n', 'cyan');
+  
+  // Run all checks
+  const distExists = checkDistExists();
+  console.log();
+  
+  if (!distExists) {
+    log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'red');
+    error('Build verification FAILED!');
+    error('Fix the errors above and try again');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n', 'red');
+    process.exit(1);
+  }
+  
+  const commands = extractCommandsFromSource();
+  console.log();
+  
+  verifyCommandsInDist(commands);
+  console.log();
+  
+  checkDistFreshness();
+  console.log();
+  
+  checkCriticalImports();
+  console.log();
+  
+  checkVersionSync();
+  console.log();
+  
+  // Final result
+  if (hasErrors) {
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'red');
+    error('Build verification FAILED! ❌');
+    error('Fix the errors above before publishing');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n', 'red');
+    process.exit(1);
+  } else {
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'green');
+    success('Build verification PASSED! ✅');
+    success('Safe to publish to npm');
+    log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n', 'green');
+    
+    // Helpful next steps
+    info('Next steps:');
+    console.log('  1. npm version patch  # Bump to 2.4.15');
+    console.log('  2. npm publish        # Push to npm');
+    console.log('  3. npm install -g faf-cli@latest  # Update global');
+    console.log('  4. faf index          # Test it works!\n');
+  }
+}
+
+// Run verification
+main();

package/scripts/version-check.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * 🎯 VERSION SANITY CHECKER
+ * Never get surprised by version conflicts again!
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('🔍 VERSION CHECK - No more surprises!\n');
+
+// 1. Get local version
+const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
+const localVersion = packageJson.version;
+
+// 2. Get npm registry version
+let npmVersion;
+try {
+  npmVersion = execSync('npm view faf-cli version', { encoding: 'utf8' }).trim();
+} catch (e) {
+  console.log('⚠️  Package not found on npm (first publish?)');
+  npmVersion = '0.0.0';
+}
+
+// 3. Get all published versions
+let allVersions;
+try {
+  allVersions = JSON.parse(execSync('npm view faf-cli versions --json', { encoding: 'utf8' }));
+} catch (e) {
+  allVersions = [];
+}
+
+// 4. THE TRUTH
+console.log('📊 VERSION REALITY CHECK:');
+console.log('─────────────────────────');
+console.log(`📁 LOCAL (package.json):  v${localVersion}`);
+console.log(`☁️  NPM LATEST:           v${npmVersion}`);
+console.log(`📚 LAST 5 PUBLISHED:     ${allVersions.slice(-5).join(', ')}`);
+console.log('');
+
+// 5. CONFLICT DETECTION
+let hasConflict = false;
+if (localVersion === npmVersion) {
+  console.log('❌ CONFLICT: Local version matches npm!');
+  console.log('   You need to bump version before publishing:');
+  console.log('   → npm version patch');
+  console.log('');
+  hasConflict = true;
+} else if (allVersions.includes(localVersion)) {
+  console.log('❌ CONFLICT: Version already exists on npm!');
+  console.log(`   v${localVersion} was already published`);
+  console.log('   → npm version patch');
+  console.log('');
+  hasConflict = true;
+} else {
+  console.log('✅ CLEAR: Ready to publish!');
+  console.log(`   Will publish as v${localVersion}`);
+  console.log('');
+}
+
+// 6. SUGGESTED NEXT VERSION
+const parts = npmVersion.split('.');
+const suggestedPatch = `${parts[0]}.${parts[1]}.${parseInt(parts[2]) + 1}`;
+const suggestedMinor = `${parts[0]}.${parseInt(parts[1]) + 1}.0`;
+const suggestedMajor = `${parseInt(parts[0]) + 1}.0.0`;
+
+console.log('📈 SUGGESTED VERSIONS:');
+console.log(`   Patch:  v${suggestedPatch} (bug fixes)`)
+console.log(`   Minor:  v${suggestedMinor} (new features)`);
+console.log(`   Major:  v${suggestedMajor} (breaking changes)`);
+console.log('');
+console.log('💡 Run: npm version patch|minor|major');
+
+// Exit with error if conflict
+if (hasConflict) {
+  process.exit(1);
+}