buddy-workbench 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/branch-health.js

@@ -8,13 +8,14 @@ import { addBranchHealthHistory, listBranchHealthHistory } from '../repositories
 const router = Router();
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT = 30 * 1000;
+const COMPLEX_ANALYSIS_MAX_AGE_DAYS = 365;
 
 async function git(folder, args, options = {}) {
   try {
     const result = await execFileAsync('git', args, {
       cwd: folder,
       timeout: GIT_TIMEOUT,
-      maxBuffer: 4 * 1024 * 1024
+      maxBuffer: options.maxBuffer || 4 * 1024 * 1024
     });
     return result.stdout.trim();
   } catch (error) {
@@ -49,9 +50,8 @@ function workspaceRepositoryCandidates(workspaceDir) {
 
 function parseRefList(raw) {
   return raw.split(/\r?\n/).filter(Boolean).map((line) => {
-    const separatorIndex = line.indexOf(' ');
-    const ref = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
-    const hash = separatorIndex === -1 ? '' : line.slice(separatorIndex + 1).trim();
+    const refFields = line.split('\t', 1)[0].trim().split(/\s+/);
+    const [ref, hash] = refFields;
     if (!ref || !hash) return null;
     const remote = ref.startsWith('refs/remotes/');
     const remoteMatch = ref.match(/^refs\/remotes\/([^/]+)\/(.+)$/);
@@ -75,13 +75,61 @@ function parseCommit(raw) {
   };
 }
 
-function parseFirstCommit(raw) {
-  const [timestamp, date, name, email] = raw.split('\x1f');
-  const numericTimestamp = Number(timestamp);
-  return {
-    createdAt: Number.isFinite(numericTimestamp) ? new Date(numericTimestamp * 1000).toISOString() : date || null,
-    creator: { name: name || '', email: email || '' }
-  };
+function parseCommitMetadata(raw) {
+  const commits = new Map();
+  raw.split(/\r?\n/).filter(Boolean).forEach((line) => {
+    const separatorIndex = line.indexOf('\t');
+    if (separatorIndex < 0) return;
+    const metadata = parseCommit(line.slice(separatorIndex + 1));
+    if (metadata?.hash) commits.set(metadata.hash, metadata);
+  });
+  return commits;
+}
+
+function parseCommitGraph(raw) {
+  const parentsByCommit = new Map();
+  const childrenByCommit = new Map();
+  const commitsByHash = new Map();
+  raw.split(/\r?\n/).filter(Boolean).forEach((line) => {
+    const fields = line.split('\x1f');
+    const commit = fields[0];
+    if (!commit) return;
+    const parents = (fields[1] || '').split(' ').filter(Boolean);
+    parentsByCommit.set(commit, parents);
+    const metadata = parseCommit([commit, ...fields.slice(2)].join('\x1f'));
+    if (metadata) commitsByHash.set(commit, metadata);
+    parents.forEach((parent) => {
+      if (!childrenByCommit.has(parent)) childrenByCommit.set(parent, new Set());
+      childrenByCommit.get(parent).add(commit);
+    });
+  });
+  return { parentsByCommit, childrenByCommit, commitsByHash };
+}
+
+function reachableCommits(tip, parentsByCommit) {
+  const seen = new Set();
+  const pending = [tip];
+  while (pending.length) {
+    const commit = pending.pop();
+    if (!commit || seen.has(commit)) continue;
+    seen.add(commit);
+    for (const parent of parentsByCommit.get(commit) || []) pending.push(parent);
+  }
+  return seen;
+}
+
+function isAncestor(ancestor, descendant, childrenByCommit) {
+  if (!ancestor || !descendant) return false;
+  const seen = new Set();
+  const pending = [ancestor];
+  while (pending.length) {
+    const commit = pending.pop();
+    if (commit === descendant) return true;
+    if (seen.has(commit)) continue;
+    seen.add(commit);
+    for (const child of childrenByCommit.get(commit) || []) pending.push(child);
+  }
+  return false;
 }
 
 function isProtectedBranch(name) {
@@ -111,19 +159,17 @@ function healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRe
   return { status: 'keep', label: 'Keep', score };
 }
 
-async function readBranchDetails(folder, branch, refs, targetRef, currentBranch) {
+async function readBranchDetails(folder, branch, refs, targetRef, currentBranch, commit, creator, branchCount, parentsByCommit, childrenByCommit, branchAncestors, targetAncestors) {
   const ref = branch.localRef || branch.remoteRef;
-  const commit = parseCommit(await git(folder, [
-    'show', '-s', '--format=%H%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%cn%x1f%ce', ref
-  ], { allowFailure: true }));
   if (!commit) return null;
 
-  let firstCommit = parseFirstCommit(await git(folder, [
-    'log', '--reverse', '--format=%ct%x1f%aI%x1f%an%x1f%ae', '-1', ref
-  ], { allowFailure: true }));
-  let createdAtSource = 'first commit (inferred)';
+  let firstCommit = creator ? { creator } : null;
+  let createdAtSource = 'not available from bulk scan';
+  const ageDays = dateAgeDays(commit.committedAt || commit.authoredAt);
+  const runComplexAnalysis = ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+  if (!runComplexAnalysis) createdAtSource = 'not analyzed (last commit older than 365 days)';
 
-  if (branch.localRef) {
+  if (runComplexAnalysis && branch.localRef) {
     const reflog = await git(folder, ['reflog', 'show', '--format=%ct%x1f%cI%x1f%gs', branch.localRef], { allowFailure: true });
     const earliestEntry = reflog.split(/\r?\n/).filter(Boolean).at(-1);
     if (earliestEntry) {
@@ -139,27 +185,23 @@ async function readBranchDetails(folder, branch, refs, targetRef, currentBranch)
     }
   }
 
-  const branchCount = Number(await git(folder, ['rev-list', '--count', ref], { allowFailure: true })) || 0;
-  const containingRefs = parseRefList(await git(folder, [
-    'for-each-ref', '--contains', commit.hash, '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'
-  ], { allowFailure: true }));
-  const containingNames = [...new Set(containingRefs.map((item) => item.name).filter((name) => name !== branch.name))];
+  const containingNames = runComplexAnalysis
+    ? [...new Set(refs.filter((item) => item.name !== branch.name && isAncestor(commit.hash, item.hash, childrenByCommit)).map((item) => item.name))]
+    : [];
   const protectedContaining = containingNames.filter(isProtectedBranch);
   // A child branch containing main's commit is not evidence that main was
   // merged into that child. Only protected/default targets count as merge
   // evidence for cleanup decisions in this local-only phase.
   const mergedInto = protectedContaining[0] || null;
-  const merged = Boolean(mergedInto);
-
-  let ahead = 0;
-  let behind = 0;
-  if (targetRef && ref !== targetRef) {
-    const counts = (await git(folder, ['rev-list', '--left-right', '--count', `${targetRef}...${ref}`], { allowFailure: true })).split(/\s+/).map(Number);
-    behind = Number.isFinite(counts[0]) ? counts[0] : 0;
-    ahead = Number.isFinite(counts[1]) ? counts[1] : 0;
+  const merged = runComplexAnalysis ? Boolean(mergedInto) : false;
+
+  let ahead = runComplexAnalysis ? 0 : null;
+  let behind = runComplexAnalysis ? 0 : null;
+  if (runComplexAnalysis && targetRef && ref !== targetRef) {
+    ahead = [...branchAncestors].filter((hash) => !targetAncestors.has(hash)).length;
+    behind = [...targetAncestors].filter((hash) => !branchAncestors.has(hash)).length;
   }
 
-  const ageDays = dateAgeDays(commit.committedAt || commit.authoredAt);
   const isCurrent = !branch.remote && currentBranch === branch.name;
   const isProtected = isProtectedBranch(branch.name);
   const health = healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRemote: Boolean(branch.remoteRef) });
@@ -178,16 +220,17 @@ async function readBranchDetails(folder, branch, refs, targetRef, currentBranch)
     lastCommit: commit,
     ageDays,
     commitCount: branchCount,
+    analysisSkipped: !runComplexAnalysis,
     ahead,
     behind,
     merged,
     mergedInto,
     mergedIntoAll: protectedContaining,
-    mergeSource: merged ? 'local ancestry (inferred)' : 'not found in local refs',
+    mergeSource: !runComplexAnalysis ? 'skipped (last commit older than 365 days)' : merged ? 'local ancestry (inferred)' : 'not found in local refs',
     openPullRequest: null,
     health,
     reasons: [
-      merged ? `Merged into ${mergedInto}` : 'No containing target branch found',
+      !runComplexAnalysis ? 'Complex ancestry analysis skipped for branches inactive over one year' : merged ? `Merged into ${mergedInto}` : 'No containing target branch found',
       ageDays >= 90 ? `${ageDays} days since last commit` : null,
       ahead > 0 ? `${ahead} commits not in the default branch` : null,
       isCurrent ? 'Currently checked out' : null,
@@ -201,12 +244,22 @@ async function scanRepository(folder) {
   const root = resolve(folder);
   if (!existsSync(join(root, '.git'))) throw new Error(`Not a Git repository: ${root}`);
 
-  const [currentBranch, remoteUrl, refsRaw] = await Promise.all([
+  const [currentBranch, remoteUrl, refsAndMetadataRaw] = await Promise.all([
     git(root, ['branch', '--show-current'], { allowFailure: true }),
     git(root, ['remote', 'get-url', 'origin'], { allowFailure: true }),
-    git(root, ['for-each-ref', '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'])
+    git(root, ['for-each-ref', '--format=%(refname) %(objectname)%09%(objectname)%1f%(objectname:short)%1f%(subject)%1f%(authorname)%1f%(authoremail:trim)%1f%(authordate:iso-strict)%1f%(committerdate:iso-strict)%1f%(committername)%1f%(committeremail:trim)', 'refs/heads', 'refs/remotes'])
   ]);
-  const refs = parseRefList(refsRaw);
+  const refs = parseRefList(refsAndMetadataRaw);
+  const commitMetadata = parseCommitMetadata(refsAndMetadataRaw);
+  const graphTips = [...new Set(refs.filter((item) => {
+    const commit = commitMetadata.get(item.hash);
+    const ageDays = dateAgeDays(commit?.committedAt || commit?.authoredAt);
+    return isProtectedBranch(item.name) || ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+  }).map((item) => item.hash))];
+  const graphRaw = graphTips.length > 0
+    ? await git(root, ['log', '--parents', '--format=%H%x1f%P%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%cn%x1f%ce', ...graphTips], { maxBuffer: 128 * 1024 * 1024 })
+    : '';
+  const { parentsByCommit, childrenByCommit, commitsByHash } = parseCommitGraph(graphRaw);
 
   // Remote refs are normalized to their branch name so local and origin/main
   // are presented as one row when both are available.
@@ -223,9 +276,30 @@ async function scanRepository(folder) {
   const targetName = preferredTargets.find((name) => normalized.has(name)) || [...normalized.keys()].find(isProtectedBranch) || null;
   const targetBranch = targetName ? normalized.get(targetName) : null;
   const targetRef = targetBranch?.localRef || targetBranch?.remoteRef || null;
+  const targetHash = refs.find((item) => item.ref === targetRef)?.hash;
+  const targetAncestors = targetHash ? reachableCommits(targetHash, parentsByCommit) : new Set();
   const details = [];
   for (const branch of normalized.values()) {
-    const detail = await readBranchDetails(root, branch, refs, targetRef, currentBranch);
+    const ref = branch.localRef || branch.remoteRef;
+    const tip = refs.find((item) => item.ref === ref)?.hash;
+    const commit = commitMetadata.get(tip) || null;
+    const ageDays = dateAgeDays(commit?.committedAt || commit?.authoredAt);
+    const runComplexAnalysis = ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+    const branchAncestors = runComplexAnalysis ? reachableCommits(tip, parentsByCommit) : null;
+    const branchCount = branchAncestors?.size ?? null;
+    let creator = null;
+    if (branchAncestors) {
+      let firstCommitTimestamp = Infinity;
+      for (const hash of branchAncestors) {
+        const candidate = commitsByHash.get(hash);
+        const timestamp = Date.parse(candidate?.authoredAt || '');
+        if (candidate && Number.isFinite(timestamp) && timestamp < firstCommitTimestamp) {
+          firstCommitTimestamp = timestamp;
+          creator = candidate.author;
+        }
+      }
+    }
+    const detail = await readBranchDetails(root, branch, refs, targetRef, currentBranch, commit, creator, branchCount, parentsByCommit, childrenByCommit, branchAncestors, targetAncestors);
     if (detail) details.push(detail);
   }
 
@@ -237,8 +311,9 @@ async function scanRepository(folder) {
     scannedAt: new Date().toISOString(),
     analysis: {
       source: 'local Git',
+      complexAnalysisMaxAgeDays: COMPLEX_ANALYSIS_MAX_AGE_DAYS,
       mergeEvidence: 'Local ref ancestry; remote PR history is not queried in this phase.',
-      creationEvidence: 'Local reflog when available, otherwise first commit date.'
+      creationEvidence: 'Local reflog for recently active local branches; older branches skip creation and ancestry analysis.'
     }
   };
 }
@@ -262,6 +337,7 @@ function deletionChecks(branch) {
   if (!branch.hasLocal && !branch.hasRemote) blockers.push('Branch no longer exists in local or origin refs.');
   if (branch.current) blockers.push('The current branch cannot be deleted.');
   if (branch.protected) blockers.push('Protected branch patterns cannot be deleted.');
+  if (branch.analysisSkipped) blockers.push('Complex ancestry analysis was skipped for this branch, so deletion cannot be verified.');
   if (!branch.merged) blockers.push('The branch head is not contained in another local ref.');
   if (branch.ahead > 0) blockers.push(`${branch.ahead} commit(s) are not in the default branch.`);
 

package/server/routes/overview.js

@@ -4,8 +4,12 @@ import { Router } from 'express';
 import { readSettings } from '../repositories/settings.js';
 import { listTodos } from '../repositories/todos.js';
 import { recordApiError } from '../lib/api-errors.js';
+import { readFileSync } from 'node:fs';
+import { root } from '../config.js';
+import { join } from 'node:path';
 
 const router = Router();
+const serverVersion = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).version;
 const httpClient = axios.create({
   httpsAgent: new https.Agent({ rejectUnauthorized: false }),
   validateStatus: () => true,
@@ -15,6 +19,8 @@ const httpClient = axios.create({
 const isSuccess = (response) => response.status >= 200 && response.status < 300;
 const apiMessage = (response, fallback) => response?.data?.errors?.[0]?.message || response?.data?.errorMessages?.[0] || response?.data?.message || response?.statusText || fallback;
 
+router.get('/version', (_req, res) => res.json({ version: serverVersion }));
+
 function jiraHost(domain) {
   const clean = String(domain || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
   if (!clean) return '';