forge-workflow 0.0.8 → 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/setup-action-log.js

@@ -14,6 +14,8 @@ const AGENT_PREFIXES = {
   '.windsurf/': 'Windsurf',
   '.cline/': 'Cline',
   '.codex/': 'Codex',
+  '~/.codex/': 'Codex',
+  '$CODEX_HOME/': 'Codex',
   '.opencode/': 'OpenCode',
   '.kilocode/': 'Kilocode',
   '.roo/': 'Roo Code',

package/lib/setup-summary-renderer.js

@@ -26,11 +26,11 @@ function capitalize(str) {
  * @param {boolean} verbose - Whether to show file-by-file detail
  * @returns {string} The formatted summary output
  */
-function renderSetupSummary(actionLog, agentNames, verbose) {
+function renderSetupSummary(actionLog, agentNames, verbose, options = {}) {
   if (verbose) {
-    return renderVerbose(actionLog, agentNames);
+    return renderVerbose(actionLog, agentNames, options);
   }
-  return renderDefault(actionLog, agentNames);
+  return renderDefault(actionLog, agentNames, options);
 }
 
 /**
@@ -40,10 +40,11 @@ function renderSetupSummary(actionLog, agentNames, verbose) {
  * @param {string[]} agentNames
  * @returns {string}
  */
-function renderDefault(actionLog, agentNames) {
+function renderDefault(actionLog, agentNames, options = {}) {
   const agentCount = agentNames.length;
   const agentLabel = agentCount === 1 ? '1 agent' : `${agentCount} agents`;
   const agentList = agentNames.length > 0 ? ` (${agentNames.join(', ')})` : '';
+  const status = options.status === 'partial' ? 'partially complete' : 'complete';
 
   const summary = actionLog.getSummary();
 
@@ -63,7 +64,7 @@ function renderDefault(actionLog, agentNames) {
   }
 
   const lines = [];
-  lines.push(`Forge setup complete — ${agentLabel} configured${agentList}`);
+  lines.push(`Forge setup ${status} — ${agentLabel} configured${agentList}`);
 
   if (parts.length > 0) {
     lines.push(`  ${parts.join(' | ')}`);
@@ -83,10 +84,18 @@ function renderDefault(actionLog, agentNames) {
  * @param {string[]} _agentNames - Not used in verbose (agents come from log data)
  * @returns {string}
  */
-function renderVerbose(actionLog, _agentNames) {
+function renderVerbose(actionLog, _agentNames, options = {}) {
   const agentSummary = actionLog.getAgentSummary();
+  const status = options.status === 'partial' ? 'partially complete' : 'complete';
   const lines = [];
 
+  if (Object.keys(agentSummary).length === 0) {
+    return 'No file operations recorded.';
+  }
+
+  lines.push(`Forge setup ${status}`);
+  lines.push('');
+
   for (const [agent, actions] of Object.entries(agentSummary)) {
     for (const [action, files] of Object.entries(actions)) {
       const fileCount = files.length;
@@ -95,11 +104,6 @@ function renderVerbose(actionLog, _agentNames) {
       lines.push(`${agent}: ${fileList} (${fileLabel}) [${action}]`);
     }
   }
-
-  if (lines.length === 0) {
-    return 'No file operations recorded.';
-  }
-
   return lines.join('\n');
 }
 

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,
+};