forge-workflow 0.0.7 → 0.0.9

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) {

package/lib/workflow/state-manager.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { secureExecFileSync } = require('../shell-utils.js');
+const { readWorkflowState, serializeWorkflowState, WORKFLOW_STATE_SCHEMA_VERSION, getAllowedTransitionsForWorkflowState } = require('./state.js');
+const { getWorkflowPath, WORKFLOW_CLASSIFICATIONS, normalizeStageId } = require('./stages.js');
+
+const WORKFLOW_STATE_FILENAME = '.forge-state.json';
+
+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 loadStateFromBeads(options) {
+  if (options.comments) {
+    const state = extractWorkflowStateFromComments(options.comments);
+    if (state) {
+      return { state, source: 'beads' };
+    }
+  }
+
+  if (options.issueId) {
+    const state = readWorkflowStateFromBeads(options.issueId, { comments: options.comments });
+    if (state) {
+      return { state, source: 'beads' };
+    }
+  }
+
+  return null;
+}
+
+function loadState(projectRoot, options = {}) {
+  if (!projectRoot) {
+    const beadsResult = loadStateFromBeads(options);
+    return beadsResult || { state: null, source: null };
+  }
+
+  const statePath = path.join(projectRoot, WORKFLOW_STATE_FILENAME);
+  if (fs.existsSync(statePath)) {
+    try {
+      const raw = fs.readFileSync(statePath, 'utf8');
+      return { state: readWorkflowState(raw), source: 'file' };
+    } catch (_parseError) {
+      // File is malformed — fall through to Beads fallback
+    }
+  }
+
+  const beadsResult = loadStateFromBeads(options);
+  if (beadsResult) {
+    return beadsResult;
+  }
+
+  return { state: null, source: null };
+}
+
+function saveState(projectRoot, state) {
+  if (!projectRoot || typeof projectRoot !== 'string') {
+    throw new Error('saveState requires a valid projectRoot path');
+  }
+
+  const normalized = serializeWorkflowState(state);
+  const json = JSON.stringify(normalized, null, 2);
+  const tmpPath = path.join(projectRoot, `${WORKFLOW_STATE_FILENAME}.tmp`);
+  const statePath = path.join(projectRoot, WORKFLOW_STATE_FILENAME);
+
+  fs.writeFileSync(tmpPath, json, 'utf8');
+  fs.renameSync(tmpPath, statePath);
+
+  return normalized;
+}
+
+function initializeState(projectRoot, classification, firstStage) {
+  if (!WORKFLOW_CLASSIFICATIONS.includes(classification)) {
+    throw new Error(`Invalid classification: ${classification}. Expected one of: ${WORKFLOW_CLASSIFICATIONS.join(', ')}`);
+  }
+
+  const workflowPath = getWorkflowPath(classification);
+  const currentStage = firstStage || workflowPath[0];
+
+  const state = {
+    schemaVersion: WORKFLOW_STATE_SCHEMA_VERSION,
+    currentStage,
+    completedStages: [],
+    skippedStages: [],
+    workflowDecisions: {
+      classification,
+      reason: 'initialized',
+      userOverride: false,
+      overrides: [],
+    },
+    parallelTracks: [],
+  };
+
+  return saveState(projectRoot, state);
+}
+
+function transitionStage(projectRoot, toStage, options = {}) {
+  const targetStage = normalizeStageId(toStage);
+  if (!targetStage) {
+    throw new Error(`Invalid target stage: ${toStage}`);
+  }
+
+  const { state: currentState } = loadState(projectRoot, options);
+  if (!currentState) {
+    throw new Error('No workflow state found. Initialize state first with initializeState().');
+  }
+
+  const previousState = JSON.parse(JSON.stringify(currentState));
+  const allowed = getAllowedTransitionsForWorkflowState(currentState);
+
+  if (!allowed.includes(targetStage)) {
+    if (!options.override) {
+      throw new Error(
+        `Transition from ${currentState.currentStage} to ${targetStage} is not allowed. ` +
+        `Allowed transitions: ${allowed.join(', ') || 'none'}. Provide an override to force.`
+      );
+    }
+  }
+
+  const completedStages = [...currentState.completedStages];
+  if (!completedStages.includes(currentState.currentStage)) {
+    completedStages.push(currentState.currentStage);
+  }
+
+  const overrides = [...(currentState.workflowDecisions.overrides || [])];
+  if (options.override) {
+    overrides.push({
+      type: options.override.type || 'manual',
+      fromStage: currentState.currentStage,
+      toStage: targetStage,
+      reason: options.override.reason || '',
+      actor: options.override.actor || 'unknown',
+      userOverride: true,
+      recordedAt: new Date().toISOString(),
+    });
+  }
+
+  const newStateInput = {
+    schemaVersion: currentState.schemaVersion || WORKFLOW_STATE_SCHEMA_VERSION,
+    currentStage: targetStage,
+    completedStages,
+    skippedStages: currentState.skippedStages || [],
+    workflowDecisions: {
+      ...currentState.workflowDecisions,
+      overrides,
+      userOverride: overrides.length > 0,
+    },
+    parallelTracks: currentState.parallelTracks || [],
+  };
+
+  const newState = saveState(projectRoot, newStateInput);
+
+  return {
+    previousState,
+    newState,
+    transitioned: true,
+  };
+}
+
+module.exports = {
+  WORKFLOW_STATE_FILENAME,
+  extractWorkflowStateFromComments,
+  initializeState,
+  loadState,
+  readWorkflowStateFromBeads,
+  saveState,
+  transitionStage,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-workflow",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "7-stage TDD workflow for ALL AI coding agents (Claude, Cursor, Cline, OpenCode, Copilot, Kilo Code, Roo Code, Codex)",
   "bin": {
     "forge": "bin/forge.js",

package/scripts/dep-guard.sh

@@ -426,7 +426,7 @@ cmd_check_ripple_keyword_v1() {
 
     # Extract issue ID (forge-xxx pattern)
     local cand_id=""
-    cand_id="$(printf '%s' "$line" | grep -oE 'forge-[a-z0-9]+' | head -1)" || continue
+    cand_id="$(printf '%s' "$line" | grep -oE 'forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*' | head -1)" || continue
     [[ -z "$cand_id" ]] && continue
 
     # Skip the source issue itself
@@ -561,6 +561,16 @@ cmd_check_ripple() {
 
   local tmp_dir
   tmp_dir="$(mktemp -d)"
+  # On Windows/Git Bash, normalize to a mixed-mode path so both bash file I/O
+  # and Node.js resolve to the same physical location (cygpath -m → C:/...).
+  # Preserve the original POSIX path if conversion fails or returns empty.
+  if command -v cygpath &>/dev/null; then
+    local mixed_tmp_dir
+    mixed_tmp_dir="$(cygpath -m "$tmp_dir" 2>/dev/null)" || true
+    if [[ -n "$mixed_tmp_dir" && -d "$mixed_tmp_dir" ]]; then
+      tmp_dir="$mixed_tmp_dir"
+    fi
+  fi
   trap 'rm -rf "$tmp_dir"' RETURN
 
   printf '%s' "$src_json" > "${tmp_dir}/current.json"

package/scripts/forge-team/lib/hooks.sh

@@ -148,7 +148,7 @@ forge_team_sync() {
 
     # Extract issue id
     local issue_id
-    issue_id="$(echo "$line" | grep -oE 'forge-[a-zA-Z0-9]+' | head -1)"
+    issue_id="$(echo "$line" | grep -oE 'forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*' | head -1)"
     [[ -z "$issue_id" ]] && continue
 
     # Get details to check for github_issue state

package/scripts/forge-team/lib/verify.sh

@@ -75,7 +75,7 @@ _extract_beads_ids() {
   if [[ -z "$input" ]]; then
     return 0
   fi
-  printf '%s\n' "$input" | grep -oP '(forge-[a-z0-9]+)' || true
+  printf '%s\n' "$input" | grep -oP '(forge-[a-zA-Z0-9]+(\.[a-zA-Z0-9]+)*)' || true
 }
 
 # ── Public API ───────────────────────────────────────────────────────────