clew-code 0.2.28 → 0.2.30

package/scripts/auto-close-duplicates.ts

@@ -0,0 +1,277 @@
+#!/usr/bin/env bun
+
+declare global {
+  var process: {
+    env: Record<string, string | undefined>;
+  };
+}
+
+interface GitHubIssue {
+  number: number;
+  title: string;
+  user: { id: number };
+  created_at: string;
+}
+
+interface GitHubComment {
+  id: number;
+  body: string;
+  created_at: string;
+  user: { type: string; id: number };
+}
+
+interface GitHubReaction {
+  user: { id: number };
+  content: string;
+}
+
+async function githubRequest<T>(endpoint: string, token: string, method: string = 'GET', body?: any): Promise<T> {
+  const response = await fetch(`https://api.github.com${endpoint}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "auto-close-duplicates-script",
+      ...(body && { "Content-Type": "application/json" }),
+    },
+    ...(body && { body: JSON.stringify(body) }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GitHub API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  return response.json();
+}
+
+function extractDuplicateIssueNumber(commentBody: string): number | null {
+  // Try to match #123 format first
+  let match = commentBody.match(/#(\d+)/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  
+  // Try to match GitHub issue URL format: https://github.com/owner/repo/issues/123
+  match = commentBody.match(/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)/);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  
+  return null;
+}
+
+
+async function closeIssueAsDuplicate(
+  owner: string,
+  repo: string,
+  issueNumber: number,
+  duplicateOfNumber: number,
+  token: string
+): Promise<void> {
+  await githubRequest(
+    `/repos/${owner}/${repo}/issues/${issueNumber}`,
+    token,
+    'PATCH',
+    {
+      state: 'closed',
+      state_reason: 'duplicate',
+      labels: ['duplicate']
+    }
+  );
+
+  await githubRequest(
+    `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
+    token,
+    'POST',
+    {
+      body: `This issue has been automatically closed as a duplicate of #${duplicateOfNumber}.
+
+If this is incorrect, please re-open this issue or create a new one.
+
+🤖 Generated with [Claude Code](https://claude.ai/code)`
+    }
+  );
+
+}
+
+async function autoCloseDuplicates(): Promise<void> {
+  console.log("[DEBUG] Starting auto-close duplicates script");
+
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error("GITHUB_TOKEN environment variable is required");
+  }
+  console.log("[DEBUG] GitHub token found");
+
+  const owner = process.env.GITHUB_REPOSITORY_OWNER || "anthropics";
+  const repo = process.env.GITHUB_REPOSITORY_NAME || "claude-code";
+  console.log(`[DEBUG] Repository: ${owner}/${repo}`);
+
+  const threeDaysAgo = new Date();
+  threeDaysAgo.setDate(threeDaysAgo.getDate() - 3);
+  console.log(
+    `[DEBUG] Checking for duplicate comments older than: ${threeDaysAgo.toISOString()}`
+  );
+
+  console.log("[DEBUG] Fetching open issues created more than 3 days ago...");
+  const allIssues: GitHubIssue[] = [];
+  let page = 1;
+  const perPage = 100;
+  
+  while (true) {
+    const pageIssues: GitHubIssue[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues?state=open&per_page=${perPage}&page=${page}`,
+      token
+    );
+    
+    if (pageIssues.length === 0) break;
+    
+    // Filter for issues created more than 3 days ago
+    const oldEnoughIssues = pageIssues.filter(issue => 
+      new Date(issue.created_at) <= threeDaysAgo
+    );
+    
+    allIssues.push(...oldEnoughIssues);
+    page++;
+    
+    // Safety limit to avoid infinite loops
+    if (page > 20) break;
+  }
+  
+  const issues = allIssues;
+  console.log(`[DEBUG] Found ${issues.length} open issues`);
+
+  let processedCount = 0;
+  let candidateCount = 0;
+
+  for (const issue of issues) {
+    processedCount++;
+    console.log(
+      `[DEBUG] Processing issue #${issue.number} (${processedCount}/${issues.length}): ${issue.title}`
+    );
+
+    console.log(`[DEBUG] Fetching comments for issue #${issue.number}...`);
+    const comments: GitHubComment[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues/${issue.number}/comments`,
+      token
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${comments.length} comments`
+    );
+
+    const dupeComments = comments.filter(
+      (comment) =>
+        comment.body.includes("Found") &&
+        comment.body.includes("possible duplicate") &&
+        comment.user.type === "Bot"
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${dupeComments.length} duplicate detection comments`
+    );
+
+    if (dupeComments.length === 0) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} - no duplicate comments found, skipping`
+      );
+      continue;
+    }
+
+    const lastDupeComment = dupeComments[dupeComments.length - 1];
+    const dupeCommentDate = new Date(lastDupeComment.created_at);
+    console.log(
+      `[DEBUG] Issue #${
+        issue.number
+      } - most recent duplicate comment from: ${dupeCommentDate.toISOString()}`
+    );
+
+    if (dupeCommentDate > threeDaysAgo) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} - duplicate comment is too recent, skipping`
+      );
+      continue;
+    }
+    console.log(
+      `[DEBUG] Issue #${
+        issue.number
+      } - duplicate comment is old enough (${Math.floor(
+        (Date.now() - dupeCommentDate.getTime()) / (1000 * 60 * 60 * 24)
+      )} days)`
+    );
+
+    const commentsAfterDupe = comments.filter(
+      (comment) => new Date(comment.created_at) > dupeCommentDate
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} - ${commentsAfterDupe.length} comments after duplicate detection`
+    );
+
+    if (commentsAfterDupe.length > 0) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} - has activity after duplicate comment, skipping`
+      );
+      continue;
+    }
+
+    console.log(
+      `[DEBUG] Issue #${issue.number} - checking reactions on duplicate comment...`
+    );
+    const reactions: GitHubReaction[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues/comments/${lastDupeComment.id}/reactions`,
+      token
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} - duplicate comment has ${reactions.length} reactions`
+    );
+
+    const authorThumbsDown = reactions.some(
+      (reaction) =>
+        reaction.user.id === issue.user.id && reaction.content === "-1"
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} - author thumbs down reaction: ${authorThumbsDown}`
+    );
+
+    if (authorThumbsDown) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} - author disagreed with duplicate detection, skipping`
+      );
+      continue;
+    }
+
+    const duplicateIssueNumber = extractDuplicateIssueNumber(lastDupeComment.body);
+    if (!duplicateIssueNumber) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} - could not extract duplicate issue number from comment, skipping`
+      );
+      continue;
+    }
+
+    candidateCount++;
+    const issueUrl = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+    
+    try {
+      console.log(
+        `[INFO] Auto-closing issue #${issue.number} as duplicate of #${duplicateIssueNumber}: ${issueUrl}`
+      );
+      await closeIssueAsDuplicate(owner, repo, issue.number, duplicateIssueNumber, token);
+      console.log(
+        `[SUCCESS] Successfully closed issue #${issue.number} as duplicate of #${duplicateIssueNumber}`
+      );
+    } catch (error) {
+      console.error(
+        `[ERROR] Failed to close issue #${issue.number} as duplicate: ${error}`
+      );
+    }
+  }
+
+  console.log(
+    `[DEBUG] Script completed. Processed ${processedCount} issues, found ${candidateCount} candidates for auto-close`
+  );
+}
+
+autoCloseDuplicates().catch(console.error);
+
+// Make it a module
+export {};

package/scripts/backfill-duplicate-comments.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+
+declare global {
+  var process: {
+    env: Record<string, string | undefined>;
+  };
+}
+
+interface GitHubIssue {
+  number: number;
+  title: string;
+  state: string;
+  state_reason?: string;
+  user: { id: number };
+  created_at: string;
+  closed_at?: string;
+}
+
+interface GitHubComment {
+  id: number;
+  body: string;
+  created_at: string;
+  user: { type: string; id: number };
+}
+
+async function githubRequest<T>(endpoint: string, token: string, method: string = 'GET', body?: any): Promise<T> {
+  const response = await fetch(`https://api.github.com${endpoint}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "backfill-duplicate-comments-script",
+      ...(body && { "Content-Type": "application/json" }),
+    },
+    ...(body && { body: JSON.stringify(body) }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GitHub API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  return response.json();
+}
+
+async function triggerDedupeWorkflow(
+  owner: string,
+  repo: string,
+  issueNumber: number,
+  token: string,
+  dryRun: boolean = true
+): Promise<void> {
+  if (dryRun) {
+    console.log(`[DRY RUN] Would trigger dedupe workflow for issue #${issueNumber}`);
+    return;
+  }
+
+  await githubRequest(
+    `/repos/${owner}/${repo}/actions/workflows/claude-dedupe-issues.yml/dispatches`,
+    token,
+    'POST',
+    {
+      ref: 'main',
+      inputs: {
+        issue_number: issueNumber.toString()
+      }
+    }
+  );
+}
+
+async function backfillDuplicateComments(): Promise<void> {
+  console.log("[DEBUG] Starting backfill duplicate comments script");
+
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(`GITHUB_TOKEN environment variable is required
+
+Usage:
+  GITHUB_TOKEN=your_token bun run scripts/backfill-duplicate-comments.ts
+
+Environment Variables:
+  GITHUB_TOKEN - GitHub personal access token with repo and actions permissions (required)
+  DRY_RUN - Set to "false" to actually trigger workflows (default: true for safety)
+  MAX_ISSUE_NUMBER - Only process issues with numbers less than this value (default: 4050)`);
+  }
+  console.log("[DEBUG] GitHub token found");
+
+  const owner = "anthropics";
+  const repo = "claude-code";
+  const dryRun = process.env.DRY_RUN !== "false";
+  const maxIssueNumber = parseInt(process.env.MAX_ISSUE_NUMBER || "4050", 10);
+  const minIssueNumber = parseInt(process.env.MIN_ISSUE_NUMBER || "1", 10);
+  
+  console.log(`[DEBUG] Repository: ${owner}/${repo}`);
+  console.log(`[DEBUG] Dry run mode: ${dryRun}`);
+  console.log(`[DEBUG] Looking at issues between #${minIssueNumber} and #${maxIssueNumber}`);
+
+  console.log(`[DEBUG] Fetching issues between #${minIssueNumber} and #${maxIssueNumber}...`);
+  const allIssues: GitHubIssue[] = [];
+  let page = 1;
+  const perPage = 100;
+  
+  while (true) {
+    const pageIssues: GitHubIssue[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues?state=all&per_page=${perPage}&page=${page}&sort=created&direction=desc`,
+      token
+    );
+    
+    if (pageIssues.length === 0) break;
+    
+    // Filter to only include issues within the specified range
+    const filteredIssues = pageIssues.filter(issue => 
+      issue.number >= minIssueNumber && issue.number < maxIssueNumber
+    );
+    allIssues.push(...filteredIssues);
+    
+    // If the oldest issue in this page is still above our minimum, we need to continue
+    // but if the oldest issue is below our minimum, we can stop
+    const oldestIssueInPage = pageIssues[pageIssues.length - 1];
+    if (oldestIssueInPage && oldestIssueInPage.number >= maxIssueNumber) {
+      console.log(`[DEBUG] Oldest issue in page #${page} is #${oldestIssueInPage.number}, continuing...`);
+    } else if (oldestIssueInPage && oldestIssueInPage.number < minIssueNumber) {
+      console.log(`[DEBUG] Oldest issue in page #${page} is #${oldestIssueInPage.number}, below minimum, stopping`);
+      break;
+    } else if (filteredIssues.length === 0 && pageIssues.length > 0) {
+      console.log(`[DEBUG] No issues in page #${page} are in range #${minIssueNumber}-#${maxIssueNumber}, continuing...`);
+    }
+    
+    page++;
+    
+    // Safety limit to avoid infinite loops
+    if (page > 200) {
+      console.log("[DEBUG] Reached page limit, stopping pagination");
+      break;
+    }
+  }
+  
+  console.log(`[DEBUG] Found ${allIssues.length} issues between #${minIssueNumber} and #${maxIssueNumber}`);
+
+  let processedCount = 0;
+  let candidateCount = 0;
+  let triggeredCount = 0;
+
+  for (const issue of allIssues) {
+    processedCount++;
+    console.log(
+      `[DEBUG] Processing issue #${issue.number} (${processedCount}/${allIssues.length}): ${issue.title}`
+    );
+
+    console.log(`[DEBUG] Fetching comments for issue #${issue.number}...`);
+    const comments: GitHubComment[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues/${issue.number}/comments`,
+      token
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${comments.length} comments`
+    );
+
+    // Look for existing duplicate detection comments (from the dedupe bot)
+    const dupeDetectionComments = comments.filter(
+      (comment) =>
+        comment.body.includes("Found") &&
+        comment.body.includes("possible duplicate") &&
+        comment.user.type === "Bot"
+    );
+
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${dupeDetectionComments.length} duplicate detection comments`
+    );
+
+    // Skip if there's already a duplicate detection comment
+    if (dupeDetectionComments.length > 0) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} already has duplicate detection comment, skipping`
+      );
+      continue;
+    }
+
+    candidateCount++;
+    const issueUrl = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+    
+    try {
+      console.log(
+        `[INFO] ${dryRun ? '[DRY RUN] ' : ''}Triggering dedupe workflow for issue #${issue.number}: ${issueUrl}`
+      );
+      await triggerDedupeWorkflow(owner, repo, issue.number, token, dryRun);
+      
+      if (!dryRun) {
+        console.log(
+          `[SUCCESS] Successfully triggered dedupe workflow for issue #${issue.number}`
+        );
+      }
+      triggeredCount++;
+    } catch (error) {
+      console.error(
+        `[ERROR] Failed to trigger workflow for issue #${issue.number}: ${error}`
+      );
+    }
+
+    // Add a delay between workflow triggers to avoid overwhelming the system
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  console.log(
+    `[DEBUG] Script completed. Processed ${processedCount} issues, found ${candidateCount} candidates without duplicate comments, ${dryRun ? 'would trigger' : 'triggered'} ${triggeredCount} workflows`
+  );
+}
+
+backfillDuplicateComments().catch(console.error);
+
+// Make it a module
+export {};

package/scripts/codegraph.ts

@@ -0,0 +1,221 @@
+#!/usr/bin/env bun
+/**
+ * Code Graph Generator
+ *
+ * Scans src/ and builds a persistent structure map of the codebase.
+ * Uses ripgrep (fast, available in the project) for text patterns.
+ *
+ * Usage: bun run scripts/codegraph.ts
+ */
+
+import { readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { join, dirname } from 'path'
+import { execSync } from 'child_process'
+
+const ROOT = join(import.meta.dirname, '..')
+const SRC = join(ROOT, 'src')
+const OUT = join(ROOT, '.clew', 'CODEGRAPH.md')
+
+function rg(args: string): string {
+  try {
+    return execSync(`rg ${args}`, { cwd: ROOT, encoding: 'utf-8', timeout: 60000, stdio: ['pipe', 'pipe', 'ignore'] })
+  } catch (e: any) {
+    return e.stdout || ''
+  }
+}
+
+interface Module {
+  path: string
+  lines: number
+  exports: string[]
+  types: string[]
+  classNames: string[]
+  imports: string[]
+  todos: number
+}
+
+// ── 1. File list ──
+console.log('📁 Scanning files...')
+const fileLines = rg('--count --sort path --type ts "^" src/').trim().split('\n').filter(Boolean)
+
+const files = new Map<string, Module>()
+
+for (const entry of fileLines) {
+  const colon = entry.lastIndexOf(':')
+  const relPath = entry.slice(0, colon).replace(/\\/g, '/').replace(/^src\//, '')
+  const lineCount = parseInt(entry.slice(colon + 1)) || 0
+  if (!relPath || relPath.startsWith('..')) continue
+
+  files.set(relPath, {
+    path: relPath,
+    lines: lineCount,
+    exports: [],
+    types: [],
+    classNames: [],
+    imports: [],
+    todos: 0,
+  })
+}
+console.log(`   ${files.size} files`)
+
+// ── 2. Exports via ripgrep (bulk) ──
+console.log('🔍 Exports...')
+
+type Field = 'exports' | 'types' | 'classNames'
+const patterns: { rgPattern: string; field: Field }[] = [
+  { rgPattern: 'export (async )?function [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'exports' },
+  { rgPattern: 'export const [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'exports' },
+  { rgPattern: 'export (abstract )?class [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'classNames' },
+  { rgPattern: 'export interface [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'types' },
+  { rgPattern: 'export type [a-zA-Z_$][a-zA-Z0-9_$]*', field: 'types' },
+]
+
+for (const p of patterns) {
+  // Single rg call per pattern — fast
+  const out = rg(`--with-filename --only-matching --no-line-number "${p.rgPattern}" src/`).trim()
+  for (const line of out.split('\n').filter(Boolean)) {
+    const fileSep = line.indexOf(':')
+    if (fileSep === -1) continue
+    const rawPath = line.slice(0, fileSep).replace(/\\/g, '/').replace(/^src\//, '')
+    const matched = line.slice(fileSep + 1).trim()
+    const name = matched.split(/\s+/).pop()
+    if (!name || !rawPath) continue
+    const f = files.get(rawPath)
+    if (f && !(f[p.field] as string[]).includes(name)) {
+      (f[p.field] as string[]).push(name)
+    }
+  }
+}
+
+// ── 3. Imports + TODOs ──
+console.log('📎 Dependencies...')
+
+for (const [relPath, info] of files) {
+  try {
+    const content = readFileSync(join(SRC, relPath), 'utf-8')
+
+    // Internal imports
+    const srcImports: string[] = []
+    for (const line of content.split('\n')) {
+      const m = line.match(/from\s+['"](src\/[^'"]+)['"]/)
+      if (m) srcImports.push(m[1])
+    }
+    info.imports = [...new Set(srcImports)]
+
+    // TODOs
+    info.todos = (content.match(/\b(TODO|FIXME|HACK|XXX)\b/g) || []).length
+  } catch {
+    // skip unreadable files
+  }
+}
+
+// Also add class names to exports
+for (const f of files.values()) {
+  for (const cls of f.classNames) {
+    if (!f.exports.includes(cls)) f.exports.push(cls)
+  }
+}
+
+// ── 4. Generate markdown ──
+console.log('📝 Generating...')
+
+const totalLines = [...files.values()].reduce((a, f) => a + f.lines, 0)
+const totalExports = [...files.values()].reduce((a, f) => a + f.exports.length, 0)
+const totalTodos = [...files.values()].reduce((a, f) => a + f.todos, 0)
+
+const md: string[] = []
+md.push('# Code Graph')
+md.push('')
+md.push(`_Auto-generated ${new Date().toISOString().slice(0, 10)}_`)
+md.push('')
+md.push(`- **Source files**: ${files.size}`)
+md.push(`- **Total lines**: ${totalLines.toLocaleString()}`)
+md.push(`- **Exports**: ${totalExports}`)
+md.push(`- **TODOs**: ${totalTodos}`)
+md.push('')
+
+// Group by top directory
+const dirMap = new Map<string, Module[]>()
+for (const f of files.values()) {
+  const dir = f.path.split('/')[0]
+  if (!dirMap.has(dir)) dirMap.set(dir, [])
+  dirMap.get(dir)!.push(f)
+}
+
+for (const [dir, dirFiles] of [...dirMap.entries()].sort()) {
+  md.push(`## ${dir}/`)
+  md.push('')
+  dirFiles.sort((a, b) => b.lines - a.lines)
+
+  for (const f of dirFiles) {
+    if (f.lines < 25 && !f.exports.length && !f.types.length) continue
+
+    const badges = [`${f.lines} lines`]
+    if (f.todos) badges.push(`⚠️ ${f.todos}`)
+
+    md.push(`### \`${f.path}\``)
+    md.push(`_${badges.join(', ')}_`)
+
+    if (f.exports.length) {
+      const list = f.exports.slice(0, 10).join(', ')
+      md.push(`- exports: ${list}${f.exports.length > 10 ? ` [+${f.exports.length - 10}]` : ''}`)
+    }
+    if (f.types.length) {
+      const list = f.types.slice(0, 6).join(', ')
+      md.push(`- types: ${list}${f.types.length > 6 ? ` [+${f.types.length - 6}]` : ''}`)
+    }
+    if (f.imports.length) {
+      const list = f.imports.slice(0, 5).join(', ')
+      md.push(`- deps: ${list}${f.imports.length > 5 ? ` (+${f.imports.length - 5})` : ''}`)
+    }
+    md.push('')
+  }
+}
+
+// Hot dependencies
+const depCount = new Map<string, number>()
+for (const f of files.values()) {
+  for (const dep of f.imports) {
+    depCount.set(dep, (depCount.get(dep) || 0) + 1)
+  }
+}
+
+const sortedDeps = [...depCount.entries()].sort((a, b) => b[1] - a[1]).slice(0, 15)
+if (sortedDeps.length) {
+  md.push('---')
+  md.push('## Hot Dependencies')
+  md.push('')
+  for (const [dep, count] of sortedDeps) {
+    md.push(`- \`${dep}\` — imported by ${count} files`)
+  }
+  md.push('')
+}
+
+// Large files
+const largeFiles = [...files.values()].filter(f => f.lines > 300).sort((a, b) => b.lines - a.lines)
+if (largeFiles.length) {
+  md.push('---')
+  md.push('## Large Files (>300 lines)')
+  md.push('')
+  for (const f of largeFiles) {
+    md.push(`- \`${f.path}\` — ${f.lines} lines${f.todos ? ', ⚠️' : ''}`)
+  }
+  md.push('')
+}
+
+// TODO hotspots
+const todoFiles = [...files.values()].filter(f => f.todos > 2).sort((a, b) => b.todos - a.todos).slice(0, 10)
+if (todoFiles.length) {
+  md.push('---')
+  md.push('## TODO Hotspots')
+  md.push('')
+  for (const f of todoFiles) {
+    md.push(`- \`${f.path}\` — ${f.todos} TODOs`)
+  }
+  md.push('')
+}
+
+mkdirSync(dirname(OUT), { recursive: true })
+writeFileSync(OUT, md.join('\n'), 'utf-8')
+console.log(`\n✅ ${OUT}`)
+console.log(`   ${files.size} files | ${totalLines.toLocaleString()} lines | ${totalExports} exports`)