forge-workflow 0.0.6 → 0.0.8

package/lib/commands/ship.js

@@ -367,6 +367,26 @@ async function executeShip(options) {
 }
 
 module.exports = {
+	name: 'ship',
+	description: 'Create a pull request from validated feature work',
+	handler: async (args, flags = {}) => {
+		const result = await executeShip({
+			featureSlug: args[0],
+			title: args[1],
+			dryRun: Boolean(flags.dryRun || flags['--dry-run']),
+		});
+		if (!result.success) {
+			return result;
+		}
+
+		const lines = [result.message];
+		if (result.prUrl) lines.push(`PR: ${result.prUrl}`);
+
+		return {
+			...result,
+			output: lines.join('\n'),
+		};
+	},
 	extractKeyDecisions,
 	extractTestScenarios,
 	getTestCoverage,

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,6 +3,13 @@
  * 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 WORKFLOW_STAGES = {
 	1: { name: 'Fresh Start', nextCommand: 'research' },
 	2: { name: 'Research', nextCommand: 'research' },
@@ -15,6 +22,16 @@ const WORKFLOW_STAGES = {
 	9: { name: 'Verification', nextCommand: 'verify' },
 };
 
+const AUTHORITATIVE_STAGE_NAMES = {
+	plan: 'Planning',
+	dev: 'Development',
+	validate: 'Validation',
+	ship: 'Shipping',
+	review: 'Review',
+	premerge: 'Premerge',
+	verify: 'Verification',
+};
+
 /**
  * Analyze branch state
  * @param {string} branch - Current branch name
@@ -302,63 +319,175 @@ function detectStage(context) {
 	};
 }
 
-/**
- * Format status output
- * @param {object} result - Detection result
- * @returns {string} Formatted output
- */
-function formatStatus(result) {
-	const lines = [];
+function parseStatusInputs(args = [], flags = {}) {
+	const statusArgs = Array.isArray(args) ? args : [];
+	const getNextValue = (flagName) => {
+		const index = statusArgs.indexOf(flagName);
+		if (index !== -1 && index + 1 < statusArgs.length) {
+			return statusArgs[index + 1];
+		}
+		return null;
+	};
+	const getInlineValue = (flagName) => {
+		const prefix = `${flagName}=`;
+		const match = statusArgs.find(arg => typeof arg === 'string' && arg.startsWith(prefix));
+		return match ? match.slice(prefix.length) : null;
+	};
 
-	// Header
-	lines.push('');
-	lines.push(`✓ Current Stage: ${result.stage} - ${result.stageName}`);
-	lines.push(`  Confidence: ${result.confidence.toUpperCase()} (${result.confidenceScore}%)`);
-	lines.push('');
+	return {
+		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'),
+	};
+}
 
-	// Completed checks
-	const completed = [];
-	if (result.factors.files.hasResearch) {
-		completed.push('✓ Research doc exists');
-	}
-	if (result.factors.files.hasPlan) {
-		completed.push('✓ Plan created');
-	}
-	if (result.factors.branch.onFeatureBranch) {
-		completed.push('✓ Feature branch created');
+function extractWorkflowStateFromComments(comments = '') {
+	const matches = String(comments).match(/^WorkflowState:\s*(\{.*\})$/gm);
+	if (!matches || matches.length === 0) {
+		return null;
 	}
-	if (result.factors.files.hasTests) {
-		completed.push('✓ Tests written');
+
+	const latest = matches.at(-1).replace(/^WorkflowState:\s*/, '');
+	return readWorkflowState(latest);
+}
+
+function readWorkflowStateFromBeads(issueId, options = {}) {
+	if (!issueId) {
+		return null;
 	}
-	if (result.factors.files.testsPass) {
-		completed.push('✓ Tests passing');
+
+	const comments = options.comments || secureExecFileSync('bd', ['comments', 'list', issueId], {
+		encoding: 'utf8',
+		stdio: ['pipe', 'pipe', 'pipe'],
+	}).trim();
+
+	if (!comments) {
+		return null;
 	}
-	if (result.factors.checks.allChecksPass) {
-		completed.push('✓ All checks passing');
+
+	return extractWorkflowStateFromComments(comments);
+}
+
+function resolveWorkflowState(inputs) {
+	try {
+		const workflowState = inputs.workflowState
+			? readWorkflowState(inputs.workflowState)
+			: readWorkflowStateFromBeads(inputs.issueId, { comments: inputs.bdComments });
+		return { workflowState, fallbackReason: null };
+	} catch (error) {
+		return {
+			workflowState: null,
+			fallbackReason: error instanceof Error ? error.message : String(error),
+		};
 	}
-	if (result.factors.pr.hasPR) {
-		completed.push(`✓ PR created (#${result.factors.pr.prNumber})`);
+}
+
+function buildAuthoritativeStatus(workflowState) {
+	const currentStage = workflowState.currentStage;
+	const stageIndex = STAGE_IDS.indexOf(currentStage);
+	const nextStages = getAllowedTransitionsForWorkflowState(workflowState);
+
+	return {
+		stage: stageIndex === -1 ? null : stageIndex + 1,
+		stageId: currentStage,
+		stageName: AUTHORITATIVE_STAGE_NAMES[currentStage] || currentStage,
+		confidence: 'high',
+		confidenceScore: 100,
+		runCommand: currentStage,
+		nextCommand: nextStages[0] || null,
+		nextStages,
+		authoritative: true,
+		workflowState,
+		factors: {
+			files: {
+				hasResearch: workflowState.completedStages.includes('plan'),
+				hasPlan: workflowState.completedStages.includes('plan') || currentStage !== 'plan',
+				testsPass: workflowState.completedStages.includes('validate'),
+			},
+			branch: {},
+			pr: {},
+			checks: { allChecksPass: workflowState.completedStages.includes('validate') },
+			beads: { hasActiveIssue: true },
+		},
+	};
+}
+
+function buildMissingWorkflowStateStatus() {
+	return {
+		stage: null,
+		stageId: null,
+		stageName: 'Unknown',
+		confidence: 'low',
+		confidenceScore: 0,
+		authoritative: false,
+		missingWorkflowState: true,
+		output: '\nNo authoritative workflow state available.\nProvide --workflow-state or --issue-id so /status can read recorded stage state.\n',
+	};
+}
+
+function buildHeaderLines(title, detailLines = []) {
+	return ['', title, ...detailLines, ''];
+}
+
+function buildSectionLines(title, items = []) {
+	if (items.length === 0) {
+		return [];
 	}
-	if (result.factors.pr.prApproved) {
-		completed.push('✓ PR approved');
+
+	return [title, ...items.map(item => `  ${item}`), ''];
+}
+
+function collectCompletedChecks(result) {
+	const completed = [];
+
+	if (result.factors.files.hasResearch) completed.push('Research doc exists');
+	if (result.factors.files.hasPlan) completed.push('Plan created');
+	if (result.factors.branch.onFeatureBranch) completed.push('Feature branch created');
+	if (result.factors.files.hasTests) completed.push('Tests written');
+	if (result.factors.files.testsPass) completed.push('Tests passing');
+	if (result.factors.checks.allChecksPass) completed.push('All checks passing');
+	if (result.factors.pr.hasPR) completed.push(`PR created (#${result.factors.pr.prNumber})`);
+	if (result.factors.pr.prApproved) completed.push('PR approved');
+	if (result.factors.pr.prMerged) completed.push('PR merged');
+
+	return completed;
+}
+
+function formatAuthoritativeStatus(result) {
+	const completedStages = result.workflowState.completedStages.map(stageId => stageId);
+	const allowedCommands = result.nextStages.map(stageId => '/' + stageId).join(', ');
+	const nextLines = [`Run now: /${result.runCommand}`];
+
+	if (result.nextCommand) {
+		nextLines.push(`Next after this: /${result.nextCommand}`);
 	}
-	if (result.factors.pr.prMerged) {
-		completed.push('✓ PR merged');
+	if (allowedCommands) {
+		nextLines.push(`Allowed after this: ${allowedCommands}`);
 	}
 
-	if (completed.length > 0) {
-		lines.push('Completed:');
-		completed.forEach(item => lines.push(`  ${item}`));
-		lines.push('');
-	}
+	return [
+		...buildHeaderLines(`Current Stage: ${result.stageId} - ${result.stageName}`, [
+			'  Source: authoritative workflow state',
+			`  Classification: ${result.workflowState.workflowDecisions.classification}`,
+		]),
+		...buildSectionLines('Completed stages:', completedStages),
+		...nextLines,
+		'',
+	].join('\n');
+}
 
-	// Next command
-	lines.push(`Next: /${result.nextCommand}`);
-	lines.push('');
+function formatHeuristicStatus(result) {
+	const lines = [
+		...buildHeaderLines(`Current Stage: ${result.stage} - ${result.stageName}`, [
+			`  Confidence: ${result.confidence.toUpperCase()} (${result.confidenceScore}%)`,
+		]),
+		...buildSectionLines('Completed:', collectCompletedChecks(result)),
+		`Next: /${result.nextCommand}`,
+		'',
+	];
 
-	// Low confidence warning
 	if (result.confidence === 'low') {
-		lines.push('⚠️  Low confidence - Manual verification suggested');
+		lines.push('Low confidence - Manual verification suggested');
 		lines.push('   Conflicting signals detected. Please verify current stage.');
 		lines.push('');
 	}
@@ -366,7 +495,44 @@ function formatStatus(result) {
 	return lines.join('\n');
 }
 
+/**
+ * Format status output
+ * @param {object} result - Detection result
+ * @returns {string} Formatted output
+ */
+function formatStatus(result) {
+	if (result.authoritative && result.workflowState) {
+		return formatAuthoritativeStatus(result);
+	}
+
+	return formatHeuristicStatus(result);
+}
+
+
 module.exports = {
+	name: 'status',
+	description: 'Intelligent stage detection with confidence scoring',
+	handler: async (args, flags, _projectRoot) => {
+		const inputs = parseStatusInputs(args, flags);
+		const { workflowState, fallbackReason } = resolveWorkflowState(inputs);
+
+		if (workflowState) {
+			const result = buildAuthoritativeStatus(workflowState);
+			return { success: true, output: formatStatus(result), ...result };
+		}
+
+		return {
+			success: true,
+			...buildMissingWorkflowStateStatus(),
+			...(fallbackReason ? { fallbackReason } : {}),
+		};
+	},
+	buildAuthoritativeStatus,
+	buildMissingWorkflowStateStatus,
+	extractWorkflowStateFromComments,
+	resolveWorkflowState,
+	parseStatusInputs,
+	readWorkflowStateFromBeads,
 	detectStage,
 	analyzeBranch,
 	analyzeFiles,

package/lib/commands/sync.js

@@ -2,6 +2,17 @@
 
 const { execFileSync } = require('node:child_process');
 
+function isRecoverableBeadsSyncError(error) {
+  const message = error?.message ?? String(error ?? '');
+  return (
+    message.includes('failed to open database') ||
+    message.includes('database not found') ||
+    message.includes('no beads configuration found') ||
+    message.includes('remote \'origin\' not found') ||
+    message.includes('remote "origin" not found')
+  );
+}
+
 /**
  * Forge Sync Command
  * Syncs Beads issue data by running dolt pull + push.
@@ -30,7 +41,7 @@ module.exports = {
     // Step 1: Check if bd binary exists
     try {
       exec('bd', ['--version'], { stdio: 'pipe' });
-    } catch (_checkErr) { /* intentional: bd not installed, skip sync gracefully */ // NOSONAR S2486
+    } catch { /* intentional: bd not installed, skip sync gracefully */ // NOSONAR S2486
       return {
         success: true,
         synced: false,
@@ -43,6 +54,13 @@ module.exports = {
       exec('bd', ['dolt', 'pull'], { stdio: 'pipe' });
       exec('bd', ['dolt', 'push'], { stdio: 'pipe' });
     } catch (syncErr) {
+      if (isRecoverableBeadsSyncError(syncErr)) {
+        return {
+          success: true,
+          synced: false,
+          message: 'Beads is installed but not initialized for sync in this worktree — skipping sync',
+        };
+      }
       return {
         success: false,
         synced: false,

package/lib/commands/update.js

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

package/lib/commands/validate.js

@@ -593,6 +593,19 @@ function executeDebugMode({ fixAttempts = 0, claim } = {}) {
 }
 
 module.exports = {
+	name: 'validate',
+	description: 'Run validation checks across type, lint, security, and tests',
+	handler: async () => {
+		const result = await executeValidate();
+		if (!result.success) {
+			return result;
+		}
+
+		return {
+			...result,
+			output: result.summary,
+		};
+	},
 	runTypeCheck,
 	runLint,
 	runSecurityScan,

package/lib/detect-agent.js

@@ -13,6 +13,25 @@
 const fs = require('node:fs');
 const path = require('node:path');
 
+const CANONICAL_AGENT_IDS = new Set([
+  'claude',
+  'cline',
+  'codex',
+  'copilot',
+  'cursor',
+  'kilocode',
+  'opencode',
+  'roo',
+]);
+
+const LEGACY_AGENT_ALIASES = Object.freeze({
+  'claude-code': 'claude',
+  'github-copilot': 'copilot',
+  kilo: 'kilocode',
+  'kilo-code': 'kilocode',
+  'roo-code': 'roo',
+});
+
 /**
  * Layer 2 mapping: env var → agent name.
  * Order matters — first match wins within this layer.
@@ -34,9 +53,9 @@ const AGENT_ENV_VARS = [
   // OpenCode
   ['OPENCODE_CLIENT', 'opencode'],
   // GitHub Copilot
-  ['COPILOT_MODEL', 'github-copilot'],
-  ['COPILOT_ALLOW_ALL', 'github-copilot'],
-  ['COPILOT_GITHUB_TOKEN', 'github-copilot'],
+  ['COPILOT_MODEL', 'copilot'],
+  ['COPILOT_ALLOW_ALL', 'copilot'],
+  ['COPILOT_GITHUB_TOKEN', 'copilot'],
   // Cline, Roo Code, Kilocode — no env vars (VSCode extensions, config-file-only)
 ];
 
@@ -52,16 +71,26 @@ const CONFIG_SIGNATURES = [
   [path.join('.cursor', 'rules'), 'cursor'],
   ['.clinerules', 'cline'],
   ['.cline', 'cline'],
-  [path.join('.roo', 'rules'), 'roo-code'],
-  ['.roo', 'roo-code'],
+  [path.join('.roo', 'rules'), 'roo'],
+  ['.roo', 'roo'],
+  ['.roorules', 'roo'],
+  ['.kilo.md', 'kilocode'],
   ['.kilocode', 'kilocode'],
   ['codex.md', 'codex'],
   ['.codex', 'codex'],
   [path.join('.opencode', 'commands'), 'opencode'],
   ['.opencode', 'opencode'],
-  [path.join('.github', 'copilot-instructions.md'), 'github-copilot'],
+  [path.join('.github', 'copilot-instructions.md'), 'copilot'],
 ];
 
+function normalizeAgentId(agentId) {
+  if (!agentId) return agentId;
+  const trimmed = String(agentId).trim();
+  if (!trimmed) return trimmed;
+  const normalized = trimmed.toLowerCase();
+  return LEGACY_AGENT_ALIASES[normalized] || (CANONICAL_AGENT_IDS.has(normalized) ? normalized : trimmed);
+}
+
 /**
  * Detect the actively running AI agent from environment signals.
  *
@@ -77,7 +106,7 @@ const CONFIG_SIGNATURES = [
 function detectActiveAgent(env = process.env) {
   // Layer 1: AI_AGENT universal env var
   if (env.AI_AGENT) {
-    return { name: env.AI_AGENT, source: 'env', confidence: 'high' };
+    return { name: normalizeAgentId(env.AI_AGENT), source: 'env', confidence: 'high' };
   }
 
   // Layer 2: Agent-specific env vars
@@ -144,7 +173,7 @@ function detectConfiguredAgents(projectRoot) {
     const fullPath = path.join(projectRoot, relativePath);
     try {
       if (fs.existsSync(fullPath)) {
-        detected.add(agentName);
+        detected.add(normalizeAgentId(agentName));
       }
     } catch (_err) {
       // Permission error or other fs issue — skip silently
@@ -188,4 +217,5 @@ module.exports = {
   detectActiveAgent,
   detectConfiguredAgents,
   detectEnvironment,
+  normalizeAgentId,
 };