forge-workflow 0.0.6 → 0.0.8

package/lib/commands/commands-reset.js

@@ -0,0 +1,147 @@
+'use strict';
+
+/**
+ * @module commands-reset
+ *
+ * Reset agent command files to match the canonical source (commands/*.md or .claude/commands/*.md).
+ * Rebuilds adapted files via sync-commands and optionally writes them.
+ *
+ * Used by `forge commands reset [--dry-run] [--all] [command-name]`.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {
+  syncCommands,
+  contentHash,
+  resolveCanonicalCommandsDir,
+  writeSyncManifest,
+} = require('../../scripts/sync-commands.js');
+
+function validateCommandName(commandName) {
+  if (commandName && !/^[a-z0-9-]+$/.test(commandName)) {
+    return [`Invalid command name: "${commandName}" - only lowercase letters, numbers, and hyphens allowed`];
+  }
+
+  return [];
+}
+
+function ensureCanonicalCommandExists(repoRoot, canonicalDir, commandName) {
+  if (!commandName) {
+    return [];
+  }
+
+  if (fs.existsSync(path.join(canonicalDir, `${commandName}.md`))) {
+    return [];
+  }
+
+  const canonicalLabel = path.relative(repoRoot, canonicalDir).replaceAll('\\', '/');
+  return [`Command not found: ${canonicalLabel}/${commandName}.md`];
+}
+
+function filterPlannedEntries(entries, commandName, all) {
+  if (commandName && all !== true) {
+    return entries.filter(entry =>
+      entry.filename.replaceAll('.prompt.md', '').replaceAll('.md', '') === commandName ||
+      entry.dir.includes(`/${commandName}/`)
+    );
+  }
+
+  return entries;
+}
+
+function recordEntryResult(entry, reset, skipped, dryRun) {
+  const relativeFile = path.join(entry.dir, entry.filename);
+
+  if (dryRun) {
+    if (fs.existsSync(entry.filePath)) {
+      const existing = fs.readFileSync(entry.filePath, 'utf8');
+      if (contentHash(existing) === contentHash(entry.content)) {
+        skipped.push({ agent: entry.agent, file: relativeFile });
+      } else {
+        reset.push({ agent: entry.agent, file: relativeFile });
+      }
+    } else {
+      reset.push({ agent: entry.agent, file: relativeFile });
+    }
+    return;
+  }
+
+  const targetDir = path.dirname(entry.filePath);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  if (fs.existsSync(entry.filePath)) {
+    const existing = fs.readFileSync(entry.filePath, 'utf8');
+    if (contentHash(existing) === contentHash(entry.content)) {
+      skipped.push({ agent: entry.agent, file: relativeFile });
+      return;
+    }
+  }
+
+  fs.writeFileSync(entry.filePath, entry.content);
+  reset.push({ agent: entry.agent, file: relativeFile });
+}
+
+function resetCommands({ repoRoot, commandName, all, dryRun }) {
+  const errors = [];
+  const reset = [];
+  const skipped = [];
+
+  errors.push(...validateCommandName(commandName));
+  if (errors.length > 0) {
+    return { reset, skipped, errors };
+  }
+
+  const canonicalDir = resolveCanonicalCommandsDir(repoRoot);
+  if (!canonicalDir) {
+    errors.push('Canonical source directory not found: commands/ or .claude/commands/');
+    return { reset, skipped, errors };
+  }
+
+  errors.push(...ensureCanonicalCommandExists(repoRoot, canonicalDir, commandName));
+  if (errors.length > 0) {
+    return { reset, skipped, errors };
+  }
+
+  const result = syncCommands({ dryRun: true, check: false, repoRoot, canonicalDir });
+  if (!result.planned || result.planned.length === 0) {
+    return { reset, skipped, errors };
+  }
+
+  const entries = filterPlannedEntries(result.planned, commandName, all);
+  for (const entry of entries) {
+    recordEntryResult(entry, reset, skipped, dryRun);
+  }
+
+  if (!dryRun) {
+    // Refresh the manifest using the full expected sync set without rewriting
+    // unrelated command files that were intentionally excluded from this reset.
+    writeSyncManifest(repoRoot, result.planned);
+  }
+
+  return { reset, skipped, errors };
+}
+
+module.exports = {
+  name: 'commands-reset',
+  description: 'Reset generated agent command files to canonical content',
+  handler: async (args, flags, repoRoot) => {
+    const commandName = args.find(arg => !arg.startsWith('-'));
+    const result = resetCommands({
+      repoRoot,
+      commandName,
+      all: Boolean(flags.all),
+      dryRun: Boolean(flags.dryRun),
+    });
+
+    if (result.errors.length > 0) {
+      return { success: false, error: result.errors.join('; ') };
+    }
+
+    return { success: true, ...result };
+  },
+  resetCommands,
+  resolveCanonicalCommandsDir,
+};

package/lib/commands/create.js

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

package/lib/commands/dev.js

@@ -558,6 +558,32 @@ function verifyTaskCompletion(taskTitle, ownedFiles, opts = {}) {
 }
 
 module.exports = {
+	name: 'dev',
+	description: 'Run the TDD development stage with phase guidance',
+	handler: async (args, flags = {}) => {
+		const featureName = args[0] || 'feature';
+		const phaseInput = flags.phase || args[1];
+		const phase = typeof phaseInput === 'string' ? phaseInput.toUpperCase() : undefined;
+		if (phase && !['RED', 'GREEN', 'REFACTOR'].includes(phase)) {
+			return {
+				success: false,
+				error: `Invalid phase '${phaseInput}'. Valid phases: red, green, refactor`,
+			};
+		}
+
+		const result = await executeDev(featureName, phase ? { phase } : {});
+		if (!result.success) {
+			return result;
+		}
+
+		const lines = [`TDD Phase: ${result.phase || result.detectedPhase}`];
+		if (result.guidance) lines.push('', result.guidance);
+
+		return {
+			...result,
+			output: lines.join('\n'),
+		};
+	},
 	detectTDDPhase,
 	identifyFilePairs,
 	runTests,

package/lib/commands/issue.js

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

package/lib/commands/list.js

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

package/lib/commands/plan.js

@@ -680,6 +680,24 @@ async function executePlan(featureName) { // NOSONAR S3776
 }
 
 module.exports = {
+	name: 'plan',
+	description: 'Create implementation plan from researched feature context',
+	handler: async (args) => {
+		const result = await executePlan(args[0]);
+		if (!result.success) {
+			return result;
+		}
+
+		const lines = [`Plan created: ${result.summary || result.branchName || args[0]}`];
+		if (result.beadsIssueId) lines.push(`Beads: ${result.beadsIssueId}`);
+		if (result.branchName) lines.push(`Branch: ${result.branchName}`);
+		if (result.nextCommand) lines.push(`Next: ${result.nextCommand}`);
+
+		return {
+			...result,
+			output: lines.join('\n'),
+		};
+	},
 	readResearchDoc,
 	detectScope,
 	createBeadsIssue,

package/lib/commands/ready.js

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