forge-workflow 0.0.9 → 0.0.10

package/lib/runtime-health.js

@@ -8,6 +8,7 @@
  */
 
 const fs = require('node:fs');
+const path = require('node:path');
 const { execFileSync: defaultExecFileSync } = require('node:child_process');
 
 const { checkLefthookStatus } = require('./lefthook-check');
@@ -76,31 +77,115 @@ function checkHookInstallation(projectRoot, options = {}) {
   const exec = options._exec || defaultExecFileSync;
   const platform = options.platform || process.platform;
   const expectedRelativeHooksPath = normalizeHooksPath('.lefthook/hooks', platform);
-  const expectedAbsoluteHooksPath = normalizeHooksPath(`${projectRoot}/${expectedRelativeHooksPath}`, platform);
+  const requiredHooks = ['pre-commit', 'pre-push'];
 
+  function resolveGitRoot() {
+    try {
+      const output = exec('git', ['rev-parse', '--show-toplevel'], {
+        cwd: projectRoot,
+        encoding: 'utf8'
+      });
+      return toText(output).trim() || projectRoot;
+    } catch {
+      return projectRoot;
+    }
+  }
+
+  const gitRoot = resolveGitRoot();
+  const expectedAbsoluteHooksPath = normalizeHooksPath(`${gitRoot}/${expectedRelativeHooksPath}`, platform);
+
+  function resolveGitHooksDir() {
+    try {
+      const output = exec('git', ['rev-parse', '--git-path', 'hooks'], {
+        cwd: projectRoot,
+        encoding: 'utf8'
+      });
+      const rawPath = toText(output).trim();
+      if (!rawPath) return null;
+      return path.isAbsolute(rawPath) ? rawPath : path.resolve(projectRoot, rawPath);
+    } catch {
+      return null;
+    }
+  }
+
+  function fileLooksLikeActiveHook(filePath) {
+    try {
+      const stat = fs.statSync(filePath);
+      const executable = platform === 'win32'
+        || (typeof options._canExecuteHook === 'function'
+          ? Boolean(options._canExecuteHook(filePath, stat))
+          : (stat.mode & 0o111) !== 0);
+      if (!stat.isFile() || stat.size === 0 || !executable) return false;
+      return /\blefthook\b/i.test(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+      return false;
+    }
+  }
+
+  let hooksPath = null;
   try {
     const output = exec('git', ['config', '--get', 'core.hooksPath'], {
       cwd: projectRoot,
       encoding: 'utf8'
     });
 
-    const hooksPath = normalizeHooksPath(output, platform);
+    hooksPath = normalizeHooksPath(output, platform);
     const active = hooksPath === expectedRelativeHooksPath || hooksPath === expectedAbsoluteHooksPath;
 
+    if (active) {
+      const hooksDir = path.join(gitRoot, '.lefthook', 'hooks');
+      const missingHooks = requiredHooks.filter(hook => !fileLooksLikeActiveHook(path.join(hooksDir, hook)));
+      const verifiedActive = missingHooks.length === 0;
+      return {
+        active: verifiedActive,
+        state: verifiedActive ? 'active' : 'inactive',
+        verification: 'core.hooksPath',
+        hooksPath: hooksPath || null,
+        hooksDir,
+        missingHooks,
+        message: verifiedActive
+          ? ''
+          : `Git hooks directory is missing required hooks: ${missingHooks.join(', ')}.`
+      };
+    }
+
+    if (hooksPath) {
+      return {
+        active: false,
+        state: 'inactive',
+        verification: 'core.hooksPath',
+        hooksPath,
+        message: `Git core.hooksPath is set to "${hooksPath}", not ".lefthook/hooks".`
+      };
+    }
+  } catch {
+    // Fall through to git-path fallback for worktree-safe verification
+  }
+
+  const hooksDir = resolveGitHooksDir();
+  if (hooksDir) {
+    const missingHooks = requiredHooks.filter(hook => !fileLooksLikeActiveHook(path.join(hooksDir, hook)));
+    const active = missingHooks.length === 0;
     return {
       active,
       state: active ? 'active' : 'inactive',
+      verification: 'git-path-hooks',
       hooksPath: hooksPath || null,
-      message: active ? '' : 'Git hooks are not pointed at .lefthook/hooks.'
-    };
-  } catch {
-    return {
-      active: false,
-      state: 'unverified',
-      hooksPath: null,
-      message: 'Git hooks could not be verified.'
+      hooksDir,
+      missingHooks,
+      message: active
+        ? ''
+        : `Git hooks directory is missing required hooks: ${missingHooks.join(', ')}.`
     };
   }
+
+  return {
+    active: false,
+    state: 'unverified',
+    verification: 'unverified',
+    hooksPath: hooksPath || null,
+    message: 'Git hooks could not be verified.'
+  };
 }
 
 function checkCommandAvailability(command, projectRoot, options = {}) {
@@ -219,8 +304,8 @@ function checkRuntimeHealth(projectRoot, options = {}) {
   const platform = options.platform || process.platform;
   const root = normalizeProjectRoot(projectRoot);
 
-  const lefthook = checkLefthookStatus(root);
   const hooks = checkHookInstallation(root, options);
+  const lefthook = checkLefthookStatus(root);
   const bd = checkCommandAvailability('bd', root, options);
   const gh = checkCommandAvailability('gh', root, options);
   const jq = checkCommandAvailability('jq', root, options);
@@ -228,7 +313,10 @@ function checkRuntimeHealth(projectRoot, options = {}) {
 
   const diagnostics = [];
 
-  if (lefthook.state !== 'installed') {
+  const lefthookMissing = lefthook.state === 'missing-dependency'
+    || lefthook.state === 'missing-binary';
+
+  if (lefthookMissing) {
     diagnostics.push(createDiagnostic(
       'LEFTHOOK_MISSING',
       'lefthook',

package/lib/smart-status/conflicts.js

@@ -0,0 +1,205 @@
+'use strict';
+
+function splitLines(value) {
+	if (!value) {
+		return [];
+	}
+
+	return String(value)
+		.replaceAll('\r', '')
+		.split('\n');
+}
+
+function uniqueStrings(values) {
+	const result = [];
+	const seen = new Set();
+
+	for (const value of values || []) {
+		if (typeof value !== 'string') {
+			continue;
+		}
+		const normalized = value.trim();
+		if (!normalized || seen.has(normalized)) {
+			continue;
+		}
+		seen.add(normalized);
+		result.push(normalized);
+	}
+
+	return result;
+}
+
+function parseWorktreePorcelain(porcelainText, baseBranch) {
+	const worktrees = [];
+	let currentPath = '';
+	let currentBranch = '';
+
+	for (const line of splitLines(porcelainText)) {
+		if (line.startsWith('worktree ')) {
+			currentPath = line.slice('worktree '.length);
+			continue;
+		}
+
+		if (line.startsWith('branch refs/heads/')) {
+			currentBranch = line.slice('branch refs/heads/'.length);
+			continue;
+		}
+
+		if (line !== '') {
+			continue;
+		}
+
+		if (currentBranch && currentBranch !== baseBranch) {
+			worktrees.push({ branch: currentBranch, path: currentPath });
+		}
+		currentPath = '';
+		currentBranch = '';
+	}
+
+	if (currentBranch && currentBranch !== baseBranch) {
+		worktrees.push({ branch: currentBranch, path: currentPath });
+	}
+
+	return worktrees;
+}
+
+function branchSlugToSearch(branch) {
+	const slug = String(branch || '').includes('/')
+		? String(branch).slice(String(branch).lastIndexOf('/') + 1)
+		: String(branch || '');
+	return slug.replaceAll('-', ' ').toLowerCase();
+}
+
+function matchInProgressIssues(worktrees, inProgressIssues) {
+	const issues = Array.isArray(inProgressIssues) ? inProgressIssues : [];
+
+	return (Array.isArray(worktrees) ? worktrees : []).map((worktree) => {
+		const slug = branchSlugToSearch(worktree.branch);
+		if (!slug) {
+			return {
+				branch: worktree.branch,
+				path: worktree.path,
+				issue_ids: [],
+				issue_count: 0,
+			};
+		}
+		const issueIds = issues
+			.filter((issue) => typeof issue?.title === 'string' && issue.title.toLowerCase().includes(slug))
+			.map((issue) => issue?.id)
+			.filter((issueId) => typeof issueId === 'string' && issueId);
+
+		return {
+			branch: worktree.branch,
+			path: worktree.path,
+			issue_ids: issueIds,
+			issue_count: issueIds.length,
+		};
+	});
+}
+
+function normalizeBranchFiles(branchFiles) {
+	if (Array.isArray(branchFiles)) {
+		return branchFiles
+			.filter((entry) => entry && typeof entry.branch === 'string')
+			.map((entry) => ({
+				branch: entry.branch,
+				files: Array.isArray(entry.files) ? uniqueStrings(entry.files) : [],
+			}));
+	}
+
+	if (branchFiles && typeof branchFiles === 'object') {
+		return Object.entries(branchFiles).map(([branch, files]) => ({
+			branch,
+			files: Array.isArray(files) ? uniqueStrings(files) : [],
+		}));
+	}
+
+	return [];
+}
+
+function computeFileConflicts(sessions, branchFiles) {
+	const branchFileEntries = normalizeBranchFiles(branchFiles);
+	const filesByBranch = new Map(branchFileEntries.map((entry) => [entry.branch, entry.files]));
+
+	return (Array.isArray(sessions) ? sessions : []).map((session) => {
+		const changedFiles = filesByBranch.get(session.branch) || [];
+		const conflicts = [];
+
+		for (const other of branchFileEntries) {
+			if (other.branch === session.branch || other.files.length === 0 || changedFiles.length === 0) {
+				continue;
+			}
+
+			const otherSet = new Set(other.files);
+			const overlap = uniqueStrings(changedFiles.filter((file) => otherSet.has(file)));
+			if (overlap.length > 0) {
+				conflicts.push({ branch: other.branch, files: overlap });
+			}
+		}
+
+		return {
+			...session,
+			changed_files: changedFiles,
+			conflicts,
+		};
+	});
+}
+
+function parseMergeTreeNameOnly(stdout) {
+	const lines = splitLines(stdout).filter((line, index) => index > 0 && line.trim().length > 0);
+	return uniqueStrings(lines);
+}
+
+function applyMergeTreeConflicts(sessions, mergeTreeResults) {
+	const nextSessions = (Array.isArray(sessions) ? sessions : []).map((session) => ({
+		...session,
+		merge_conflicts: Array.isArray(session.merge_conflicts) ? [...session.merge_conflicts] : [],
+	}));
+	const sessionIndexes = new Map(nextSessions.map((session, index) => [session.branch, index]));
+
+	for (const result of Array.isArray(mergeTreeResults) ? mergeTreeResults : []) {
+		if (!result || typeof result.left !== 'string' || typeof result.right !== 'string') {
+			continue;
+		}
+
+		const exitCode = Number(result.exitCode);
+		if (exitCode !== 1) {
+			continue;
+		}
+
+		const files = parseMergeTreeNameOnly(result.output);
+		if (files.length === 0) {
+			continue;
+		}
+
+		for (const [targetBranch, otherBranch] of [[result.left, result.right], [result.right, result.left]]) {
+			const index = sessionIndexes.get(targetBranch);
+			if (index === undefined) {
+				continue;
+			}
+
+			nextSessions[index].merge_conflicts.push({
+				branch: otherBranch,
+				files,
+			});
+		}
+	}
+
+	return nextSessions.map((session) => {
+		if (session.merge_conflicts.length === 0) {
+			const nextSession = { ...session };
+			delete nextSession.merge_conflicts;
+			return nextSession;
+		}
+
+		return session;
+	});
+}
+
+module.exports = {
+	applyMergeTreeConflicts,
+	computeFileConflicts,
+	matchInProgressIssues,
+	parseMergeTreeNameOnly,
+	parseWorktreePorcelain,
+};

package/lib/smart-status/scoring.js

@@ -0,0 +1,177 @@
+'use strict';
+
+function roundToTwo(value) {
+	return Math.round(value * 100) / 100;
+}
+
+function normalizePriorityNumber(priority) {
+	if (priority === undefined || priority === null) {
+		return 2;
+	}
+
+	if (typeof priority === 'string') {
+		switch (priority) {
+			case 'P0':
+				return 0;
+			case 'P1':
+				return 1;
+			case 'P2':
+				return 2;
+			case 'P3':
+				return 3;
+			case 'P4':
+				return 4;
+			default:
+				return 5;
+		}
+	}
+
+	return priority;
+}
+
+function getPriorityWeight(priority) {
+	switch (normalizePriorityNumber(priority)) {
+		case 0:
+			return 5;
+		case 1:
+			return 4;
+		case 2:
+			return 3;
+		case 3:
+			return 2;
+		case 4:
+			return 1;
+		default:
+			return 1;
+	}
+}
+
+function getTypeWeight(type = 'task') {
+	const normalizedType = type ?? 'task';
+	if (normalizedType === 'bug') {
+		return 1.2;
+	}
+	if (normalizedType === 'feature') {
+		return 1;
+	}
+	if (normalizedType === 'task') {
+		return 0.8;
+	}
+	return 1;
+}
+
+function getStatusBoost(status) {
+	if (status === 'in_progress') {
+		return 1.5;
+	}
+	if (status === 'open') {
+		return 1;
+	}
+	return 1;
+}
+
+function parseUpdatedAtLikeShell(updatedAt) {
+	if (!updatedAt) {
+		return null;
+	}
+
+	const normalized = `${String(updatedAt).slice(0, 19)}Z`;
+	const timestamp = Date.parse(normalized);
+	return Number.isFinite(timestamp) ? timestamp : null;
+}
+
+function getStalenessBoost(updatedAt, now = Date.now()) {
+	const timestamp = parseUpdatedAtLikeShell(updatedAt);
+	if (timestamp === null) {
+		return 1;
+	}
+
+	const days = (now - timestamp) / 86400000;
+	if (days >= 30) {
+		return 1.5;
+	}
+	if (days >= 14) {
+		return 1.2;
+	}
+	if (days >= 7) {
+		return 1.1;
+	}
+	return 1;
+}
+
+function buildDependentsMap(issues) {
+	const dependentsMap = new Map();
+
+	for (const issue of issues) {
+		for (const dependency of issue.dependencies ?? []) {
+			const dependencyId = dependency?.depends_on_id;
+			if (!dependencyId) {
+				continue;
+			}
+			if (!dependentsMap.has(dependencyId)) {
+				dependentsMap.set(dependencyId, []);
+			}
+			dependentsMap.get(dependencyId).push(issue.id);
+		}
+	}
+
+	return dependentsMap;
+}
+
+function getEpicProximity(issue, epicStats) {
+	if (!issue.parent_id || !epicStats?.[issue.parent_id]) {
+		return 1;
+	}
+
+	const stats = epicStats[issue.parent_id];
+	if (stats.total <= 0) {
+		return 1;
+	}
+
+	return 1 + ((stats.closed / stats.total) * 0.5);
+}
+
+function scoreIssues(issues, options = {}) {
+	const epicStats = options.epicStats ?? {};
+	const now = options.now ?? Date.now();
+	const dependentsMap = buildDependentsMap(issues);
+
+	return [...issues]
+		.map((issue) => {
+			const priorityWeight = getPriorityWeight(issue.priority);
+			const directDependents = issue.dependent_count ?? dependentsMap.get(issue.id)?.length ?? 0;
+			const unblockChain = Math.max(directDependents + 1, 1);
+			const typeWeight = getTypeWeight(issue.type);
+			const statusBoost = getStatusBoost(issue.status);
+			const epicProximity = getEpicProximity(issue, epicStats);
+			const stalenessBoost = getStalenessBoost(issue.updated_at, now);
+			const dependents = dependentsMap.get(issue.id) ?? [];
+			const score = priorityWeight
+				* unblockChain
+				* typeWeight
+				* statusBoost
+				* epicProximity
+				* stalenessBoost;
+
+			return {
+				...issue,
+				score: roundToTwo(score),
+				priority_weight: priorityWeight,
+				unblock_chain: unblockChain,
+				type_weight: typeWeight,
+				status_boost: statusBoost,
+				epic_proximity: roundToTwo(epicProximity),
+				staleness_boost: stalenessBoost,
+				dependents,
+			};
+		})
+		.sort((left, right) => right.score - left.score);
+}
+
+module.exports = {
+	getPriorityWeight,
+	getStalenessBoost,
+	getStatusBoost,
+	getTypeWeight,
+	scoreIssues,
+};

package/lib/status/beads-snapshot.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { secureExecFileSync } = require('../shell-utils.js');
+
+function getGitConfig(projectRoot, key) {
+	try {
+		return secureExecFileSync('git', ['config', key], {
+			encoding: 'utf8',
+			cwd: projectRoot,
+			stdio: ['pipe', 'pipe', 'pipe'],
+		}).trim();
+	} catch (_error) {
+		return '';
+	}
+}
+
+function getDeveloperIdentity(projectRoot) {
+	return {
+		email: getGitConfig(projectRoot, 'user.email'),
+		name: getGitConfig(projectRoot, 'user.name'),
+	};
+}
+
+function normalizeEmail(value) {
+	return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+
+function readIssues(projectRoot) {
+	const issuesPath = path.join(projectRoot, '.beads', 'issues.jsonl');
+	if (!fs.existsSync(issuesPath)) {
+		return [];
+	}
+
+	const raw = fs.readFileSync(issuesPath, 'utf8');
+	const latestById = new Map();
+
+	for (const line of raw.split(/\r?\n/)) {
+		if (!line.trim()) {
+			continue;
+		}
+
+		try {
+			const issue = JSON.parse(line);
+			if (issue && issue.id) {
+				latestById.set(issue.id, issue);
+			}
+		} catch (_error) {
+			// Ignore malformed rows so one bad append does not break status.
+		}
+	}
+
+	return Array.from(latestById.values());
+}
+
+function isAssignedToDeveloper(issue, developer) {
+	if (!issue || !developer) {
+		return false;
+	}
+
+	if (issue.owner) {
+		const developerEmail = normalizeEmail(developer.email);
+		return developerEmail !== '' && normalizeEmail(issue.owner) === developerEmail;
+	}
+
+	return developer.name !== '' && issue.created_by === developer.name;
+}
+
+function parseTimestampOrZero(value) {
+	if (!value) {
+		return 0;
+	}
+
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? 0 : parsed;
+}
+
+function sortByUpdatedAtDesc(left, right) {
+	const leftTime = parseTimestampOrZero(left.updated_at);
+	const rightTime = parseTimestampOrZero(right.updated_at);
+	return rightTime - leftTime;
+}
+
+function readBeadsSnapshot(projectRoot) {
+	const developer = getDeveloperIdentity(projectRoot);
+	const issues = readIssues(projectRoot);
+
+	return {
+		developer,
+		issues,
+		activeAssigned: issues.filter(issue => issue.status === 'in_progress' && isAssignedToDeveloper(issue, developer)),
+		ready: issues.filter(issue => issue.status === 'open' && Number(issue.dependency_count || 0) === 0),
+		recentCompleted: issues.filter(issue => issue.status === 'closed').sort(sortByUpdatedAtDesc),
+	};
+}
+
+module.exports = {
+	getDeveloperIdentity,
+	isAssignedToDeveloper,
+	readBeadsSnapshot,
+};

package/lib/status/presenter.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const DEFAULT_SECTION_LIMIT = 5;
+
+function buildSection(title, items, options = {}) {
+	const lines = ['', title];
+	if (!items || items.length === 0) {
+		lines.push('  none', '');
+		return lines;
+	}
+
+	const limit = options.limit ?? null;
+	const visibleItems = limit ? items.slice(0, limit) : items;
+	lines.push(...visibleItems.map(item => `  ${item}`));
+
+	if (limit && items.length > limit) {
+		lines.push(`  ...and ${items.length - limit} more`);
+	}
+
+	lines.push('');
+	return lines;
+}
+
+function formatIssue(issue, options = {}) {
+	const status = options.includeStatus && issue.status ? ` [${issue.status}]` : '';
+	return `${issue.id} ${issue.title || '(untitled)'}${status}`;
+}
+
+function formatWorkflow(workflowResult) {
+	if (!workflowResult) {
+		return ['No active workflow state detected.'];
+	}
+
+	return [
+		`${workflowResult.stageName} (${workflowResult.stageId})`,
+		`Run now: /${workflowResult.runCommand}`,
+		workflowResult.nextCommand ? `Next after this: /${workflowResult.nextCommand}` : 'Next after this: none',
+	];
+}
+
+function formatZeroArgStatus({ context, snapshot, workflowResult = null }) {
+	const contextLines = [
+		`Branch: ${context.branch}`,
+		`Worktree: ${context.inWorktree ? 'linked' : 'main'}`,
+		`Path: ${context.worktreePath}`,
+	];
+
+	if (context.inWorktree && context.mainWorktree) {
+		contextLines.push(`Main worktree: ${context.mainWorktree}`);
+	}
+
+	contextLines.push(`Working tree: ${context.workingTree.summary}`);
+
+	return [
+		...buildSection('Context', contextLines),
+		...buildSection('Active Issues', (snapshot.activeAssigned || []).map(issue => formatIssue(issue, { includeStatus: true }))),
+		...buildSection('Ready', (snapshot.ready || []).map(issue => formatIssue(issue)), { limit: DEFAULT_SECTION_LIMIT }),
+		...buildSection('Recent Completions', (snapshot.recentCompleted || []).map(issue => formatIssue(issue)), { limit: DEFAULT_SECTION_LIMIT }),
+		...buildSection('Workflow', formatWorkflow(workflowResult)),
+	].join('\n');
+}
+
+module.exports = {
+	formatZeroArgStatus,
+};