@sparkleideas/claude-flow-patch 3.1.0-alpha.44.patch.3

package/repair-post-init.sh

@@ -0,0 +1,245 @@
+#!/bin/bash
+# repair-post-init.sh
+# Post-init remediation for projects initialized before patch-all.sh.
+#
+# What it does:
+# 1) Finds a patched @claude-flow/cli helper source (local or global npx cache)
+# 2) Backs up target .claude/helpers (default)
+# 3) Rehydrates helper files into target project
+# 4) Preserves/installs a guidance-aware hook-handler when available
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TARGET_DIR="$(pwd)"
+SOURCE_SCOPE="auto"   # auto|local|global
+DO_BACKUP=1
+DRY_RUN=0
+RUN_CHECK=1
+
+usage() {
+  cat <<'EOF'
+Usage:
+  bash repair-post-init.sh [options]
+
+Options:
+  --target <dir>        Target project directory (default: current working directory)
+  --source <mode>       Source mode: auto|local|global (default: auto)
+  --no-backup           Skip .claude/helpers backup
+  --dry-run             Print actions without writing files
+  --skip-check          Skip check-patches.sh preflight
+  -h, --help            Show help
+
+Examples:
+  bash repair-post-init.sh --target ~/src/my-project
+  bash repair-post-init.sh --target ~/src/my-project --source global
+  bash repair-post-init.sh --target ~/src/my-project --dry-run
+EOF
+}
+
+fail() {
+  echo "[repair-post-init] ERROR: $*" >&2
+  exit 1
+}
+
+log() {
+  echo "[repair-post-init] $*"
+}
+
+run_cmd() {
+  if [ "$DRY_RUN" -eq 1 ]; then
+    echo "[dry-run] $*"
+    return 0
+  fi
+  "$@"
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --target)
+      TARGET_DIR="${2:-}"
+      shift 2
+      ;;
+    --source)
+      SOURCE_SCOPE="${2:-}"
+      shift 2
+      ;;
+    --no-backup)
+      DO_BACKUP=0
+      shift
+      ;;
+    --dry-run)
+      DRY_RUN=1
+      shift
+      ;;
+    --skip-check)
+      RUN_CHECK=0
+      shift
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      fail "Unknown option: $1"
+      ;;
+  esac
+done
+
+if [[ ! "$SOURCE_SCOPE" =~ ^(auto|local|global)$ ]]; then
+  fail "Invalid --source value: $SOURCE_SCOPE (expected auto|local|global)"
+fi
+
+TARGET_DIR="$(cd "$TARGET_DIR" && pwd)"
+[ -d "$TARGET_DIR" ] || fail "Target directory not found: $TARGET_DIR"
+
+if [ "$RUN_CHECK" -eq 1 ]; then
+  if [ -x "$SCRIPT_DIR/check-patches.sh" ]; then
+    log "Running preflight patch check..."
+    bash "$SCRIPT_DIR/check-patches.sh" >/dev/null || {
+      log "Patch check failed; applying patches..."
+      bash "$SCRIPT_DIR/patch-all.sh" --global >/dev/null
+      bash "$SCRIPT_DIR/check-patches.sh" >/dev/null || fail "Patch verification failed"
+    }
+  else
+    log "check-patches.sh not found; skipping preflight"
+  fi
+fi
+
+find_local_helpers() {
+  local base="$1"
+  for d in "$base" "$base/.." "$base/../.." "$base/../../.."; do
+    if [ -d "$d/node_modules/@claude-flow/cli/.claude/helpers" ]; then
+      (cd "$d/node_modules/@claude-flow/cli/.claude/helpers" && pwd)
+      return 0
+    fi
+  done
+  return 1
+}
+
+find_global_helpers() {
+  ls -td ~/.npm/_npx/*/node_modules/@claude-flow/cli/.claude/helpers 2>/dev/null | head -1 || true
+}
+
+SRC_HELPERS=""
+case "$SOURCE_SCOPE" in
+  local)
+    SRC_HELPERS="$(find_local_helpers "$TARGET_DIR" || true)"
+    ;;
+  global)
+    SRC_HELPERS="$(find_global_helpers)"
+    ;;
+  auto)
+    SRC_HELPERS="$(find_local_helpers "$TARGET_DIR" || true)"
+    if [ -z "$SRC_HELPERS" ]; then
+      SRC_HELPERS="$(find_global_helpers)"
+    fi
+    ;;
+esac
+
+[ -n "$SRC_HELPERS" ] || fail "Could not locate @claude-flow/cli/.claude/helpers (source=$SOURCE_SCOPE)"
+[ -d "$SRC_HELPERS" ] || fail "Source helpers directory does not exist: $SRC_HELPERS"
+[ -f "$SRC_HELPERS/intelligence.cjs" ] || fail "Source missing intelligence.cjs: $SRC_HELPERS"
+
+TARGET_HELPERS="$TARGET_DIR/.claude/helpers"
+BACKUP_PATH="$TARGET_DIR/.claude/helpers.backup.$(date +%Y%m%d-%H%M%S)"
+
+log "Target: $TARGET_DIR"
+log "Source helpers: $SRC_HELPERS"
+log "Target helpers: $TARGET_HELPERS"
+
+run_cmd mkdir -p "$TARGET_HELPERS"
+
+if [ "$DO_BACKUP" -eq 1 ] && [ -d "$TARGET_HELPERS" ]; then
+  if [ "$(ls -A "$TARGET_HELPERS" 2>/dev/null || true)" ]; then
+    log "Backing up existing helpers -> $BACKUP_PATH"
+    run_cmd cp -a "$TARGET_HELPERS" "$BACKUP_PATH"
+  fi
+fi
+
+# Copy all helpers except hook-handler.cjs first.
+copied=0
+for src in "$SRC_HELPERS"/*; do
+  [ -e "$src" ] || continue
+  base="$(basename "$src")"
+  if [ "$base" = "hook-handler.cjs" ]; then
+    continue
+  fi
+  run_cmd cp -a "$src" "$TARGET_HELPERS/$base"
+  copied=$((copied + 1))
+done
+
+# Prefer guidance-aware hook-handler when installed in target project.
+GUIDANCE_HANDLER="$TARGET_DIR/node_modules/claude-flow-guidance-implementation/scaffold/.claude/helpers/hook-handler.cjs"
+HOOK_SRC="$SRC_HELPERS/hook-handler.cjs"
+HOOK_REASON="@claude-flow/cli helper template"
+if [ -f "$GUIDANCE_HANDLER" ]; then
+  HOOK_SRC="$GUIDANCE_HANDLER"
+  HOOK_REASON="guidance implementation hook-handler"
+fi
+
+if [ -f "$HOOK_SRC" ]; then
+  log "Installing hook-handler from: $HOOK_REASON"
+  run_cmd cp -a "$HOOK_SRC" "$TARGET_HELPERS/hook-handler.cjs"
+  copied=$((copied + 1))
+fi
+
+# Make guidance hook-handler path resolution work when copied into project .claude/helpers.
+if [ "$DRY_RUN" -eq 0 ] && [ -f "$TARGET_HELPERS/hook-handler.cjs" ]; then
+  python3 - "$TARGET_HELPERS/hook-handler.cjs" <<'PY'
+import pathlib
+import sys
+
+path = pathlib.Path(sys.argv[1])
+text = path.read_text()
+
+start = text.find("function getBundledScriptPath(scriptName)")
+end = text.find("function getGuidanceScriptPath()", start if start >= 0 else 0)
+
+if start >= 0 and end > start and "claude-flow-guidance-implementation" not in text:
+    replacement = """function getBundledScriptPath(scriptName) {
+  return path.join(
+    getProjectDir(),
+    'node_modules',
+    'claude-flow-guidance-implementation',
+    'scaffold',
+    'scripts',
+    scriptName
+  );
+}
+
+function resolveGuidanceScriptPath(scriptName) {
+  const localPath = path.join(getProjectDir(), 'scripts', scriptName);
+  if (fs.existsSync(localPath)) return localPath;
+
+  const bundledPath = getBundledScriptPath(scriptName);
+  if (fs.existsSync(bundledPath)) return bundledPath;
+
+  // Keep compatibility for handler copies that live under scaffold/.claude/helpers.
+  const relativeBundledPath = path.resolve(__dirname, '..', '..', 'scripts', scriptName);
+  if (fs.existsSync(relativeBundledPath)) return relativeBundledPath;
+
+  return localPath;
+}
+
+"""
+    text = text[:start] + replacement + text[end:]
+    path.write_text(text)
+PY
+fi
+
+if [ "$DRY_RUN" -eq 0 ] && [ -f "$TARGET_HELPERS/hook-handler.cjs" ]; then
+  chmod +x "$TARGET_HELPERS/hook-handler.cjs" || true
+fi
+
+log "Copied/updated helper files: $copied"
+
+if [ "$DRY_RUN" -eq 0 ] && [ -f "$TARGET_HELPERS/hook-handler.cjs" ]; then
+  if node "$TARGET_HELPERS/hook-handler.cjs" status >/dev/null 2>&1; then
+    log "Smoke check: hook-handler status OK"
+  else
+    log "WARN: hook-handler status returned non-zero"
+  fi
+fi
+
+log "Done."

package/scripts/update-docs.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+// scripts/update-docs.mjs — Regenerate documentation from dynamic patch discovery.
+// Updates: README.md, CLAUDE.md, npm/README.md, npm/config.json
+//
+// Usage: node scripts/update-docs.mjs [--check]
+//   --check  Exit 1 if docs are out of date (for CI), don't write.
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { discover } from '../lib/discover.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+const checkOnly = process.argv.includes('--check');
+
+const data = discover();
+const { patches, categories, stats } = data;
+
+// ── Helpers ──
+
+/** Group patches by prefix, preserving sort order. */
+function groupByPrefix(patches) {
+  const groups = new Map();
+  for (const p of patches) {
+    if (!groups.has(p.prefix)) groups.set(p.prefix, []);
+    groups.get(p.prefix).push(p);
+  }
+  return groups;
+}
+
+/**
+ * Replace content between marker comments in a file.
+ * Returns true if content changed.
+ */
+function replaceMarkerSection(filePath, markerName, newContent) {
+  const beginMarker = `<!-- GENERATED:${markerName}:begin -->`;
+  const endMarker = `<!-- GENERATED:${markerName}:end -->`;
+
+  const text = readFileSync(filePath, 'utf-8');
+  const beginIdx = text.indexOf(beginMarker);
+  const endIdx = text.indexOf(endMarker);
+
+  if (beginIdx < 0 || endIdx < 0) {
+    console.error(`ERROR: Markers ${beginMarker} / ${endMarker} not found in ${filePath}`);
+    console.error('  Add them around the section that should be auto-generated.');
+    process.exit(1);
+  }
+
+  const before = text.slice(0, beginIdx + beginMarker.length);
+  const after = text.slice(endIdx);
+  const updated = `${before}\n${newContent}\n${after}`;
+
+  if (updated === text) return false;
+
+  if (!checkOnly) writeFileSync(filePath, updated);
+  return true;
+}
+
+// ── Generate README.md defect index ──
+
+function generateReadmeIndex() {
+  const groups = groupByPrefix(patches);
+  const lines = [`${stats.total} defects across ${stats.categories} categories.`];
+
+  for (const [prefix, items] of groups) {
+    const catLabel = categories[prefix] ?? prefix;
+    lines.push('');
+    lines.push(`### ${prefix} -- ${catLabel}`);
+    lines.push('');
+    lines.push('| ID | Description <img width="500" height="1" /> | Severity | GitHub&nbsp;Issue |');
+    lines.push('|----|-------------|----------|--------------|');
+
+    for (const p of items) {
+      const idLink = `[${p.id.replace('-', '&#8209;')}](patch/${p.dir}/)`;
+      const ghLink = p.githubUrl ? `[${p.github}](${p.githubUrl})` : p.github;
+      lines.push(`| ${idLink} | ${p.title} | ${p.severity} | ${ghLink} |`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// ── Generate CLAUDE.md defect tables ──
+
+function generateClaudeTables() {
+  const groups = groupByPrefix(patches);
+  const lines = [];
+
+  // Category summary table
+  lines.push('| Prefix | Category | Count |');
+  lines.push('|--------|----------|-------|');
+  for (const [prefix, items] of groups) {
+    const catLabel = categories[prefix] ?? prefix;
+    lines.push(`| ${prefix} | ${catLabel} | ${items.length} |`);
+  }
+
+  // Full defect list
+  lines.push('');
+  lines.push(`## All ${stats.total} Defects`);
+  lines.push('');
+  lines.push('| ID | GitHub Issue | Severity |');
+  lines.push('|----|-------------|----------|');
+  for (const p of patches) {
+    const ghText = p.github ? `${p.github} ${p.title}` : p.title;
+    const ghLink = p.githubUrl ? `[${ghText}](${p.githubUrl})` : ghText;
+    lines.push(`| ${p.id} | ${ghLink} | ${p.severity} |`);
+  }
+
+  return lines.join('\n');
+}
+
+// ── Generate npm/README.md defect list ──
+
+const REPO_URL = 'https://github.com/sparkling/claude-flow-patch';
+
+function generateNpmDefectList() {
+  const groups = groupByPrefix(patches);
+  const lines = [
+    `${stats.total} tracked defects across ${stats.categories} categories.`,
+    '',
+    '| Defect | Description | GitHub Issue |',
+    '|--------|-------------|-------------|',
+  ];
+
+  for (const [, items] of groups) {
+    for (const p of items) {
+      const defectLink = `[${p.id}](${REPO_URL}/tree/master/patch/${p.dir})`;
+      const ghLink = p.githubUrl ? `[${p.github}](${p.githubUrl})` : p.github;
+      lines.push(`| ${defectLink} | ${p.title} | ${ghLink} |`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function updateNpmReadme() {
+  return replaceMarkerSection(
+    resolve(ROOT, 'npm', 'README.md'),
+    'npm-defects',
+    generateNpmDefectList()
+  );
+}
+
+// ── Update npm/config.json counts ──
+
+function updateNpmConfig() {
+  const filePath = resolve(ROOT, 'npm', 'config.json');
+  const config = JSON.parse(readFileSync(filePath, 'utf-8'));
+
+  let changed = false;
+  if (config.defects?.total !== stats.total) {
+    config.defects.total = stats.total;
+    changed = true;
+  }
+  if (config.defects?.categories !== stats.categories) {
+    config.defects.categories = stats.categories;
+    changed = true;
+  }
+
+  if (changed && !checkOnly) {
+    writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+  }
+  return changed;
+}
+
+// ── Main ──
+
+let anyChanged = false;
+
+const readmeChanged = replaceMarkerSection(
+  resolve(ROOT, 'README.md'),
+  'defect-index',
+  generateReadmeIndex()
+);
+if (readmeChanged) {
+  anyChanged = true;
+  console.log(checkOnly ? 'STALE: README.md' : 'Updated: README.md');
+}
+
+const claudeChanged = replaceMarkerSection(
+  resolve(ROOT, 'CLAUDE.md'),
+  'defect-tables',
+  generateClaudeTables()
+);
+if (claudeChanged) {
+  anyChanged = true;
+  console.log(checkOnly ? 'STALE: CLAUDE.md' : 'Updated: CLAUDE.md');
+}
+
+const npmReadmeChanged = updateNpmReadme();
+if (npmReadmeChanged) {
+  anyChanged = true;
+  console.log(checkOnly ? 'STALE: npm/README.md' : 'Updated: npm/README.md');
+}
+
+const npmConfigChanged = updateNpmConfig();
+if (npmConfigChanged) {
+  anyChanged = true;
+  console.log(checkOnly ? 'STALE: npm/config.json' : 'Updated: npm/config.json');
+}
+
+if (!anyChanged) {
+  console.log('All docs are up to date.');
+} else if (checkOnly) {
+  console.log('\nDocs are out of date. Run: npm run update-docs');
+  process.exit(1);
+}

package/scripts/upstream-log.mjs

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+// scripts/upstream-log.mjs — Show recent @claude-flow/cli releases with changes.
+//
+// Usage:
+//   node scripts/upstream-log.mjs [count]    # default: 10
+//   node scripts/upstream-log.mjs 20         # last 20 releases
+//   node scripts/upstream-log.mjs --diff     # also diff deps against our baseline
+//   node scripts/upstream-log.mjs --full     # show complete GitHub issue bodies
+//
+// Requires: npm, gh (optional, for commit messages)
+
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, '..');
+
+// ── Args ──
+
+const flags = ['--diff', '--full'];
+const args = process.argv.slice(2).filter(a => !flags.includes(a));
+const showDiff = process.argv.includes('--diff');
+const fullDetail = process.argv.includes('--full');
+const count = parseInt(args[0], 10) || 10;
+
+// ── Our baseline + latest from npm ──
+
+let baseline = null;
+try {
+  const readme = readFileSync(resolve(ROOT, 'README.md'), 'utf-8');
+  const match = readme.match(/@claude-flow\/cli.*?\*\*v?(3\.\d+\.\d+-alpha\.\d+)\*\*/);
+  baseline = match?.[1] ?? null;
+} catch { /* no README */ }
+
+const latest = run('npm view @claude-flow/cli@latest version').trim() || null;
+
+// ── Helpers ──
+
+function run(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8', timeout: 30000 }).trim();
+  } catch {
+    return '';
+  }
+}
+
+// ── Fetch npm version timeline ──
+
+const timeJson = run('npm view @claude-flow/cli time --json');
+if (!timeJson) {
+  console.error('ERROR: Could not fetch version data from npm.');
+  process.exit(1);
+}
+
+const times = JSON.parse(timeJson);
+delete times.created;
+delete times.modified;
+
+// Sort by publish date descending, take last N (+1 for window boundary)
+const allVersions = Object.entries(times)
+  .sort((a, b) => new Date(b[1]) - new Date(a[1]));
+
+const versions = allVersions.slice(0, count);
+
+// ── Fetch GitHub commits with timestamps ──
+
+const commits = []; // { time: Date, title: string, body: string }
+
+function fetchCommits() {
+  // Fetch as JSON to preserve full multi-line commit messages
+  const raw = run('gh api repos/ruvnet/claude-flow/commits?per_page=100');
+  if (!raw) return;
+  try {
+    const data = JSON.parse(raw);
+    for (const item of data) {
+      const time = new Date(item.commit?.author?.date);
+      const fullMsg = item.commit?.message ?? '';
+      const lines = fullMsg.split('\n');
+      const title = lines[0] || '';
+      // Body is everything after the first blank line
+      const blankIdx = lines.findIndex((l, i) => i > 0 && l.trim() === '');
+      const body = blankIdx >= 0
+        ? lines.slice(blankIdx + 1).filter(l => l.trim()).join('\n').trim()
+        : '';
+      if (!isNaN(time.getTime()) && title) {
+        commits.push({ time, title, body });
+      }
+    }
+  } catch { /* gh not available or parse error */ }
+  // Sort oldest first for window matching
+  commits.sort((a, b) => a.time - b.time);
+}
+
+fetchCommits();
+
+/**
+ * Find commits between prevTime (exclusive) and thisTime (inclusive).
+ * Skip version-bump-only and checkpoint commits.
+ */
+function commitsForWindow(thisTime, prevTime) {
+  const start = prevTime ? new Date(prevTime) : new Date(0);
+  const end = new Date(thisTime);
+  return commits
+    .filter(c => c.time > start && c.time <= end)
+    .filter(c => !/^Bump to 3\.\d/.test(c.title))
+    .filter(c => !/^Checkpoint:/.test(c.title));
+}
+
+// ── GitHub issue details ──
+
+const issueCache = new Map();
+
+function fetchIssue(num) {
+  if (issueCache.has(num)) return issueCache.get(num);
+  const raw = run(`gh api repos/ruvnet/claude-flow/issues/${num}`);
+  if (!raw) { issueCache.set(num, null); return null; }
+  try {
+    const data = JSON.parse(raw);
+    const rawBody = (data.body ?? '').trim();
+    const labels = (data.labels ?? []).map(l => l.name);
+
+    // Summary: filtered lines for compact view
+    const summary = rawBody.split('\n')
+      .filter(l => l.trim())
+      .filter(l => !l.startsWith('##'))
+      .filter(l => !l.startsWith('```'))
+      .filter(l => !l.startsWith('Fixes #'))
+      .filter(l => !l.startsWith('Co-Authored'))
+      .filter(l => !l.startsWith('🤖'))
+      .slice(0, 6)
+      .map(l => l.trim());
+
+    const result = { title: data.title, state: data.state, labels, summary, fullBody: rawBody };
+    issueCache.set(num, result);
+    return result;
+  } catch { issueCache.set(num, null); return null; }
+}
+
+/**
+ * Extract GitHub issue numbers from a commit title, e.g. "(#1165)" -> [1165]
+ */
+function extractIssueRefs(title) {
+  const matches = [...title.matchAll(/#(\d+)/g)];
+  return matches.map(m => parseInt(m[1], 10));
+}
+
+// ── Dep diff helper ──
+
+function getDeps(version) {
+  const raw = run(`npm view @claude-flow/cli@${version} dependencies --json`);
+  return raw ? JSON.parse(raw) : {};
+}
+
+// ── Output ──
+
+console.log(`Last ${versions.length} releases of @claude-flow/cli`);
+if (latest) console.log(`Latest on npm: ${latest}`);
+if (baseline) console.log(`Patch baseline: ${baseline}`);
+if (latest && baseline && latest !== baseline) {
+  const ahead = allVersions.findIndex(([v]) => v === baseline) - allVersions.findIndex(([v]) => v === latest);
+  if (ahead > 0) console.log(`Upstream is ${ahead} version${ahead > 1 ? 's' : ''} ahead of baseline`);
+}
+console.log('');
+
+for (let i = 0; i < versions.length; i++) {
+  const [version, time] = versions[i];
+  const date = time.slice(0, 10);
+  const isBaseline = version === baseline;
+  const marker = isBaseline ? '  <-- patch baseline' : '';
+
+  console.log(`  ${version}  ${date}${marker}`);
+
+  // Previous version's time is the window boundary
+  const prevTime = versions[i + 1]?.[1] ?? allVersions[allVersions.indexOf(versions[i]) + 1]?.[1];
+  const windowCommits = commitsForWindow(time, prevTime);
+
+  const seenIssues = new Set();
+  for (const c of windowCommits.slice(0, 5)) {
+    console.log(`    - ${c.title}`);
+    if (c.body) {
+      const bodyLines = c.body.split('\n')
+        .filter(l => l.trim())
+        .filter(l => !l.startsWith('Co-Authored-By'))
+        .filter(l => !l.startsWith('Published:'));
+      for (const bl of (fullDetail ? bodyLines : bodyLines.slice(0, 6))) {
+        console.log(`      ${bl.trim()}`);
+      }
+    }
+    // Fetch linked GitHub issues for additional context
+    for (const issueNum of extractIssueRefs(c.title)) {
+      if (seenIssues.has(issueNum)) continue;
+      seenIssues.add(issueNum);
+      const issue = fetchIssue(issueNum);
+      if (!issue) continue;
+
+      if (fullDetail && issue.fullBody) {
+        // --full: show complete issue body
+        console.log(`      Issue #${issueNum}: ${issue.title} [${issue.state}]`);
+        if (issue.labels.length > 0) {
+          console.log(`      Labels: ${issue.labels.join(', ')}`);
+        }
+        for (const bl of issue.fullBody.split('\n')) {
+          console.log(`        ${bl}`);
+        }
+      } else if (issue.summary.length > 0) {
+        // Compact: show summary lines not already in the commit body
+        const extra = issue.summary.filter(l => !c.body?.includes(l));
+        if (extra.length > 0) {
+          console.log(`      Issue #${issueNum}: ${issue.title} [${issue.state}]`);
+          for (const bl of extra.slice(0, 4)) {
+            console.log(`        ${bl}`);
+          }
+        }
+      }
+    }
+  }
+  if (windowCommits.length > 5) {
+    console.log(`    ... and ${windowCommits.length - 5} more`);
+  }
+  if (windowCommits.length === 0 && commits.length > 0) {
+    console.log('    (version bump only)');
+  }
+}
+
+// ── Dep diff against baseline ──
+
+if (showDiff && baseline) {
+  const latest = versions[0]?.[0];
+  if (latest && latest !== baseline) {
+    console.log('');
+    console.log(`Dependency diff: ${baseline} -> ${latest}`);
+    console.log('');
+
+    const oldDeps = getDeps(baseline);
+    const newDeps = getDeps(latest);
+
+    const allKeys = new Set([...Object.keys(oldDeps), ...Object.keys(newDeps)]);
+    let anyChange = false;
+
+    for (const key of [...allKeys].sort()) {
+      const oldV = oldDeps[key];
+      const newV = newDeps[key];
+      if (oldV !== newV) {
+        anyChange = true;
+        if (!oldV) console.log(`  + ${key}: ${newV}`);
+        else if (!newV) console.log(`  - ${key}: ${oldV}`);
+        else console.log(`  ~ ${key}: ${oldV} -> ${newV}`);
+      }
+    }
+
+    if (!anyChange) console.log('  (no dependency changes)');
+  }
+}
+
+console.log('');