faf-cli 4.3.0 → 4.3.1

package/scripts/run-test-showcase.ts

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+/**
+ * Test Showcase Runner (5 repos)
+ * Tests the showcase runner on a small sample before running full 70 repos
+ */
+
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import * as yaml from 'yaml';
+
+interface ShowcaseData {
+  title: string;
+  description: string;
+  updated: string;
+  categories: Array<{
+    name: string;
+    repos: string[];
+  }>;
+}
+
+interface RepoResult {
+  repo: string;
+  owner: string;
+  name: string;
+  category: string;
+  currentScore: number;
+  newScore: number;
+  improvement: number;
+  tier: string;
+  stack: {
+    frontend?: string;
+    backend?: string;
+    runtime?: string;
+    build?: string;
+    database?: string;
+    hosting?: string;
+  };
+  projectType: string;
+  mainLanguage: string;
+  description: string;
+  status: 'success' | 'failed' | 'rate-limited';
+  error?: string;
+}
+
+interface ShowcaseResults {
+  generated: string;
+  totalRepos: number;
+  successCount: number;
+  failedCount: number;
+  avgImprovement: number;
+  categories: Array<{
+    name: string;
+    repos: RepoResult[];
+  }>;
+}
+
+function parseFafGitOutput(output: string): { currentScore: number; newScore: number; improvement: number; tier: string } | null {
+  // Strip ANSI color codes first
+  // eslint-disable-next-line no-control-regex
+  const cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+
+  // v4.3.0 format (after stripping colors):
+  // Current:  No .faf file ⚠️
+  // With FAF: 100% 🏆 Trophy
+
+  const currentMatch = cleanOutput.match(/Current:\s+No \.faf file/);
+  const withFafMatch = cleanOutput.match(/With FAF:\s+(\d+)%\s+([🏆🥇🥈🥉🟢🟡🔴🤍⚠️]+)\s*(\w+)?/);
+
+  if (!withFafMatch) {
+    return null;
+  }
+
+  const currentScore = currentMatch ? 0 : 0; // Always 0 for "No .faf file"
+  const newScore = parseInt(withFafMatch[1]);
+  const tier = withFafMatch[3] || 'Unknown';
+  const improvement = newScore - currentScore;
+
+  return {
+    currentScore,
+    newScore,
+    improvement,
+    tier
+  };
+}
+
+function extractStackFromFaf(fafPath: string): any {
+  try {
+    const content = readFileSync(fafPath, 'utf-8');
+    const parsed = yaml.parse(content);
+
+    return {
+      stack: {
+        frontend: parsed.stack?.frontend !== 'slotignored' ? parsed.stack?.frontend : undefined,
+        backend: parsed.stack?.backend !== 'slotignored' ? parsed.stack?.backend : undefined,
+        runtime: parsed.stack?.runtime !== 'slotignored' ? parsed.stack?.runtime : undefined,
+        build: parsed.stack?.build !== 'slotignored' ? parsed.stack?.build : undefined,
+        database: parsed.stack?.database !== 'slotignored' ? parsed.stack?.database : undefined,
+        hosting: parsed.stack?.hosting !== 'slotignored' ? parsed.stack?.hosting : undefined,
+      },
+      projectType: parsed.project?.type || 'unknown',
+      mainLanguage: parsed.project?.main_language || 'unknown',
+      description: parsed.project?.goal || parsed.metadata?.description || ''
+    };
+  } catch (e) {
+    return {
+      stack: {},
+      projectType: 'unknown',
+      mainLanguage: 'unknown',
+      description: ''
+    };
+  }
+}
+
+async function runTestShowcase() {
+  console.log('🏎️  FAF Test Showcase Runner (5 repos)\n');
+
+  // Read test showcase data
+  const showcaseData: ShowcaseData = JSON.parse(
+    readFileSync(join(__dirname, 'test-showcase.json'), 'utf-8')
+  );
+
+  const results: ShowcaseResults = {
+    generated: new Date().toISOString(),
+    totalRepos: 0,
+    successCount: 0,
+    failedCount: 0,
+    avgImprovement: 0,
+    categories: []
+  };
+
+  let totalImprovement = 0;
+
+  for (const category of showcaseData.categories) {
+    console.log(`\n📁 Category: ${category.name}`);
+    console.log(`   Testing ${category.repos.length} repos...\n`);
+
+    const categoryResults: RepoResult[] = [];
+
+    for (const repo of category.repos) {
+      results.totalRepos++;
+      const [owner, name] = repo.split('/');
+
+      process.stdout.write(`   ⚡ ${repo}... `);
+
+      try {
+        // Run faf git (use local build to avoid bin name collision with bun-sticky)
+        const output = execSync(
+          `node ${join(__dirname, '../dist/cli.js')} git ${repo}`,
+          {
+            encoding: 'utf-8',
+            timeout: 30000,
+            stdio: 'pipe'
+          }
+        );
+
+        // Parse output
+        const scores = parseFafGitOutput(output);
+
+        if (!scores) {
+          // Debug: save output to file
+          const debugPath = join(__dirname, `debug-${name}.txt`);
+          writeFileSync(debugPath, output);
+          throw new Error(`Failed to parse output (saved to ${debugPath})`);
+        }
+
+        // Extract stack from generated .faf file
+        const fafPath = join(process.cwd(), `${name}.faf`);
+        const fafData = extractStackFromFaf(fafPath);
+
+        const result: RepoResult = {
+          repo,
+          owner,
+          name,
+          category: category.name,
+          currentScore: scores.currentScore,
+          newScore: scores.newScore,
+          improvement: scores.improvement,
+          tier: scores.tier,
+          stack: fafData.stack,
+          projectType: fafData.projectType,
+          mainLanguage: fafData.mainLanguage,
+          description: fafData.description,
+          status: 'success'
+        };
+
+        categoryResults.push(result);
+        results.successCount++;
+        totalImprovement += scores.improvement;
+
+        console.log(`✅ ${scores.currentScore}% → ${scores.newScore}% (+${scores.improvement})`);
+
+      } catch (error: any) {
+        results.failedCount++;
+
+        const result: RepoResult = {
+          repo,
+          owner,
+          name,
+          category: category.name,
+          currentScore: 0,
+          newScore: 0,
+          improvement: 0,
+          tier: 'Failed',
+          stack: {},
+          projectType: 'unknown',
+          mainLanguage: 'unknown',
+          description: '',
+          status: error.message?.includes('rate limit') ? 'rate-limited' : 'failed',
+          error: error.message
+        };
+
+        categoryResults.push(result);
+        console.log(`❌ ${error.message.split('\n')[0]}`);
+      }
+
+      // Rate limit protection (1 second between requests)
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    results.categories.push({
+      name: category.name,
+      repos: categoryResults
+    });
+  }
+
+  // Calculate average improvement
+  results.avgImprovement = results.successCount > 0
+    ? Math.round(totalImprovement / results.successCount)
+    : 0;
+
+  // Save results
+  const outputPath = join(__dirname, 'test-showcase-results.json');
+  writeFileSync(outputPath, JSON.stringify(results, null, 2));
+
+  console.log(`\n\n🏆 Test Showcase Complete!\n`);
+  console.log(`   Total Repos: ${results.totalRepos}`);
+  console.log(`   ✅ Success: ${results.successCount}`);
+  console.log(`   ❌ Failed: ${results.failedCount}`);
+  console.log(`   📈 Avg Improvement: +${results.avgImprovement} points\n`);
+  console.log(`📄 Results saved to: ${outputPath}\n`);
+}
+
+runTestShowcase().catch(console.error);

package/scripts/setup-github-watch.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# 🩵 Setup GitHub Discussions Watching for FAF
+
+echo "🩵 Setting up GitHub Discussions alerts for FAF..."
+echo ""
+
+# Check if gh is installed
+if ! command -v gh &> /dev/null; then
+    echo "❌ GitHub CLI (gh) is not installed"
+    echo "Install with: brew install gh"
+    exit 1
+fi
+
+# Check authentication
+if ! gh auth status &> /dev/null; then
+    echo "❌ Not authenticated with GitHub"
+    echo "Run: gh auth login"
+    exit 1
+fi
+
+echo "✅ GitHub CLI authenticated"
+
+# Watch the repository
+echo "📺 Watching FAF repository for activity..."
+gh api -X PUT repos/Wolfe-Jam/faf/subscription \
+    --field subscribed=true \
+    --field ignored=false 2>/dev/null && echo "✅ Subscribed to repository notifications"
+
+# Enable web notifications for discussions
+echo "🔔 Enabling discussion notifications..."
+gh api -X PUT repos/Wolfe-Jam/faf/notifications \
+    --field discussions=true 2>/dev/null || echo "ℹ️  Notifications API not available (normal)"
+
+echo ""
+echo "🩵 Setup complete! You can now:"
+echo "  1. Run ./scripts/watch-discussions.sh to monitor in terminal"
+echo "  2. Check https://github.com/Wolfe-Jam/faf/discussions for activity"
+echo "  3. View notifications at https://github.com/notifications"
+echo ""
+echo "💡 For best results, also enable notifications in GitHub web settings:"
+echo "   https://github.com/settings/notifications"
+echo ""
+echo "Thank you for engaging with the FAF community! 🩵⚡"

package/scripts/sync-version.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * Sync version from package.json to project.faf
+ * Run: npm run sync-version
+ * Auto-runs on: npm version (via "version" lifecycle hook)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const projectFafPath = path.join(__dirname, '..', 'project.faf');
+
+try {
+  // Read version from package.json
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+  const version = packageJson.version;
+
+  // Read project.faf
+  let projectFaf = fs.readFileSync(projectFafPath, 'utf-8');
+
+  // Update version field
+  projectFaf = projectFaf.replace(
+    /^(\s*version:\s*).+$/m,
+    `$1${version}`
+  );
+
+  // Write back
+  fs.writeFileSync(projectFafPath, projectFaf);
+
+  console.log(`Synced project.faf version to ${version}`);
+} catch (error) {
+  console.error('Failed to sync version:', error.message);
+  process.exit(1);
+}

package/scripts/test-integration-detection.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env ts-node
+/**
+ * Test Integration Detection System
+ *
+ * Tests FAF Family detectors on real projects
+ */
+
+import { integrationRegistry } from '../src/family/registry';
+import { resolve } from 'path';
+
+async function testProject(projectPath: string, projectName: string) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`🔍 Testing: ${projectName}`);
+  console.log(`📁 Path: ${projectPath}`);
+  console.log(`${'='.repeat(60)}\n`);
+
+  try {
+    // Detect all integrations
+    const detected = await integrationRegistry.detectAll(projectPath);
+
+    if (detected.length === 0) {
+      console.log('❌ No integrations detected\n');
+      return;
+    }
+
+    console.log(`✅ Detected ${detected.length} integration(s):\n`);
+
+    // Show each detected integration
+    detected.forEach((integration, index) => {
+      const emoji = {
+        trophy: '🏆',
+        gold: '🥇',
+        silver: '🥈',
+        bronze: '🥉',
+      }[integration.tier] || '⚪';
+
+      console.log(`${index + 1}. ${emoji} ${integration.displayName}`);
+      console.log(`   Tier: ${integration.tier} (${integration.qualityScore} quality score)`);
+      console.log(`   Weekly adoption: ${integration.weeklyAdoption.toLocaleString()} developers`);
+      console.log(`   MCP servers: ${integration.mcpServers.join(', ')}`);
+      console.log(`   Context slots: ${integration.contextContribution.join(', ')}`);
+      console.log('');
+    });
+
+    // Generate combined context
+    console.log('📊 Generating combined .faf context...\n');
+    const context = await integrationRegistry.generateContext(projectPath);
+
+    console.log('Generated Context:');
+    console.log(JSON.stringify(context, null, 2));
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error testing project:', error);
+  }
+}
+
+async function main() {
+  console.log('🏆 FAF Integration Detection System - Test Suite\n');
+  console.log('Championship Standard: Auto-detect stacks and generate optimized .faf context\n');
+
+  const testProjects = [
+    {
+      name: 'faf-cli (this project)',
+      path: resolve(__dirname, '..'),
+    },
+    {
+      name: 'claude-faf-mcp',
+      path: resolve(__dirname, '../../claude-faf-mcp'),
+    },
+  ];
+
+  for (const project of testProjects) {
+    await testProject(project.path, project.name);
+  }
+
+  // Show registry stats
+  console.log(`\n${'='.repeat(60)}`);
+  console.log('📈 Integration Registry Statistics');
+  console.log(`${'='.repeat(60)}\n`);
+
+  const stats = integrationRegistry.getStats();
+  console.log(`Total integrations: ${stats.total}`);
+  console.log(`Total weekly adoption: ${stats.totalWeeklyAdoption.toLocaleString()} developers`);
+  console.log('\nBy tier:');
+  Object.entries(stats.byTier).forEach(([tier, count]) => {
+    console.log(`  ${tier}: ${count}`);
+  });
+
+  console.log('\n🏁 Test suite complete!');
+}
+
+main().catch(console.error);

package/scripts/test-integration-simple.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Test Integration Detection System (Simple JavaScript version)
+ *
+ * Tests FAF Family detectors on real projects
+ */
+
+const { integrationRegistry } = require('../dist/family/registry.js');
+const { resolve } = require('path');
+
+async function testProject(projectPath, projectName) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`🔍 Testing: ${projectName}`);
+  console.log(`📁 Path: ${projectPath}`);
+  console.log(`${'='.repeat(60)}\n`);
+
+  try {
+    // Detect all integrations
+    const detected = await integrationRegistry.detectAll(projectPath);
+
+    if (detected.length === 0) {
+      console.log('❌ No integrations detected\n');
+      return;
+    }
+
+    console.log(`✅ Detected ${detected.length} integration(s):\n`);
+
+    // Show each detected integration
+    detected.forEach((integration, index) => {
+      const emoji = {
+        trophy: '🏆',
+        gold: '🥇',
+        silver: '🥈',
+        bronze: '🥉',
+      }[integration.tier] || '⚪';
+
+      console.log(`${index + 1}. ${emoji} ${integration.displayName}`);
+      console.log(`   Tier: ${integration.tier} (${integration.qualityScore} quality score)`);
+      console.log(`   Weekly adoption: ${integration.weeklyAdoption.toLocaleString()} developers`);
+      console.log(`   MCP servers: ${integration.mcpServers.join(', ')}`);
+      console.log(`   Context slots: ${integration.contextContribution.join(', ')}`);
+      console.log('');
+    });
+
+    // Generate combined context
+    console.log('📊 Generating combined .faf context...\n');
+    const context = await integrationRegistry.generateContext(projectPath);
+
+    console.log('Generated Context:');
+    console.log(JSON.stringify(context, null, 2));
+    console.log('');
+
+  } catch (error) {
+    console.error('❌ Error testing project:', error.message);
+  }
+}
+
+async function main() {
+  console.log('🏆 FAF Integration Detection System - Test Suite\n');
+  console.log('Championship Standard: Auto-detect stacks and generate optimized .faf context\n');
+
+  const testProjects = [
+    {
+      name: 'faf-cli (this project)',
+      path: resolve(__dirname, '..'),
+    },
+    {
+      name: 'claude-faf-mcp',
+      path: resolve(__dirname, '../../claude-faf-mcp'),
+    },
+  ];
+
+  for (const project of testProjects) {
+    await testProject(project.path, project.name);
+  }
+
+  // Show registry stats
+  console.log(`\n${'='.repeat(60)}`);
+  console.log('📈 Integration Registry Statistics');
+  console.log(`${'='.repeat(60)}\n`);
+
+  const stats = integrationRegistry.getStats();
+  console.log(`Total integrations: ${stats.total}`);
+  console.log(`Total weekly adoption: ${stats.totalWeeklyAdoption.toLocaleString()} developers`);
+  console.log('\nBy tier:');
+  Object.entries(stats.byTier).forEach(([tier, count]) => {
+    console.log(`  ${tier}: ${count}`);
+  });
+
+  console.log('\n🏁 Test suite complete!');
+}
+
+main().catch(console.error);

package/scripts/test-medal-progression.sh

@@ -0,0 +1,143 @@
+#!/bin/bash
+
+##
+# 🏁 WJTC Medal Progression Visual Test
+# Manual verification of championship medal display
+#
+# Philosophy: "We break things so others never even know they were ever broken"
+##
+
+set -e
+
+echo "🏎️⚡️ WJTC MEDAL PROGRESSION TEST - Championship Visual Verification"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+# Test scores covering all medal tiers
+TEST_SCORES=(
+  "0:🔴 Stop - Needs work"
+  "48:🔴 Stop - Needs work (near threshold)"
+  "55:🟡 Caution - Getting ready"
+  "62:🟡 Caution - Getting ready (mid-range)"
+  "70:🟢 GO! - Ready for Target 1"
+  "77:🟢 GO! - Ready for Target 1 (mid-range)"
+  "85:🥉 Target 1 - Bronze"
+  "88:🥉 Target 1 - Bronze (mid-range)"
+  "95:🥈 Target 2 - Silver"
+  "96:🥈 Target 2 - Silver (mid-range)"
+  "99:🥇 Gold"
+  "100:🏆 Trophy - Championship"
+)
+
+# Create temp directory
+TEST_DIR="/tmp/faf-medal-test-$$"
+mkdir -p "$TEST_DIR"
+
+echo "📁 Test directory: $TEST_DIR"
+echo ""
+
+# Function to create a test .faf file with specific score
+create_test_faf() {
+  local score=$1
+  local label=$2
+  local dir="$TEST_DIR/project-$score"
+
+  mkdir -p "$dir"
+
+  # Calculate filled slots based on score
+  # 21 total slots, so score% = (filled/21) * 100
+  local filled_slots=$(echo "scale=0; ($score * 21) / 100" | bc)
+
+  # Create minimal .faf file
+  cat > "$dir/.faf" <<EOF
+faf_version: "2.4.0"
+ai_scoring_system: "2025-08-30"
+ai_score: "${score}%"
+ai_confidence: $([ $score -ge 70 ] && echo "HIGH" || echo "LOW")
+project:
+  name: "Test Project $score%"
+  goal: "Testing medal display at $score%"
+  main_language: "TypeScript"
+stack:
+  frontend: "React"
+  backend: "Node.js"
+  database: "PostgreSQL"
+human_context:
+  who: "Developers"
+  what: "Test project for medal validation"
+  why: "WJTC championship testing"
+  where: "Testing environment"
+  when: "Now"
+  how: "Manual test script"
+ai_instructions:
+  priority_order:
+    - "Test medal display"
+  working_style:
+    code_first: true
+context_quality:
+  slots_filled: "$filled_slots/21 (${score}%)"
+  ai_confidence: $([ $score -ge 70 ] && echo "HIGH" || echo "LOW")
+EOF
+
+  echo "$dir"
+}
+
+echo "🔨 Creating test projects..."
+echo ""
+
+# Create all test projects
+TEST_PROJECTS=()
+for entry in "${TEST_SCORES[@]}"; do
+  score="${entry%%:*}"
+  label="${entry#*:}"
+
+  project_dir=$(create_test_faf "$score" "$label")
+  TEST_PROJECTS+=("$score:$label:$project_dir")
+
+  echo "  ✅ Created: $score% - $label"
+done
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🏁 RUNNING VISUAL VERIFICATION TESTS"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+# Run faf show on each project
+for entry in "${TEST_PROJECTS[@]}"; do
+  score="${entry%%:*}"
+  rest="${entry#*:}"
+  label="${rest%%:*}"
+  project_dir="${rest#*:}"
+
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo "📊 Testing: $score% - $label"
+  echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+  echo ""
+
+  # Run faf show
+  npx ts-node src/cli.ts show "$project_dir"
+
+  echo ""
+  echo "✅ Verify: Medal matches expected '$label'"
+  echo ""
+  read -p "Press Enter to continue to next test..."
+  echo ""
+done
+
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🏆 WJTC MEDAL PROGRESSION TEST COMPLETE"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+echo "📋 Manual Verification Checklist:"
+echo ""
+echo "  [ ] All medals display correctly"
+echo "  [ ] Traffic light progression is clear (🔴→🟡→🟢)"
+echo "  [ ] Medal progression is clear (🥉→🥈→🥇→🏆)"
+echo "  [ ] No medals shown at wrong scores"
+echo "  [ ] Colors match medal tier appropriately"
+echo ""
+echo "🧹 Cleanup: rm -rf $TEST_DIR"
+echo ""
+echo "Status: ${GREEN}READY FOR WJTC REPORT${NC}"
+echo ""