forge-workflow 0.0.8 → 0.0.10

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

@@ -3,12 +3,20 @@
  * 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 { detectWorktree } = require('../detect-worktree');
+const { readBeadsSnapshot } = require('../status/beads-snapshot');
+const { formatZeroArgStatus } = require('../status/presenter');
+const {
+	loadState,
+	extractWorkflowStateFromComments,
+	readWorkflowStateFromBeads,
+} = require('../workflow/state-manager');
+const { secureExecFileSync } = require('../shell-utils.js');
 
 const WORKFLOW_STAGES = {
 	1: { name: 'Fresh Start', nextCommand: 'research' },
@@ -338,42 +346,156 @@ 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;
+function runGitCommand(projectRoot, args) {
+	if (!projectRoot) {
+		return '';
+	}
+
+	try {
+		return secureExecFileSync('git', args, {
+			encoding: 'utf8',
+			cwd: projectRoot,
+			stdio: ['pipe', 'pipe', 'pipe'],
+		}).trim();
+	} catch (_error) {
+		return '';
 	}
+}
+
+function detectRepoContext(projectRoot = process.cwd()) {
+	const worktree = detectWorktree(projectRoot);
+	const branch = worktree.branch || runGitCommand(projectRoot, ['branch', '--show-current']) || 'unknown';
+	const statusOutput = runGitCommand(projectRoot, ['status', '--short']);
+	const changedEntries = statusOutput ? statusOutput.split(/\r?\n/).filter(Boolean) : [];
+	const clean = changedEntries.length === 0;
+	const summary = clean ? 'clean' : `${changedEntries.length} uncommitted change${changedEntries.length === 1 ? '' : 's'}`;
 
-	const latest = matches.at(-1).replace(/^WorkflowState:\s*/, '');
-	return readWorkflowState(latest);
+	return {
+		branch,
+		inWorktree: worktree.inWorktree === true,
+		worktreePath: worktree.currentWorktree || projectRoot,
+		mainWorktree: worktree.mainWorktree || projectRoot,
+		workingTree: {
+			clean,
+			summary,
+		},
+	};
 }
 
-function readWorkflowStateFromBeads(issueId, options = {}) {
+function readIssueDetails(issueId, projectRoot = process.cwd()) {
 	if (!issueId) {
 		return null;
 	}
 
-	const comments = options.comments || secureExecFileSync('bd', ['comments', 'list', issueId], {
-		encoding: 'utf8',
-		stdio: ['pipe', 'pipe', 'pipe'],
-	}).trim();
+	try {
+		const raw = secureExecFileSync('bd', ['show', issueId, '--json'], {
+			encoding: 'utf8',
+			cwd: projectRoot,
+			stdio: ['pipe', 'pipe', 'pipe'],
+		}).trim();
+		if (!raw) {
+			return null;
+		}
 
-	if (!comments) {
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed[0] || null : parsed;
+	} catch (_error) {
 		return null;
 	}
+}
+
+function extractDesignSlugs(design) {
+	if (typeof design !== 'string' || design.trim() === '') {
+		return [];
+	}
+
+	const slugs = new Set();
+	const pattern = /docs[\\/]+plans[\\/]+\d{4}-\d{2}-\d{2}-([a-z0-9-]+?)-(?:design|tasks|decisions)\.md/g;
+	let match = pattern.exec(design);
+	while (match) {
+		slugs.add(match[1]);
+		match = pattern.exec(design);
+	}
 
-	return extractWorkflowStateFromComments(comments);
+	return [...slugs];
+}
+
+function designMatchesFeatureSlug(issue, featureSlug) {
+	if (!issue || !featureSlug) {
+		return false;
+	}
+
+	return extractDesignSlugs(issue.design).includes(featureSlug);
+}
+
+function discoverCurrentIssue(snapshot, context, projectRoot = process.cwd()) {
+	const activeAssigned = snapshot.activeAssigned || [];
+	if (activeAssigned.length === 0) {
+		return null;
+	}
+
+	const branchInfo = analyzeBranch(context.branch || 'master');
+	const hydratedIssues = new Map();
+
+	function hydrateIssue(issue) {
+		if (!issue || !issue.id) {
+			return issue;
+		}
+
+		if (hydratedIssues.has(issue.id)) {
+			return hydratedIssues.get(issue.id);
+		}
+
+		const details = issue.design && issue.comments ? issue : readIssueDetails(issue.id, projectRoot);
+		const hydratedIssue = details ? { ...issue, ...details } : issue;
+		hydratedIssues.set(issue.id, hydratedIssue);
+		return hydratedIssue;
+	}
+
+	if (branchInfo.featureSlug) {
+		const slugMatches = [];
+
+		for (const issue of activeAssigned) {
+			const candidate = issue.design ? issue : hydrateIssue(issue);
+			if (designMatchesFeatureSlug(candidate, branchInfo.featureSlug)) {
+				slugMatches.push(candidate);
+			}
+		}
+
+		if (slugMatches.length === 1) {
+			return hydrateIssue(slugMatches[0]);
+		}
+
+		if (slugMatches.length > 1) {
+			return null;
+		}
+	}
+
+	if (activeAssigned.length === 1) {
+		return hydrateIssue(activeAssigned[0]);
+	}
+
+	return null;
 }
 
 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,
+			issue: inputs.issue,
+			comments: inputs.bdComments,
+			preferBeads: inputs.preferBeads,
+		});
+
+		return { workflowState: state, fallbackReason: null };
 	} catch (error) {
 		return {
 			workflowState: null,
@@ -512,10 +634,53 @@ 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);
+		const isZeroArgStatus = !inputs.issueId && !inputs.workflowState && !inputs.bdComments;
+		inputs.preferBeads = !isZeroArgStatus && Boolean(inputs.issueId || inputs.bdComments);
+		if (!inputs.projectRoot && projectRoot) {
+			inputs.projectRoot = projectRoot;
+		}
+		const effectiveProjectRoot = inputs.projectRoot || process.cwd();
+		let context = null;
+		let snapshot = null;
+
+		if (isZeroArgStatus) {
+			context = detectRepoContext(effectiveProjectRoot);
+			snapshot = readBeadsSnapshot(effectiveProjectRoot);
+			const discoveredIssue = discoverCurrentIssue(snapshot, context, effectiveProjectRoot);
+			if (discoveredIssue) {
+				inputs.issueId = discoveredIssue.id;
+				inputs.issue = discoveredIssue;
+			}
+		}
+
 		const { workflowState, fallbackReason } = resolveWorkflowState(inputs);
 
+		if (isZeroArgStatus) {
+			if (workflowState) {
+				const result = buildAuthoritativeStatus(workflowState);
+				return {
+					success: true,
+					context,
+					snapshot,
+					issueId: inputs.issueId,
+					output: formatZeroArgStatus({ context, snapshot, workflowResult: result }),
+					...result,
+				};
+			}
+
+			return {
+				success: true,
+				context,
+				snapshot,
+				issueId: inputs.issueId,
+				missingWorkflowState: true,
+				output: formatZeroArgStatus({ context, snapshot }),
+				...(fallbackReason ? { fallbackReason } : {}),
+			};
+		}
+
 		if (workflowState) {
 			const result = buildAuthoritativeStatus(workflowState);
 			return { success: true, output: formatStatus(result), ...result };
@@ -534,6 +699,8 @@ module.exports = {
 	parseStatusInputs,
 	readWorkflowStateFromBeads,
 	detectStage,
+	detectRepoContext,
+	discoverCurrentIssue,
 	analyzeBranch,
 	analyzeFiles,
 	analyzePR,
@@ -541,4 +708,5 @@ module.exports = {
 	analyzeBeads,
 	calculateConfidence,
 	formatStatus,
+	extractDesignSlugs,
 };

package/lib/commands/team.js

@@ -34,4 +34,14 @@ function handleTeam(args) {
   }
 }
 
-module.exports = { handleTeam };
+async function handler(args = []) {
+  handleTeam(args);
+  return { success: true };
+}
+
+module.exports = {
+  name: 'team',
+  description: 'Team coordination workflows and sync utilities',
+  handler,
+  handleTeam
+};