forge-workflow 0.0.7 → 0.0.9

package/lib/commands/ship.js

@@ -29,6 +29,178 @@ function isCommandNotFound(error) {
 	return error.message.includes('ENOENT') || error.message.includes('not found');
 }
 
+function getGitExecOptions(cwd = process.cwd()) {
+	return { ...getExecOptions(), cwd };
+}
+
+function getQuietGitExecOptions(cwd = process.cwd()) {
+	return { ...getGitExecOptions(cwd), stdio: 'pipe' };
+}
+
+function resolveRemoteHeadTarget(exec = execFileSync, cwd = process.cwd(), remoteName) {
+	try {
+		const symbolicRef = exec('git', ['symbolic-ref', `refs/remotes/${remoteName}/HEAD`], getQuietGitExecOptions(cwd)).trim();
+		if (!symbolicRef) {
+			return null;
+		}
+		exec('git', ['rev-parse', '--verify', symbolicRef], getQuietGitExecOptions(cwd));
+		return symbolicRef;
+	} catch (_error) {
+		return null;
+	}
+}
+
+function remoteHasTrackingBase(exec = execFileSync, cwd = process.cwd(), remoteName) {
+	if (resolveRemoteHeadTarget(exec, cwd, remoteName)) {
+		return true;
+	}
+
+	for (const candidate of ['main', 'master']) {
+		try {
+			exec('git', ['rev-parse', '--verify', `refs/remotes/${remoteName}/${candidate}`], getQuietGitExecOptions(cwd));
+			return true;
+		} catch (_error) {
+			// Probe next candidate.
+		}
+	}
+
+	return false;
+}
+
+function resolveBaseRemote(exec = execFileSync, cwd = process.cwd()) {
+	for (const candidate of ['upstream', 'origin']) {
+		try {
+			exec('git', ['remote', 'get-url', candidate], getQuietGitExecOptions(cwd));
+			if (remoteHasTrackingBase(exec, cwd, candidate)) {
+				return candidate;
+			}
+		} catch (_error) {
+			// Probe next candidate.
+		}
+	}
+
+	return 'origin';
+}
+
+function resolveBaseBranch(exec = execFileSync, cwd = process.cwd(), remoteName = resolveBaseRemote(exec, cwd)) {
+	const symbolicRef = resolveRemoteHeadTarget(exec, cwd, remoteName);
+	if (symbolicRef) {
+		const match = new RegExp(`^refs/remotes/${remoteName}/(.+)$`).exec(symbolicRef);
+		if (match && match[1]) {
+			return match[1];
+		}
+	}
+
+	for (const candidate of ['main', 'master']) {
+		try {
+			exec('git', ['rev-parse', '--verify', `refs/remotes/${remoteName}/${candidate}`], getQuietGitExecOptions(cwd));
+			return candidate;
+		} catch (_error) {
+			// Probe next candidate.
+		}
+	}
+
+	return 'master';
+}
+
+function refreshBaseReference(exec = execFileSync, cwd = process.cwd(), remoteName, baseBranch) {
+	exec(
+		'git',
+		['fetch', '--quiet', '--no-tags', remoteName, `refs/heads/${baseBranch}:refs/remotes/${remoteName}/${baseBranch}`],
+		getQuietGitExecOptions(cwd),
+	);
+}
+
+function getBranchReadiness(options = {}) {
+	const exec = options.exec || execFileSync;
+	const cwd = options.cwd || process.cwd();
+	const baseRemote = options.baseRemote || resolveBaseRemote(exec, cwd);
+	const baseBranch = options.baseBranch || resolveBaseBranch(exec, cwd, baseRemote);
+	const baseRef = `${baseRemote}/${baseBranch}`;
+	const branchName = exec('git', ['rev-parse', '--abbrev-ref', 'HEAD'], getGitExecOptions(cwd)).trim();
+
+	if (!branchName || branchName === 'HEAD') {
+		return {
+			ready: false,
+			branchName: branchName || 'HEAD',
+			baseRemote,
+			baseBranch,
+			error: 'Current HEAD is detached. Check out a feature branch before running /ship.',
+		};
+	}
+
+	try {
+		refreshBaseReference(exec, cwd, baseRemote, baseBranch);
+	} catch (error) {
+		return {
+			ready: false,
+			branchName,
+			baseRemote,
+			baseBranch,
+			error: `Unable to refresh ${baseRef} before comparing branch readiness. Verify that remote '${baseRemote}' and branch '${baseBranch}' can be fetched. Git said: ${error.message}`,
+		};
+	}
+
+	let counts;
+	try {
+		counts = exec('git', ['rev-list', '--left-right', '--count', `${baseRef}...HEAD`], getGitExecOptions(cwd)).trim();
+	} catch (error) {
+		return {
+			ready: false,
+			branchName,
+			baseRemote,
+			baseBranch,
+			error: `Unable to compare the current branch against ${baseRef}. Verify that remote '${baseRemote}' and branch '${baseBranch}' exist. Git said: ${error.message}`,
+		};
+	}
+
+	const [behindRaw = '0', aheadRaw = '0'] = counts.split(/\s+/);
+	const behind = Number.parseInt(behindRaw, 10) || 0;
+	const ahead = Number.parseInt(aheadRaw, 10) || 0;
+
+	let hasDiff = false;
+	try {
+		exec('git', ['diff', '--quiet', `${baseRef}...HEAD`, '--'], getGitExecOptions(cwd));
+	} catch (error) {
+		if (error.status === 1) {
+			hasDiff = true;
+		} else {
+			return {
+				ready: false,
+				branchName,
+				baseRemote,
+				baseBranch,
+				ahead,
+				behind,
+				error: `Unable to inspect the tree diff against ${baseRef}. Git said: ${error.message}`,
+			};
+		}
+	}
+
+	if (!hasDiff) {
+		return {
+			ready: false,
+			branchName,
+			baseRemote,
+			baseBranch,
+			ahead,
+			behind,
+			error:
+				`Current branch ${branchName} has no diff against ${baseRef}. ` +
+				'It is not PR-ready because all changes are already upstream or the branch collapsed onto the base during rebase.',
+		};
+	}
+
+	return {
+		ready: true,
+		branchName,
+		baseRemote,
+		baseBranch,
+		ahead,
+		behind,
+	};
+}
+
 /**
  * Validate feature slug format
  * Ensures slug matches expected pattern and doesn't contain path traversal
@@ -256,11 +428,11 @@ function validatePRTitle(title) {
 }
 
 async function createPR(options) { // NOSONAR S3776
-	const { title, body, dryRun = false } = options;
+	const { title, body, dryRun = false, exec = execFileSync, cwd = process.cwd() } = options;
 	const titleValidation = validatePRTitle(title);
 	if (!titleValidation.valid) return { success: false, error: titleValidation.error };
 	try {
-		execFileSync('gh', ['--version'], getGhCheckOptions());  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+		exec('gh', ['--version'], { ...getGhCheckOptions(), cwd });  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
 	} catch (error) {
 		if (isCommandNotFound(error)) {
 			return { success: false, error: 'GitHub CLI (gh) not found. Install from: https://cli.github.com/' };
@@ -272,22 +444,30 @@ async function createPR(options) { // NOSONAR S3776
 		return { success: false, error: `GitHub CLI check failed: ${error.message}` };
 	}
 	try {
-		execFileSync('git', ['rev-parse', '--git-dir'], getExecOptions());  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+		exec('git', ['rev-parse', '--git-dir'], getGitExecOptions(cwd));  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
 	} catch (error_) { // NOSONAR S2486 - intentional: not-a-git-repo is the expected failure signal
 		void error_;
 		return { success: false, error: 'Not in a git repository. Initialize with: git init' };
 	}
 	try {
-		execFileSync('git', ['remote', 'get-url', 'origin'], getExecOptions());  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+		exec('git', ['remote', 'get-url', 'origin'], getGitExecOptions(cwd));  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
 	} catch (error_) { // NOSONAR S2486 - intentional: no-remote is the expected failure signal
 		void error_;
 		return { success: false, error: 'No git remote configured. Add with: git remote add origin <url>' };
 	}
+	try {
+		const readiness = getBranchReadiness({ exec, cwd });
+		if (!readiness.ready) {
+			return { success: false, error: readiness.error };
+		}
+	} catch (error) {
+		return { success: false, error: `Failed to verify branch readiness: ${error.message}` };
+	}
 	if (dryRun) {
 		return { success: true, message: '[DRY RUN] Would create PR with title: ' + title, prUrl: 'https://github.com/owner/repo/pull/1' };
 	}
 	try {
-		const result = execFileSync('gh', ['pr', 'create', '--title', title, '--body', body], getExecOptions());  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
+		const result = exec('gh', ['pr', 'create', '--title', title, '--body', body], getGitExecOptions(cwd));  // NOSONAR S4036 - hardcoded CLI command, no user input, developer tool context
 		const urlMatch = /https:\/\/github\.com\/[^\s]+/.exec(result);
 		const prUrl = urlMatch ? urlMatch[0] : null;
 		const numberMatch = /\/pull\/(\d+)/.exec(result);
@@ -394,4 +574,7 @@ module.exports = {
 	validatePRTitle,
 	createPR,
 	executeShip,
+	getBranchReadiness,
+	resolveBaseRemote,
+	resolveBaseBranch,
 };

package/lib/commands/show.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const { makeAliasCommand } = require('./_issue');
+
+module.exports = makeAliasCommand('show');

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/sync.js

@@ -7,7 +7,9 @@ function isRecoverableBeadsSyncError(error) {
   return (
     message.includes('failed to open database') ||
     message.includes('database not found') ||
-    message.includes('no beads configuration found')
+    message.includes('no beads configuration found') ||
+    message.includes('remote \'origin\' not found') ||
+    message.includes('remote "origin" not found')
   );
 }
 

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/update.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const { makeAliasCommand } = require('./_issue');
+
+module.exports = makeAliasCommand('update');