aibridge-context 1.5.1 → 2.0.0

package/core/briefingGenerator.js

@@ -0,0 +1,368 @@
+'use strict';
+
+/**
+ * briefingGenerator.js
+ * --------------------
+ * Generates .ai-context/briefing.md — a single markdown file
+ * that gives any AI assistant a complete, immediate picture
+ * of the project: structure, code, errors, fixes, changes,
+ * dependencies, routes, and what to work on next.
+ *
+ * Auto-regenerated on every startup and every file change.
+ */
+
+const path = require('path');
+
+// ─────────────────────────────────────────────────────────────────
+//  Tree renderer
+// ─────────────────────────────────────────────────────────────────
+
+function renderFileTree(tree, prefix, lines) {
+  const entries = Object.entries(tree || {});
+  entries.forEach(([name, children], idx) => {
+    const isLast      = idx === entries.length - 1;
+    const connector   = isLast ? '└── ' : '├── ';
+    const childPrefix = isLast ? '    ' : '│   ';
+    lines.push(prefix + connector + name);
+    if (children && typeof children === 'object') {
+      renderFileTree(children, prefix + childPrefix, lines);
+    }
+  });
+}
+
+function fileTreeToString(tree) {
+  const lines = [];
+  renderFileTree(tree, '', lines);
+  return lines.join('\n');
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Section builders
+// ─────────────────────────────────────────────────────────────────
+
+function sectionHeader(title) {
+  return `\n## ${title}\n`;
+}
+
+function buildOverview(state) {
+  const ts   = state.tech_stack || {};
+  const dbs  = (ts.databases || []).join(', ') || 'None detected';
+  const lines = [
+    sectionHeader('Project Overview'),
+    `| Field | Value |`,
+    `|---|---|`,
+    `| **Project** | ${state.project} v${state.version} |`,
+    `| **Stage** | ${state.current_stage} |`,
+    `| **Language** | ${ts.language || '—'} |`,
+    `| **Framework** | ${ts.framework || '—'} |`,
+    `| **Runtime** | ${ts.runtime || '—'} |`,
+    `| **Package Manager** | ${ts.package_manager || '—'} |`,
+    `| **TypeScript** | ${ts.typescript ? 'Yes' : 'No'} |`,
+    `| **Databases** | ${dbs} |`,
+    `| **Test Framework** | ${ts.test_framework || 'None detected'} |`,
+    `| **Linter** | ${ts.linter || 'None'} |`,
+    `| **Bundler** | ${ts.bundler || 'None'} |`,
+    `| **Cloud / Deploy** | ${ts.cloud_platform || 'None detected'} |`,
+    `| **Last Updated** | ${state.last_updated} |`,
+    '',
+    `**Summary:** ${state.ai_summary}`,
+    '',
+    (state.description ? `**Description:** ${state.description}` : '')
+  ];
+  return lines.filter((l) => l !== '').join('\n');
+}
+
+function buildActiveErrors(state) {
+  const errors = (state.issue_tracker || {}).active_errors || [];
+  if (errors.length === 0) {
+    return sectionHeader('🔴 Active Errors') + '\n_No active errors. All clear._\n';
+  }
+  const lines = [sectionHeader('🔴 Active Errors (FIX THESE FIRST)')];
+  lines.push(`> **${errors.length} open error${errors.length !== 1 ? 's' : ''} — address before any new work.**\n`);
+  for (const e of errors) {
+    lines.push(`### ${e.id}`);
+    lines.push(`- **Message:** ${e.message}`);
+    if (e.file)  lines.push(`- **File:** \`${e.file}\``);
+    if (e.stack) lines.push(`- **Stack:**\n\`\`\`\n${e.stack.slice(0, 400)}\n\`\`\``);
+    lines.push(`- **Recorded:** ${e.timestamp}`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function buildResolvedIssues(state) {
+  const resolved = (state.issue_tracker || {}).resolved_issues || [];
+  if (resolved.length === 0) return '';
+  const lines = [sectionHeader('✅ Resolved Issues (History)')];
+  lines.push('_Read this before writing any fix — these bugs were already solved._\n');
+  for (const r of resolved.slice(0, 15)) {
+    lines.push(`- **${r.message}**`);
+    if (r.file)       lines.push(`  - File: \`${r.file}\``);
+    lines.push(`  - Fixed: ${r.resolved_at || r.timestamp}`);
+    lines.push(`  - How: ${r.resolution}`);
+  }
+  if (resolved.length > 15) lines.push(`\n_...and ${resolved.length - 15} more in state.json_`);
+  return lines.join('\n');
+}
+
+function buildRecentChanges(state) {
+  const changes = state.code_changes || [];
+  if (changes.length === 0) {
+    return sectionHeader('📝 Recent Code Changes') + '\n_No changes recorded yet._\n';
+  }
+  const lines = [sectionHeader('📝 Recent Code Changes')];
+  for (const c of changes.slice(0, 10)) {
+    lines.push(`### \`${c.file}\` — ${c.action} — ${c.timestamp}`);
+    lines.push(`**${c.summary}**`);
+    if (c.signals && c.signals.length) {
+      lines.push('');
+      lines.push('What changed:');
+      for (const sig of c.signals) lines.push(`- ${sig}`);
+    }
+    if (c.patch && c.patch.length < 2000) {
+      lines.push('');
+      lines.push('```diff');
+      lines.push(c.patch);
+      lines.push('```');
+    }
+    lines.push('');
+  }
+  if (changes.length > 10) lines.push(`_...and ${changes.length - 10} more in state.json → code_changes_`);
+  return lines.join('\n');
+}
+
+function buildFileStructure(state) {
+  const lines = [sectionHeader('📁 File Structure')];
+  lines.push('```');
+  lines.push(fileTreeToString(state.file_tree || {}));
+  lines.push('```');
+  return lines.join('\n');
+}
+
+function buildCodeCatalogue(state) {
+  const codeFiles = state.code_files || {};
+  const files     = Object.keys(codeFiles);
+  if (files.length === 0) return '';
+
+  const lines = [sectionHeader('🔍 Code Catalogue')];
+  lines.push('_Every source file with its functions and exports._\n');
+
+  for (const filePath of files) {
+    const info = codeFiles[filePath];
+    lines.push(`#### \`${filePath}\` (${info.lines} lines)`);
+
+    if (info.functions && info.functions.length) {
+      lines.push(`- **Functions:** ${info.functions.join(', ')}`);
+    }
+    if (info.classes && info.classes.length) {
+      lines.push(`- **Classes:** ${info.classes.join(', ')}`);
+    }
+    if (info.exports && info.exports.length) {
+      lines.push(`- **Exports:** ${info.exports.join(', ')}`);
+    }
+    if (info.imports && info.imports.length) {
+      lines.push(`- **Imports:** ${info.imports.join(', ')}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function buildApiRoutes(state) {
+  const routes = state.api_routes || [];
+  if (routes.length === 0) return '';
+
+  const lines = [sectionHeader('🛤 API Routes')];
+  lines.push('| Method | Path | File |');
+  lines.push('|---|---|---|');
+  for (const r of routes) {
+    lines.push(`| \`${r.method}\` | \`${r.path}\` | \`${r.file}\` |`);
+  }
+  return lines.join('\n');
+}
+
+function buildDependencies(state) {
+  const deps    = state.dependencies || {};
+  const prod    = Object.entries(deps.production  || {});
+  const dev     = Object.entries(deps.development || {});
+  const scripts = Object.entries(deps.scripts     || {});
+
+  const lines = [sectionHeader('📦 Dependencies & Scripts')];
+
+  if (prod.length) {
+    lines.push('**Production:**');
+    for (const [name, ver] of prod) lines.push(`- \`${name}\` ${ver}`);
+    lines.push('');
+  }
+  if (dev.length) {
+    lines.push('**Development:**');
+    for (const [name, ver] of dev) lines.push(`- \`${name}\` ${ver}`);
+    lines.push('');
+  }
+  if (scripts.length) {
+    lines.push('**Scripts:**');
+    lines.push('| Name | Command |');
+    lines.push('|---|---|');
+    for (const [name, cmd] of scripts) lines.push(`| \`${name}\` | \`${cmd}\` |`);
+  }
+  return lines.join('\n');
+}
+
+function buildEnvVariables(state) {
+  const vars = state.env_variables || [];
+  if (vars.length === 0) return '';
+
+  const lines = [sectionHeader('🔑 Environment Variables')];
+  lines.push('_All env vars referenced in source or .env files. Never invent undocumented ones._\n');
+  for (const v of vars) lines.push(`- \`${v}\``);
+  return lines.join('\n');
+}
+
+function buildArchitecture(state) {
+  const patterns = state.architecture_patterns || [];
+  const details  = state.implementation_details || [];
+  if (!patterns.length && !details.length) return '';
+
+  const lines = [sectionHeader('🏗 Architecture & Implementation')];
+
+  if (patterns.length) {
+    lines.push('**Patterns in use:**');
+    for (const p of patterns) lines.push(`- ${p}`);
+    lines.push('');
+  }
+  if (details.length) {
+    lines.push('**Implementation details:**');
+    for (const d of details) lines.push(`- ${d}`);
+  }
+  return lines.join('\n');
+}
+
+function buildKeyFeatures(state) {
+  const features = state.key_features || [];
+  if (!features.length) return '';
+
+  const lines = [sectionHeader('⚡ Key Features')];
+  for (const f of features) lines.push(`- ${f}`);
+  return lines.join('\n');
+}
+
+function buildWorkingContext(state) {
+  const lines = [sectionHeader('🎯 Working Context')];
+  let hasContent = false;
+
+  if (state.current_focus) {
+    lines.push(`**Current Focus:** ${state.current_focus}`);
+    hasContent = true;
+  }
+  if (state.working_branch) {
+    lines.push(`**Branch:** \`${state.working_branch}\``);
+    hasContent = true;
+  }
+
+  const questions = state.open_questions || [];
+  if (questions.length) {
+    lines.push('');
+    lines.push('**Open Questions:**');
+    for (const q of questions) {
+      lines.push(`- ${typeof q === 'string' ? q : q.question}`);
+    }
+    hasContent = true;
+  }
+
+  const decisions = state.decisions_made || [];
+  if (decisions.length) {
+    lines.push('');
+    lines.push('**Decisions Made (do not contradict these):**');
+    for (const d of decisions) {
+      lines.push(`- ${typeof d === 'string' ? d : d.decision}`);
+    }
+    hasContent = true;
+  }
+
+  const notes = state.session_notes || [];
+  if (notes.length) {
+    lines.push('');
+    lines.push('**Session Notes:**');
+    for (const n of notes.slice(0, 5)) {
+      lines.push(`- ${typeof n === 'string' ? n : n.note}`);
+    }
+    hasContent = true;
+  }
+
+  return hasContent ? lines.join('\n') : '';
+}
+
+function buildNextSteps(state) {
+  const steps  = state.next_steps   || [];
+  const issues = state.known_issues || [];
+  if (!steps.length && !issues.length) return '';
+
+  const lines = [sectionHeader('🚀 What To Do Next')];
+
+  if (issues.length) {
+    lines.push('**Known issues to resolve:**');
+    for (const i of issues) lines.push(`- ⚠️ ${i}`);
+    lines.push('');
+  }
+  if (steps.length) {
+    lines.push('**Recommended next steps:**');
+    for (const s of steps) lines.push(`- ${s}`);
+  }
+  return lines.join('\n');
+}
+
+function buildInstructions() {
+  return [
+    sectionHeader('📋 Instructions For The AI Reading This'),
+    '1. Read **Active Errors** first — fix those before anything else.',
+    '2. Read **Resolved Issues** before writing any fix — avoid re-introducing old bugs.',
+    '3. Read **Recent Code Changes** to understand what just changed and why.',
+    '4. Read **Code Catalogue** to know what each file exports before calling anything.',
+    '5. Read **API Routes** before adding or changing any endpoint.',
+    '6. Read **Dependencies** before suggesting `npm install` — the package may already exist.',
+    '7. Read **Working Context** to understand the current focus and locked-in decisions.',
+    '8. Read **What To Do Next** for prioritised next actions.',
+    '',
+    '> This file is auto-generated by aibridge-context on every startup and file change.',
+    '> Do not edit it manually — changes will be overwritten.',
+    '> The full machine-readable state is in `.ai-context/state.json`.',
+  ].join('\n');
+}
+
+// ─────────────────────────────────────────────────────────────────
+//  Main generator
+// ─────────────────────────────────────────────────────────────────
+
+function generateBriefing(state, projectRoot) {
+  const now       = new Date().toISOString();
+  const projName  = state.project || path.basename(projectRoot || process.cwd());
+
+  const sections = [
+    `# AI Briefing — ${projName}`,
+    '',
+    `> **Auto-generated by aibridge-context** | Last updated: ${now}`,
+    `> Paste this file into any AI assistant to immediately brief it on the full project state.`,
+    '',
+    buildInstructions(),
+    buildOverview(state),
+    buildActiveErrors(state),
+    buildResolvedIssues(state),
+    buildNextSteps(state),
+    buildWorkingContext(state),
+    buildRecentChanges(state),
+    buildFileStructure(state),
+    buildCodeCatalogue(state),
+    buildApiRoutes(state),
+    buildDependencies(state),
+    buildEnvVariables(state),
+    buildArchitecture(state),
+    buildKeyFeatures(state),
+    '',
+    '---',
+    `_Generated by [aibridge-context](https://github.com/npm/aibridge-context) • ${now}_`,
+  ];
+
+  return sections.filter((s) => s !== null && s !== undefined).join('\n');
+}
+
+module.exports = { generateBriefing };

package/core/codeDiff.js

@@ -0,0 +1,304 @@
+'use strict';
+
+/**
+ * codeDiff.js
+ * -----------
+ * Pure-JS line-level diff engine. No external deps.
+ * Produces a unified-diff-style patch and a human summary
+ * of what exactly changed in a file between two snapshots.
+ */
+
+const MAX_DIFF_LINES = 120; // cap stored diff size
+
+/**
+ * Myers diff – returns array of { op: 'eq'|'add'|'del', line }
+ */
+function myersDiff(oldLines, newLines) {
+  const N = oldLines.length;
+  const M = newLines.length;
+  const MAX = N + M;
+  if (MAX === 0) return [];
+
+  const v = new Array(2 * MAX + 1).fill(0);
+  const trail = [];
+
+  for (let d = 0; d <= MAX; d++) {
+    const snapshot = v.slice();
+    trail.push(snapshot);
+
+    for (let k = -d; k <= d; k += 2) {
+      let x;
+      if (k === -d || (k !== d && v[k - 1 + MAX] < v[k + 1 + MAX])) {
+        x = v[k + 1 + MAX];
+      } else {
+        x = v[k - 1 + MAX] + 1;
+      }
+      let y = x - k;
+      while (x < N && y < M && oldLines[x] === newLines[y]) { x++; y++; }
+      v[k + MAX] = x;
+      if (x >= N && y >= M) {
+        return buildOps(trail, d, oldLines, newLines, MAX);
+      }
+    }
+  }
+  return buildOps(trail, MAX, oldLines, newLines, MAX);
+}
+
+function buildOps(trail, d, oldLines, newLines, MAX) {
+  const ops = [];
+  let x = oldLines.length;
+  let y = newLines.length;
+
+  for (let step = d; step > 0; step--) {
+    const v = trail[step];
+    const k = x - y;
+    const prevK = (k === -step || (k !== step && v[k - 1 + MAX] < v[k + 1 + MAX]))
+      ? k + 1 : k - 1;
+    const prevX = v[prevK + MAX];
+    const prevY = prevX - prevK;
+
+    while (x > prevX + (x - prevX - (y - prevY)) && y > prevY + (y - prevY - (x - prevX))) {
+      ops.unshift({ op: 'eq', line: oldLines[x - 1] });
+      x--; y--;
+    }
+
+    if (step > 0) {
+      if (x === prevX) {
+        ops.unshift({ op: 'add', line: newLines[y - 1] });
+        y--;
+      } else {
+        ops.unshift({ op: 'del', line: oldLines[x - 1] });
+        x--;
+      }
+    }
+  }
+
+  while (x > 0) { ops.unshift({ op: 'eq', line: oldLines[x - 1] }); x--; }
+  return ops;
+}
+
+/**
+ * Produce a compact unified diff string from old/new text.
+ * Returns { patch, linesAdded, linesRemoved, summary }
+ */
+function diffTexts(oldText, newText, filePath) {
+  const oldLines = (oldText || '').split('\n');
+  const newLines = (newText || '').split('\n');
+
+  let linesAdded   = 0;
+  let linesRemoved = 0;
+  const patchLines = [`--- ${filePath}`, `+++ ${filePath}`];
+
+  // Use simpler LCS approach for large files to stay fast
+  if (oldLines.length + newLines.length > 2000) {
+    // Fast path: just count added/removed, no full diff
+    const oldSet = new Set(oldLines);
+    const newSet = new Set(newLines);
+    linesAdded   = newLines.filter((l) => !oldSet.has(l)).length;
+    linesRemoved = oldLines.filter((l) => !newSet.has(l)).length;
+    return {
+      patch:        `[diff too large – ${linesAdded} lines added, ${linesRemoved} lines removed]`,
+      linesAdded,
+      linesRemoved,
+      summary:      buildSummary(linesAdded, linesRemoved, filePath)
+    };
+  }
+
+  const ops = myersDiff(oldLines, newLines);
+  const CONTEXT = 3;
+  const hunks   = [];
+  let hunk      = null;
+  let oldLine   = 1;
+  let newLine   = 1;
+  let pending   = [];
+
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+
+    if (op.op === 'eq') {
+      if (hunk) {
+        pending.push({ op, oldLine, newLine });
+        if (pending.length > CONTEXT * 2) {
+          // Flush context
+          for (let j = 0; j < CONTEXT; j++) hunk.lines.push(` ${pending[j].op.line}`);
+          hunks.push(hunk);
+          hunk    = null;
+          pending = pending.slice(pending.length - CONTEXT);
+        }
+      } else {
+        pending.push({ op, oldLine, newLine });
+        if (pending.length > CONTEXT) pending.shift();
+      }
+      oldLine++; newLine++;
+    } else {
+      if (!hunk) {
+        const startOld = Math.max(1, oldLine - pending.length);
+        const startNew = Math.max(1, newLine - pending.length);
+        hunk = { startOld, startNew, oldCount: 0, newCount: 0, lines: [] };
+        for (const p of pending) hunk.lines.push(` ${p.op.line}`);
+        pending = [];
+      }
+      if (op.op === 'add') {
+        hunk.lines.push(`+${op.line}`);
+        hunk.newCount++;
+        linesAdded++;
+        newLine++;
+      } else {
+        hunk.lines.push(`-${op.line}`);
+        hunk.oldCount++;
+        linesRemoved++;
+        oldLine++;
+      }
+    }
+  }
+
+  if (hunk) {
+    for (let j = 0; j < Math.min(CONTEXT, pending.length); j++) {
+      hunk.lines.push(` ${pending[j].op.line}`);
+    }
+    hunks.push(hunk);
+  }
+
+  let totalLines = 0;
+  for (const h of hunks) {
+    const oldCount = (h.lines.filter((l) => l[0] !== '+').length);
+    const newCount = (h.lines.filter((l) => l[0] !== '-').length);
+    patchLines.push(`@@ -${h.startOld},${oldCount} +${h.startNew},${newCount} @@`);
+    for (const line of h.lines) {
+      patchLines.push(line);
+      totalLines++;
+      if (totalLines >= MAX_DIFF_LINES) {
+        patchLines.push(`[... diff truncated at ${MAX_DIFF_LINES} lines ...]`);
+        break;
+      }
+    }
+    if (totalLines >= MAX_DIFF_LINES) break;
+  }
+
+  return {
+    patch:        patchLines.join('\n'),
+    linesAdded,
+    linesRemoved,
+    summary:      buildSummary(linesAdded, linesRemoved, filePath)
+  };
+}
+
+function buildSummary(added, removed, filePath) {
+  const parts = [];
+  if (added   > 0) parts.push(`+${added} line${added   !== 1 ? 's' : ''}`);
+  if (removed > 0) parts.push(`-${removed} line${removed !== 1 ? 's' : ''}`);
+  if (parts.length === 0) return `No line changes in ${filePath}`;
+  return `${filePath}: ${parts.join(', ')}`;
+}
+
+/**
+ * Extract meaningful code-level signals from a diff patch.
+ * Returns array of human-readable strings like:
+ *   "Added function buildFileTree"
+ *   "Removed call to syncContextToGit"
+ *   "Modified exports block"
+ */
+function extractCodeSignals(patch, filePath) {
+  if (!patch || typeof patch !== 'string') return [];
+  const signals = [];
+  const ext     = (filePath || '').split('.').pop().toLowerCase();
+
+  if (['js', 'ts', 'mjs', 'cjs'].includes(ext)) {
+    extractJsSignals(patch, signals);
+  } else if (ext === 'json') {
+    extractJsonSignals(patch, signals, filePath);
+  } else if (ext === 'md') {
+    signals.push('Documentation updated');
+  }
+
+  return uniqueSignals(signals);
+}
+
+function extractJsSignals(patch, signals) {
+  const addedLines   = patch.split('\n').filter((l) => l.startsWith('+')).map((l) => l.slice(1));
+  const removedLines = patch.split('\n').filter((l) => l.startsWith('-')).map((l) => l.slice(1));
+
+  // Functions added/removed
+  const fnPattern = /\bfunction\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/;
+  const arrowFn   = /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s*)?\(/;
+  const methodFn  = /\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\(.*\)\s*\{/;
+
+  for (const line of addedLines) {
+    const m = fnPattern.exec(line) || arrowFn.exec(line);
+    if (m) signals.push(`Added function \`${m[1]}\``);
+  }
+  for (const line of removedLines) {
+    const m = fnPattern.exec(line) || arrowFn.exec(line);
+    if (m) signals.push(`Removed function \`${m[1]}\``);
+  }
+
+  // require/import changes
+  const reqPattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/;
+  for (const line of addedLines) {
+    const m = reqPattern.exec(line);
+    if (m) signals.push(`Added dependency on \`${m[1]}\``);
+  }
+  for (const line of removedLines) {
+    const m = reqPattern.exec(line);
+    if (m) signals.push(`Removed dependency on \`${m[1]}\``);
+  }
+
+  // exports changes
+  const exportsAdded   = addedLines.some((l) => /module\.exports|exports\./.test(l));
+  const exportsRemoved = removedLines.some((l) => /module\.exports|exports\./.test(l));
+  if (exportsAdded || exportsRemoved) signals.push('Modified module exports');
+
+  // Const/let additions
+  const constPattern = /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=/;
+  for (const line of addedLines.slice(0, 20)) {
+    const m = constPattern.exec(line);
+    if (m && !signals.some((s) => s.includes(m[1]))) {
+      signals.push(`Added \`${m[1]}\``);
+    }
+  }
+
+  // Error handling
+  if (addedLines.some((l) => /try\s*\{|catch\s*\(/.test(l))) signals.push('Added error handling');
+  if (addedLines.some((l) => /throw\s+new/.test(l)))         signals.push('Added throw statement');
+
+  // Async/await
+  if (addedLines.some((l) => /\basync\b/.test(l))) signals.push('Added async logic');
+
+  // Route definitions
+  const routePattern = /\b(?:router|app)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/;
+  for (const line of addedLines) {
+    const m = routePattern.exec(line);
+    if (m) signals.push(`Added route ${m[1].toUpperCase()} ${m[2]}`);
+  }
+  for (const line of removedLines) {
+    const m = routePattern.exec(line);
+    if (m) signals.push(`Removed route ${m[1].toUpperCase()} ${m[2]}`);
+  }
+}
+
+function extractJsonSignals(patch, signals, filePath) {
+  if (filePath && filePath.includes('package.json')) {
+    const addedLines   = patch.split('\n').filter((l) => l.startsWith('+')).map((l) => l.slice(1));
+    const removedLines = patch.split('\n').filter((l) => l.startsWith('-')).map((l) => l.slice(1));
+    const pkgPattern   = /"([a-z@][a-z0-9@/_-]*)"\s*:/;
+    for (const line of addedLines) {
+      const m = pkgPattern.exec(line);
+      if (m && !m[1].startsWith('name') && !m[1].startsWith('version')) {
+        signals.push(`Added package \`${m[1]}\``);
+      }
+    }
+    for (const line of removedLines) {
+      const m = pkgPattern.exec(line);
+      if (m) signals.push(`Removed package \`${m[1]}\``);
+    }
+    if (addedLines.some((l) => /"version"/.test(l))) signals.push('Version bumped');
+  } else {
+    signals.push('Config/data file updated');
+  }
+}
+
+function uniqueSignals(signals) {
+  return Array.from(new Set(signals)).slice(0, 10);
+}
+
+module.exports = { diffTexts, extractCodeSignals };