flagshark 1.0.0 → 1.0.1

package/README.md

@@ -83,6 +83,8 @@ jobs:
         with:
           fetch-depth: 0  # Required for git blame age detection
       - uses: FlagShark/flagshark@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 ```
 
 ### Action Inputs
@@ -93,9 +95,23 @@ jobs:
 | `threshold` | `6` | Staleness threshold in months |
 | `fail-threshold` | `0` | Health score below which the check fails (0 = never fail) |
 
+### Scan Modes
+
+**`scan: changed`** (default) scans only files modified in the PR. Fast, focused on what you're changing.
+
+**`scan: full`** scans the entire repository. Shows your full flag health score and finds stale flags everywhere, not just in changed files. Great for seeing the big picture:
+
+```yaml
+      - uses: FlagShark/flagshark@v1
+        with:
+          scan: full
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+```
+
 ### What the Action does
 
-On every PR, FlagShark comments with a table of stale flags found in the changed files:
+On every PR, FlagShark comments with a table of stale flags:
 
 > ### 🦈 FlagShark found 3 stale flags
 >
@@ -154,22 +170,6 @@ A flag is marked stale if **any** of these signals fires:
 
 FlagShark only checks files that actually import a flag SDK. A function called `isEnabled()` in a file that doesn't import LaunchDarkly/Unleash/etc. won't be flagged. This prevents false positives.
 
-## Configuration
-
-### `.flagsharkignore`
-
-Exclude files or specific flags:
-
-```
-# Glob patterns for files
-test/**
-fixtures/**
-
-# Specific flag names (prefix with flag:)
-flag:PERMANENT_ADMIN_OVERRIDE
-flag:MAINTENANCE_MODE
-```
-
 ## License
 
 MIT

package/action/index.ts

@@ -1,15 +1,8 @@
 /**
  * GitHub Action entry point for FlagShark.
  *
- * This is a thin wrapper around the same detection engine used by the CLI.
- * It runs the scan, posts a PR comment with results, and sets a status check.
- *
- * Architecture:
- *   action/index.ts (this file)
- *       │
- *       ├─ Runs the same scanner + staleness logic as the CLI
- *       ├─ Posts a PR comment with markdown table
- *       └─ Sets a GitHub check status (pass/fail)
+ * Scans a repo for stale feature flags, posts a rich PR comment,
+ * writes a GitHub Actions job summary, and sets a status check.
  */
 
 import { readFileSync, readdirSync, statSync } from 'node:fs'
@@ -27,22 +20,22 @@ import type { StaleFlag } from '../src/staleness.js'
 
 const COMMENT_MARKER = '<!-- flagshark-action -->'
 const SKIP_DIRS = new Set([
-  'node_modules',
-  'vendor',
-  '.git',
-  'dist',
-  'build',
-  'coverage',
-  '__pycache__',
-  '.next',
-  '.turbo',
+  'node_modules', 'vendor', '.git', 'dist', 'build',
+  'coverage', '__pycache__', '.next', '.turbo',
 ])
 
+// Logger that serializes objects properly instead of [object Object]
 const logger = {
-  debug: (...args: unknown[]) => core.debug(args.map(String).join(' ')),
-  info: (...args: unknown[]) => core.info(args.map(String).join(' ')),
-  warn: (...args: unknown[]) => core.warning(args.map(String).join(' ')),
-  error: (...args: unknown[]) => core.error(args.map(String).join(' ')),
+  debug: (...args: unknown[]) => core.debug(formatLogArgs(args)),
+  info: (...args: unknown[]) => core.info(formatLogArgs(args)),
+  warn: (...args: unknown[]) => core.warning(formatLogArgs(args)),
+  error: (...args: unknown[]) => core.error(formatLogArgs(args)),
+}
+
+function formatLogArgs(args: unknown[]): string {
+  return args.map(a =>
+    typeof a === 'object' && a !== null ? JSON.stringify(a, null, 2) : String(a)
+  ).join(' ')
 }
 
 async function run(): Promise<void> {
@@ -85,9 +78,7 @@ async function run(): Promise<void> {
     for (const fp of filePaths) {
       try {
         const stat = statSync(fp)
-        if (stat.size > 5 * 1024 * 1024) {
-          continue
-        }
+        if (stat.size > 5 * 1024 * 1024) continue
         files.set(fp, readFileSync(fp, 'utf-8'))
       } catch {
         // Skip unreadable files
@@ -100,29 +91,62 @@ async function run(): Promise<void> {
     const result = await analyzer.analyzeFiles(files)
     const totalFlags = result.totalFlags.size
 
+    // Collect language stats
+    const langStats: Record<string, number> = {}
+    for (const [lang, count] of result.languages) {
+      langStats[lang] = count
+    }
+
+    // Collect detected providers
+    const allFlags: FeatureFlag[] = []
+    for (const flags of result.totalFlags.values()) {
+      allFlags.push(...(flags as FeatureFlag[]))
+    }
+    const providers = [...new Set(
+      allFlags.map(f => f.provider).filter((p): p is string => p !== null && p !== undefined && p !== '')
+    )]
+
+    core.info(`Detection complete: ${totalFlags} unique flags across ${Object.keys(langStats).length} languages`)
+
     // Run staleness analysis
     const staleFlags = await analyzeStaleness(result.totalFlags as Map<string, FeatureFlag[]>, {
       thresholdMonths: threshold,
       repoRoot: process.cwd(),
     })
 
-    // Use unique stale flag names (not occurrences) for health score — matches CLI formula
     const uniqueStaleNames = new Set(staleFlags.map((f) => f.name)).size
     const healthScore =
       totalFlags > 0 ? Math.round(((totalFlags - uniqueStaleNames) / totalFlags) * 100) : 100
-
     const scanDuration = Date.now() - startTime
 
+    // Pretty log output
+    core.info('')
+    core.info('┌─────────────────────────────────────────┐')
+    core.info('│  🦈 FlagShark Scan Results               │')
+    core.info('├─────────────────────────────────────────┤')
+    core.info(`│  Files scanned:    ${String(files.size).padStart(6)}               │`)
+    core.info(`│  Languages:        ${String(Object.keys(langStats).length).padStart(6)}               │`)
+    core.info(`│  Flags detected:   ${String(totalFlags).padStart(6)}               │`)
+    core.info(`│  Stale flags:      ${String(uniqueStaleNames).padStart(6)}               │`)
+    core.info(`│  Health score:   ${String(healthScore).padStart(3)}/100               │`)
+    core.info(`│  Scan time:      ${String(scanDuration).padStart(5)}ms               │`)
+    core.info('└─────────────────────────────────────────┘')
+    core.info('')
+
+    if (providers.length > 0) {
+      core.info(`Detected providers: ${providers.slice(0, 8).join(', ')}${providers.length > 8 ? ` (+${providers.length - 8} more)` : ''}`)
+    }
+
     // Set outputs
     core.setOutput('health-score', healthScore.toString())
-    core.setOutput('stale-count', staleFlags.length.toString())
+    core.setOutput('stale-count', uniqueStaleNames.toString())
     core.setOutput('total-count', totalFlags.toString())
 
-    // Post PR comment (only on PRs)
-    if (github.context.payload.pull_request && staleFlags.length > 0) {
+    // Post PR comment
+    if (github.context.payload.pull_request && totalFlags > 0) {
       const token = process.env.GITHUB_TOKEN || core.getInput('token')
       if (token) {
-        await postComment(token, staleFlags, totalFlags, healthScore)
+        await postComment(token, staleFlags, totalFlags, healthScore, scanMode, langStats, providers, scanDuration)
       }
     }
 
@@ -130,19 +154,51 @@ async function run(): Promise<void> {
     if (failThreshold > 0 && healthScore < failThreshold) {
       core.setFailed(
         `Flag health score ${healthScore}/100 is below threshold ${failThreshold}/100. ` +
-          `${staleFlags.length} stale flags found.`,
+        `${uniqueStaleNames} stale flags found.`,
       )
-    } else {
-      core.info(`Flag Health Score: ${healthScore}/100 (${staleFlags.length}/${totalFlags} stale)`)
     }
 
-    // Summary
-    core.summary
-      .addHeading('FlagShark Results', 2)
-      .addRaw(`**Health Score:** ${healthScore}/100\n\n`)
-      .addRaw(`**Flags:** ${totalFlags} total, ${staleFlags.length} stale\n\n`)
-      .addRaw(`**Scan time:** ${scanDuration}ms\n`)
+    // Job summary (visible in Actions UI under "Summary" tab)
+    const healthEmoji = healthScore >= 90 ? '🟢' : healthScore >= 70 ? '🟡' : healthScore >= 40 ? '🟠' : '🔴'
+
+    core.summary.addHeading('🦈 FlagShark Scan Results', 2)
+    core.summary.addRaw(`\n${healthEmoji} **Health Score: ${healthScore}/100**\n\n`)
+    core.summary.addTable([
+      [{ data: 'Metric', header: true }, { data: 'Value', header: true }],
+      ['Files scanned', files.size.toString()],
+      ['Languages', Object.keys(langStats).join(', ') || 'none'],
+      ['Total flags', totalFlags.toString()],
+      ['Stale flags', uniqueStaleNames.toString()],
+      ['Scan mode', scanMode],
+      ['Scan time', `${scanDuration}ms`],
+    ])
+
+    if (providers.length > 0) {
+      core.summary.addRaw(`\n**Detected providers:** ${providers.join(', ')}\n`)
+    }
+
+    if (uniqueStaleNames > 0) {
+      core.summary.addRaw('\n### Top stale flags\n\n')
+      core.summary.addTable([
+        [{ data: 'Flag', header: true }, { data: 'File', header: true }, { data: 'Age', header: true }, { data: 'Signal', header: true }],
+        ...staleFlags.slice(0, 15).map(f => [
+          `\`${f.name}\``,
+          `${f.filePath}:${f.lineNumber}`,
+          f.age || 'unknown',
+          f.signals.map(s => s.description).join(', '),
+        ]),
+      ])
+      if (staleFlags.length > 15) {
+        core.summary.addRaw(`\n*... and ${staleFlags.length - 15} more stale flags*\n`)
+      }
+    }
+
+    core.summary.addRaw('\n---\n')
+    core.summary.addRaw('*Powered by [FlagShark](https://github.com/FlagShark/flagshark) — find stale feature flags before they cause incidents*\n')
+    core.summary.addRaw('\n[Automate flag cleanup](https://flagshark.com) · [Open source CLI](https://github.com/FlagShark/flagshark) · [Report an issue](https://github.com/FlagShark/flagshark/issues)\n')
+
     await core.summary.write()
+
   } catch (error) {
     if (error instanceof Error) {
       core.setFailed(error.message)
@@ -157,86 +213,103 @@ async function postComment(
   staleFlags: StaleFlag[],
   totalFlags: number,
   healthScore: number,
+  scanMode: string,
+  langStats: Record<string, number>,
+  providers: string[],
+  scanDuration: number,
 ): Promise<void> {
   const octokit = github.getOctokit(token)
   const { owner, repo } = github.context.repo
   const prNumber = github.context.payload.pull_request!.number
 
-  const displayFlags = staleFlags.slice(0, 10)
-  const remaining = staleFlags.length - displayFlags.length
+  const uniqueStaleCount = new Set(staleFlags.map((f) => f.name)).size
+  const modeLabel = scanMode === 'full' ? 'Full repo scan' : 'Changed files only'
+  const healthEmoji = healthScore >= 90 ? '🟢' : healthScore >= 70 ? '🟡' : healthScore >= 40 ? '🟠' : '🔴'
+  const langList = Object.entries(langStats).map(([l, c]) => `${l} (${c})`).join(', ')
+  const providerList = providers.length > 0
+    ? providers.slice(0, 5).join(', ') + (providers.length > 5 ? ` +${providers.length - 5} more` : '')
+    : 'none detected'
 
   let body = `${COMMENT_MARKER}\n`
-  body += `### 🦈 FlagShark found ${staleFlags.length} stale flag${staleFlags.length !== 1 ? 's' : ''}\n\n`
-  body += '| Flag | File | Added | Signal |\n'
-  body += '|------|------|-------|--------|\n'
 
-  for (const flag of displayFlags) {
-    const signals = flag.signals.map((s) => s.description).join(', ')
-    body += `| \`${flag.name}\` | ${flag.filePath}:${flag.lineNumber} | ${flag.age || 'unknown'} | ${signals} |\n`
+  // Header
+  if (uniqueStaleCount === 0) {
+    body += `## 🦈 FlagShark — All flags healthy\n\n`
+  } else {
+    body += `## 🦈 FlagShark — ${uniqueStaleCount} stale flag${uniqueStaleCount !== 1 ? 's' : ''} found\n\n`
   }
 
-  if (remaining > 0) {
-    body += `\n... and ${remaining} more stale flags.\n`
+  // Health score badge
+  body += `${healthEmoji} **Health Score: ${healthScore}/100**\n\n`
+
+  // Stats row
+  body += `| Metric | Value |\n`
+  body += `|--------|-------|\n`
+  body += `| Flags detected | ${totalFlags} |\n`
+  body += `| Stale flags | ${uniqueStaleCount} |\n`
+  body += `| Languages | ${langList} |\n`
+  body += `| Providers | ${providerList} |\n`
+  body += `| Scan mode | ${modeLabel} |\n`
+  body += `| Scan time | ${scanDuration}ms |\n\n`
+
+  // Stale flags table
+  if (uniqueStaleCount > 0) {
+    body += `<details${uniqueStaleCount <= 5 ? ' open' : ''}>\n`
+    body += `<summary><strong>Stale flags (${uniqueStaleCount})</strong></summary>\n\n`
+    body += '| Flag | File | Age | Why it looks stale |\n'
+    body += '|------|------|-----|--------------------|\n'
+
+    const displayFlags = staleFlags.slice(0, 20)
+    for (const flag of displayFlags) {
+      const signals = flag.signals.map(s => s.description).join(', ')
+      const shortPath = flag.filePath.replace(/^\.\//, '')
+      body += `| \`${flag.name}\` | \`${shortPath}:${flag.lineNumber}\` | ${flag.age || 'unknown'} | ${signals} |\n`
+    }
+
+    if (staleFlags.length > 20) {
+      body += `\n*... and ${staleFlags.length - 20} more. Run \`npx flagshark scan --verbose\` locally for the full list.*\n`
+    }
+
+    body += '\n</details>\n\n'
   }
 
-  body += `\n**Flag Health:** ${healthScore}/100 (${totalFlags} total, ${staleFlags.length} stale)\n`
-  body +=
-    '\nFull analysis → [FlagShark](https://github.com/FlagShark/flagshark)\n'
+  // Footer with links
+  body += '---\n'
+  body += `*[FlagShark](https://github.com/FlagShark/flagshark) finds stale feature flags before they cause incidents*\n\n`
+  body += `[Automate flag cleanup](https://flagshark.com) · `
+  body += `[Install CLI](https://www.npmjs.com/package/flagshark) · `
+  body += `[Open source](https://github.com/FlagShark/flagshark)\n`
 
   // Find existing comment to update
   const { data: comments } = await octokit.rest.issues.listComments({
-    owner,
-    repo,
-    issue_number: prNumber,
-    per_page: 100,
+    owner, repo, issue_number: prNumber, per_page: 100,
   })
 
   const existing = comments.find((c) => c.body?.includes(COMMENT_MARKER))
 
   if (existing) {
-    await octokit.rest.issues.updateComment({
-      owner,
-      repo,
-      comment_id: existing.id,
-      body,
-    })
+    await octokit.rest.issues.updateComment({ owner, repo, comment_id: existing.id, body })
     core.info('Updated existing FlagShark comment')
   } else {
-    await octokit.rest.issues.createComment({
-      owner,
-      repo,
-      issue_number: prNumber,
-      body,
-    })
+    await octokit.rest.issues.createComment({ owner, repo, issue_number: prNumber, body })
     core.info('Posted new FlagShark comment')
   }
 }
 
 function walkDir(dir: string, supportedExts: Set<string>): string[] {
   const results: string[] = []
-
   try {
     const entries = readdirSync(dir, { withFileTypes: true })
     for (const entry of entries) {
-      if (SKIP_DIRS.has(entry.name)) {
-        continue
-      }
-      if (entry.name.startsWith('.')) {
-        continue
-      }
-
+      if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.')) continue
       const fullPath = join(dir, entry.name)
-
       if (entry.isDirectory()) {
         results.push(...walkDir(fullPath, supportedExts))
       } else if (entry.isFile() && supportedExts.has(extname(entry.name))) {
         results.push(fullPath)
       }
     }
-  } catch {
-    // Skip unreadable directories
-  }
-
+  } catch { /* skip unreadable dirs */ }
   return results
 }