forge-workflow 0.0.8 → 0.0.9

package/lib/commands/status.js

@@ -3,12 +3,16 @@
  * Detects workflow stage (1-9) with confidence scoring
  */
 
-const { secureExecFileSync } = require('../shell-utils');
 const {
 	readWorkflowState,
 	getAllowedTransitionsForWorkflowState,
 } = require('../workflow/state');
 const { STAGE_IDS } = require('../workflow/stages');
+const {
+	loadState,
+	extractWorkflowStateFromComments,
+	readWorkflowStateFromBeads,
+} = require('../workflow/state-manager');
 
 const WORKFLOW_STAGES = {
 	1: { name: 'Fresh Start', nextCommand: 'research' },
@@ -338,42 +342,22 @@ function parseStatusInputs(args = [], flags = {}) {
 		issueId: flags.issueId || flags['--issue-id'] || getInlineValue('--issue-id') || getNextValue('--issue-id'),
 		workflowState: flags.workflowState || flags['--workflow-state'] || getInlineValue('--workflow-state') || getNextValue('--workflow-state'),
 		bdComments: flags.bdComments || flags['--bd-comments'] || getInlineValue('--bd-comments') || getNextValue('--bd-comments'),
+		projectRoot: flags.projectRoot || flags['--project-root'] || getInlineValue('--project-root') || getNextValue('--project-root') || null,
 	};
 }
 
-function extractWorkflowStateFromComments(comments = '') {
-	const matches = String(comments).match(/^WorkflowState:\s*(\{.*\})$/gm);
-	if (!matches || matches.length === 0) {
-		return null;
-	}
-
-	const latest = matches.at(-1).replace(/^WorkflowState:\s*/, '');
-	return readWorkflowState(latest);
-}
-
-function readWorkflowStateFromBeads(issueId, options = {}) {
-	if (!issueId) {
-		return null;
-	}
-
-	const comments = options.comments || secureExecFileSync('bd', ['comments', 'list', issueId], {
-		encoding: 'utf8',
-		stdio: ['pipe', 'pipe', 'pipe'],
-	}).trim();
-
-	if (!comments) {
-		return null;
-	}
-
-	return extractWorkflowStateFromComments(comments);
-}
-
 function resolveWorkflowState(inputs) {
 	try {
-		const workflowState = inputs.workflowState
-			? readWorkflowState(inputs.workflowState)
-			: readWorkflowStateFromBeads(inputs.issueId, { comments: inputs.bdComments });
-		return { workflowState, fallbackReason: null };
+		if (inputs.workflowState) {
+			return { workflowState: readWorkflowState(inputs.workflowState), fallbackReason: null };
+		}
+
+		const { state } = loadState(inputs.projectRoot, {
+			issueId: inputs.issueId,
+			comments: inputs.bdComments,
+		});
+
+		return { workflowState: state, fallbackReason: null };
 	} catch (error) {
 		return {
 			workflowState: null,
@@ -512,8 +496,11 @@ function formatStatus(result) {
 module.exports = {
 	name: 'status',
 	description: 'Intelligent stage detection with confidence scoring',
-	handler: async (args, flags, _projectRoot) => {
+	handler: async (args, flags, projectRoot) => {
 		const inputs = parseStatusInputs(args, flags);
+		if (!inputs.projectRoot && projectRoot) {
+			inputs.projectRoot = projectRoot;
+		}
 		const { workflowState, fallbackReason } = resolveWorkflowState(inputs);
 
 		if (workflowState) {

package/lib/commands/test.js

@@ -60,19 +60,7 @@ function checkBeadsConnectivity(execFileSync) {
 	}
 }
 
-/**
- * Get changed files relative to main branch, mapped to test file paths.
- *
- * Falls back to `git diff --name-only HEAD` if merge-base fails.
- *
- * @param {string} _projectRoot - Project root (unused, git uses cwd)
- * @param {Function} execFileSync - Injected execFileSync
- * @returns {string[]} Array of test file paths (e.g. ['test/foo.test.js'])
- */
-function getAffectedTestFiles(_projectRoot, execFileSync) {
-	let diffRef;
-
-	// Detect default branch, then try merge-base
+function resolveBaseBranch(execFileSync) {
 	let baseBranch = 'main';
 	try {
 		baseBranch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'origin/HEAD'], {
@@ -88,17 +76,39 @@ function getAffectedTestFiles(_projectRoot, execFileSync) {
 			} catch (_e2) { /* intentional: branch doesn't exist, try next name */ } // NOSONAR S2486
 		}
 	}
+	return baseBranch;
+}
+
+function resolveDiffRef(execFileSync, options = {}) {
+	if (options.sinceUpstream) {
+		try {
+			const upstreamRef = execFileSync('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], {
+				encoding: 'utf8',
+				stdio: 'pipe',
+				timeout: 3000,
+			}).trim();
+			if (upstreamRef) {
+				return `${upstreamRef}...HEAD`;
+			}
+		} catch (_e) { // NOSONAR S2486
+			/* intentional: branch may not track a remote yet, fall back to base branch */
+		}
+	}
 
+	const baseBranch = resolveBaseBranch(execFileSync);
 	try {
 		const mergeBase = execFileSync('git', ['merge-base', 'HEAD', baseBranch], {
 			encoding: 'utf8',
 			timeout: 5000,
 		}).trim();
-		diffRef = `${mergeBase}...HEAD`;
+		return `${mergeBase}...HEAD`;
 	} catch (_e) { /* intentional: merge-base failed, fallback to diff against HEAD */ // NOSONAR S2486
-		diffRef = 'HEAD';
+		return 'HEAD';
 	}
+}
 
+function getChangedFiles(execFileSync, options = {}) {
+	const diffRef = resolveDiffRef(execFileSync, options);
 	let output;
 	try {
 		output = execFileSync('git', ['diff', '--name-only', diffRef], {
@@ -111,23 +121,76 @@ function getAffectedTestFiles(_projectRoot, execFileSync) {
 	}
 
 	if (!output) return [];
+	return output.split('\n').filter(Boolean);
+}
 
-	const changedFiles = output.split('\n').filter(Boolean);
-
-	// Map lib/*.js files to test/*.test.js
-	const testFiles = [];
+/**
+ * Get changed files relative to main branch, mapped to test file paths.
+ *
+ * Falls back to `git diff --name-only HEAD` if merge-base fails.
+ *
+ * @param {string} projectRoot - Project root for test file existence checks
+ * @param {Function} execFileSync - Injected execFileSync
+ * @param {Object} [fs] - Injected fs module
+ * @param {Object} [options] - Diff selection options
+ * @returns {string[]} Array of test file paths (e.g. ['test/foo.test.js'])
+ */
+function getAffectedTestFiles(projectRoot, execFileSync, fs = defaultFs, options = {}) {
+	const changedFiles = getChangedFiles(execFileSync, options);
+	const testFiles = new Set();
 	for (const file of changedFiles) {
-		if (file.startsWith('lib/') && file.endsWith('.js')) {
-			const relative = file.slice('lib/'.length);
-			const testFile = `test/${relative.replace(/\.js$/, '.test.js')}`;
-			testFiles.push(testFile);
+		for (const candidate of getTestCandidatesForChangedFile(file)) {
+			if (fs.existsSync(path.join(projectRoot, candidate))) {
+				testFiles.add(candidate);
+			}
 		}
 	}
 
-	return testFiles;
+	return Array.from(testFiles).sort((left, right) => left.localeCompare(right));
+}
+
+function getTestCandidatesForChangedFile(file) {
+	if (!file) return [];
+
+	if (file.startsWith('test/') && file.endsWith('.test.js')) {
+		return [file];
+	}
+
+	if (file.startsWith('lib/') && file.endsWith('.js')) {
+		const relative = file.slice('lib/'.length);
+		return [`test/${relative.replace(/\.js$/, '.test.js')}`];
+	}
+
+	if (file.startsWith('scripts/') && file.endsWith('.js')) {
+		const relative = file.slice('scripts/'.length).replace(/\.js$/, '.test.js');
+		return [
+			`test/scripts/${relative}`,
+			`test/${relative}`,
+		];
+	}
+
+	if (file.startsWith('.github/workflows/')) {
+		const workflowName = path.basename(file, path.extname(file));
+		return [
+			`test/workflows/${workflowName}.test.js`,
+			'test/ci-workflow.test.js',
+		];
+	}
+
+	if (file.startsWith('.claude/commands/') && file.endsWith('.md')) {
+		return [
+			'test/command-sync-check.test.js',
+			'test/structural/command-sync.test.js',
+		];
+	}
+
+	return [];
 }
 
 module.exports = {
+	getChangedFiles,
+	getAffectedTestFiles,
+	getTestCandidatesForChangedFile,
 	name: 'test',
 	description: 'Run tests with smart defaults (timeout, Beads skip, affected-only)',
 	usage: 'forge test [--affected]',
@@ -181,7 +244,9 @@ module.exports = {
 
 		// 5. --affected flag: find changed test files
 		if (flags['--affected'] || flags.affected) {
-			const affectedTests = getAffectedTestFiles(projectRoot, execFileSync);
+			const affectedTests = getAffectedTestFiles(projectRoot, execFileSync, fs, {
+				sinceUpstream: flags.sinceUpstream || flags['--since-upstream'],
+			});
 			if (affectedTests.length > 0) {
 				testArgs = ['run', 'test', ...affectedTests];
 			}

package/lib/commands/validate.js

@@ -14,12 +14,69 @@ const path = require('node:path');
 
 // Constants
 const CHECK_TYPES = {
+	CONFLICT_MARKERS: 'conflictMarkers',
 	TYPE_CHECK: 'typeCheck',
 	LINT: 'lint',
 	SECURITY: 'security',
 	TESTS: 'tests',
 };
 
+const CONFLICT_MARKER_IGNORE_DIRS = new Set([
+	'.beads',
+	'.git',
+	'.next',
+	'coverage',
+	'dist',
+	'node_modules',
+]);
+const CONFLICT_MARKER_ALLOWED_DOT_DIRS = new Set([
+	'.claude',
+	'.cline',
+	'.codex',
+	'.cursor',
+	'.forge',
+	'.github',
+	'.husky',
+	'.kilocode',
+	'.opencode',
+	'.roo',
+	'.sonarlint',
+]);
+const CONFLICT_START_PATTERN = /^<<<<<<<(?: .*)?$/;
+const CONFLICT_DIVIDER_PATTERN = /^=======$/;
+const CONFLICT_END_PATTERN = /^>>>>>>>.*$/;
+const GIT_CONFLICT_SCAN_MAX_BUFFER = 16 * 1024 * 1024;
+
+function listConflictScanFiles(rootDir) {
+	try {
+		const output = execFileSync(
+			'git',
+			['ls-files', '-z', '--cached', '--others', '--exclude-standard'],
+			{ encoding: 'utf8', cwd: rootDir, timeout: 120000, maxBuffer: GIT_CONFLICT_SCAN_MAX_BUFFER },
+		);
+		return output
+			.split('\0')
+			.filter(file => file.length > 0)
+			.map(file => path.join(rootDir, file));
+	} catch (error) {
+		if (!isGitListingUnavailableError(error)) {
+			throw error;
+		}
+		return null;
+	}
+}
+
+function shouldSkipConflictScanPath(relativePath) {
+	const segments = String(relativePath || '')
+		.split(/[\\/]+/)
+		.filter(Boolean);
+	const directorySegments = segments.slice(0, -1);
+	return directorySegments.some(segment => (
+		(segment.startsWith('.') && !CONFLICT_MARKER_ALLOWED_DOT_DIRS.has(segment))
+		|| CONFLICT_MARKER_IGNORE_DIRS.has(segment)
+	));
+}
+
 function getExecOptions() {
 	return { encoding: 'utf8', cwd: process.cwd(), timeout: 120000 };
 }
@@ -27,6 +84,15 @@ function getExecOptions() {
 const ERROR_PATTERNS = {
 	COMMAND_NOT_FOUND: ['ENOENT', 'not found'],
 	NO_LOCK_FILE: ['requires an existing', 'package-lock'],
+	GIT_LISTING_UNAVAILABLE: [
+		'not a git repository',
+		'maxBuffer',           // git ls-files output exceeds maxBuffer
+		'ENOBUFS',             // OS-level buffer overflow
+		'ETIMEDOUT',           // subprocess timeout
+		'EPERM',               // permission denied
+		'EACCES',              // access denied
+		'spawnSync',           // general spawn failure
+	],
 };
 
 /**
@@ -39,6 +105,14 @@ function isCommandNotFound(error) {
 	);
 }
 
+function isGitListingUnavailableError(error) {
+	if (!error || typeof error.message !== 'string') {
+		return false;
+	}
+	return isCommandNotFound(error)
+		|| ERROR_PATTERNS.GIT_LISTING_UNAVAILABLE.some(pattern => error.message.includes(pattern));
+}
+
 /**
  * Parse number from regex match
  * @private
@@ -57,6 +131,131 @@ function getCheckStatus(check) {
 	return check.success ? 'PASS' : 'FAIL';
 }
 
+function scanForConflictMarkers(rootDir = process.cwd()) {
+	const filesWithMarkers = [];
+
+	function inspectFile(absolutePath) {
+		const relativePath = path.relative(rootDir, absolutePath) || path.basename(absolutePath);
+		if (shouldSkipConflictScanPath(relativePath)) {
+			return;
+		}
+
+		try {
+			if (!fs.lstatSync(absolutePath).isFile()) {
+				return;
+			}
+		} catch (error) {
+			if (!canSkipConflictScanStatError(error)) {
+				throw error;
+			}
+			return;
+		}
+
+		const startLine = findConflictMarkerStartLine(readConflictScanFile(absolutePath));
+		if (startLine === null) {
+			return;
+		}
+
+		filesWithMarkers.push({ path: relativePath, line: startLine });
+	}
+
+	function walk(currentDir) {
+		for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+			if (shouldSkipConflictScanEntry(entry)) {
+				continue;
+			}
+
+			if (entry.isDirectory()) {
+				walk(path.join(currentDir, entry.name));
+				continue;
+			}
+
+			if (!entry.isFile()) {
+				continue;
+			}
+
+			inspectFile(path.join(currentDir, entry.name));
+		}
+	}
+
+	const trackedFiles = listConflictScanFiles(rootDir);
+	if (trackedFiles) {
+		for (const absolutePath of trackedFiles) {
+			inspectFile(absolutePath);
+		}
+	} else {
+		walk(rootDir);
+	}
+	filesWithMarkers.sort((left, right) => {
+		if (left.path === right.path) {
+			return left.line - right.line;
+		}
+		return left.path.localeCompare(right.path);
+	});
+
+	return {
+		success: filesWithMarkers.length === 0,
+		files: filesWithMarkers,
+		message: filesWithMarkers.length === 0
+			? 'No conflict markers found'
+			: `Conflict markers found in ${filesWithMarkers.length} file(s)`,
+	};
+}
+
+function shouldSkipConflictScanEntry(entry) {
+	return entry.isDirectory() && (
+		(entry.name.startsWith('.') && !CONFLICT_MARKER_ALLOWED_DOT_DIRS.has(entry.name))
+		|| CONFLICT_MARKER_IGNORE_DIRS.has(entry.name)
+	);
+}
+
+function canSkipConflictScanStatError(error) {
+	return Boolean(error && ['ENOENT', 'ENOTDIR', 'ELOOP'].includes(error.code));
+}
+
+function readConflictScanFile(absolutePath) {
+	try {
+		return fs.readFileSync(absolutePath, 'utf8');
+	} catch (_error) {
+		return null;
+	}
+}
+
+function findConflictMarkerStartLine(content) {
+	const lines = String(content || '').split(/\r?\n/);
+	let activeStartLine = null;
+	let sawDivider = false;
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		const lineNumber = index + 1;
+		if (activeStartLine === null) {
+			if (CONFLICT_START_PATTERN.test(line)) {
+				activeStartLine = lineNumber;
+				sawDivider = false;
+			} else if (CONFLICT_END_PATTERN.test(line)) {
+				return lineNumber;
+			}
+			continue;
+		}
+
+		if (!sawDivider) {
+			if (CONFLICT_DIVIDER_PATTERN.test(line)) {
+				sawDivider = true;
+			} else if (CONFLICT_START_PATTERN.test(line)) {
+				activeStartLine = index + 1;
+			}
+			continue;
+		}
+
+		if (CONFLICT_END_PATTERN.test(line)) {
+			return activeStartLine;
+		}
+	}
+
+	return activeStartLine;
+}
+
 /**
  * Parse vulnerability counts from audit output
  * @private
@@ -450,13 +649,29 @@ async function runAllTests() {
  * console.log(result.summary);
  */
 async function executeValidate(options = {}) { // NOSONAR S3776
-	const { skip = [], continueOnError = true } = options || {};
+	const { skip = [], continueOnError = true, rootDir = process.cwd() } = options || {};
 
 	const checks = {};
 	const failedChecks = [];
 	const errors = [];
 	const startTime = Date.now();
 
+	// 0. Conflict markers
+	if (!skip.includes(CHECK_TYPES.CONFLICT_MARKERS)) {
+		try {
+			checks.conflictMarkers = scanForConflictMarkers(rootDir);
+			if (!checks.conflictMarkers.success) {
+				failedChecks.push(CHECK_TYPES.CONFLICT_MARKERS);
+				if (!continueOnError) {
+					return buildResult(checks, failedChecks, errors, startTime);
+				}
+			}
+		} catch (error) {
+			errors.push(`Conflict marker scan error: ${error.message}`);
+			checks.conflictMarkers = { success: false, message: error.message };
+		}
+	}
+
 	// 1. Type checking
 	if (!skip.includes(CHECK_TYPES.TYPE_CHECK)) {
 		try {
@@ -535,6 +750,7 @@ function buildResult(checks, failedChecks, errors, startTime) {
 	// Build summary using getCheckStatus helper
 	const checkResults = [];
 	const checkLabels = {
+		conflictMarkers: 'Conflict Markers',
 		typeCheck: 'Type',
 		lint: 'Lint',
 		security: 'Security',
@@ -610,6 +826,7 @@ module.exports = {
 	runLint,
 	runSecurityScan,
 	runAllTests,
+	scanForConflictMarkers,
 	executeValidate,
 	executeDebugMode,
 };

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/workflow/enforce-stage.js

@@ -1,8 +1,5 @@
 'use strict';
 
-const fs = require('node:fs');
-const path = require('node:path');
-
 const { repairWorkflowRuntimeAssets } = require('../commands/setup');
 const { checkRuntimeHealth } = require('../runtime-health');
 const { normalizeStageId } = require('./stages');
@@ -11,8 +8,7 @@ const {
   normalizeOverrideRecord,
   readWorkflowState,
 } = require('./state');
-
-const WORKFLOW_STATE_FILENAME = '.forge-state.json';
+const { loadState, WORKFLOW_STATE_FILENAME } = require('./state-manager');
 
 function getOverrideInput(flags = {}) {
   if (Object.hasOwn(flags, 'overrideStage')) {
@@ -67,6 +63,8 @@ function readWorkflowStateFile(projectRoot) {
     return null;
   }
 
+  const fs = require('node:fs');
+  const path = require('node:path');
   const statePath = path.join(projectRoot, WORKFLOW_STATE_FILENAME);
   if (!fs.existsSync(statePath)) {
     return null;
@@ -76,11 +74,17 @@ function readWorkflowStateFile(projectRoot) {
 }
 
 function resolveWorkflowStateInput(workflowState, flags = {}, args = [], projectRoot) {
-  return workflowState
+  const inlineOrFlag = workflowState
     || flags.workflowState
     || flags['--workflow-state']
-    || getCliFlagValue('--workflow-state', args)
-    || readWorkflowStateFile(projectRoot);
+    || getCliFlagValue('--workflow-state', args);
+
+  if (inlineOrFlag) {
+    return inlineOrFlag;
+  }
+
+  const { state } = loadState(projectRoot);
+  return state;
 }
 
 function readWorkflowStateInput(input) {