forge-workflow 0.0.7 → 0.0.8

package/bin/forge.js

@@ -2541,6 +2541,13 @@ function parseFlags() {
     sync: false,      // Scaffold Beads GitHub sync workflows (--sync)
   };
 
+  // Issue passthrough commands delegate all flags to bd.
+  // Skip global parsing so flags like --type, -p, --help reach the handler intact.
+  const issuePassthroughCommands = ['create', 'update', 'claim', 'close', 'show', 'list', 'ready', 'issue'];
+  if (issuePassthroughCommands.includes(args[0])) {
+    return flags;
+  }
+
   for (let i = 0; i < args.length;) {
     const arg = args[i];
 

package/lib/commands/_issue.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+
+const SUBCOMMANDS = {
+  create: {
+    description: 'Create a Beads issue via Forge',
+    usage: 'forge create [title] [bd-create-flags]',
+    helpCommand: 'create',
+    buildBdArgs: (args) => ['create', ...args],
+  },
+  update: {
+    description: 'Update a Beads issue via Forge',
+    usage: 'forge update <id...> [bd-update-flags]',
+    helpCommand: 'update',
+    buildBdArgs: (args) => ['update', ...args],
+  },
+  claim: {
+    description: 'Claim a Beads issue via Forge',
+    usage: 'forge claim <id> [bd-update-flags]',
+    helpCommand: 'update',
+    buildBdArgs: (args) => {
+      const [issueId, ...rest] = args;
+      if (!issueId) {
+        return { error: 'Missing issue id. Usage: forge claim <id> [bd-update-flags]' };
+      }
+      return ['update', issueId, '--claim', ...rest];
+    },
+  },
+  close: {
+    description: 'Close a Beads issue via Forge',
+    usage: 'forge close <id...> [bd-close-flags]',
+    helpCommand: 'close',
+    buildBdArgs: (args) => ['close', ...args],
+  },
+  show: {
+    description: 'Show a Beads issue via Forge',
+    usage: 'forge show <id> [bd-show-flags]',
+    helpCommand: 'show',
+    buildBdArgs: (args) => ['show', ...args],
+  },
+  list: {
+    description: 'List Beads issues via Forge',
+    usage: 'forge list [bd-list-flags]',
+    helpCommand: 'list',
+    buildBdArgs: (args) => ['list', ...args],
+  },
+  ready: {
+    description: 'Show ready Beads issues via Forge',
+    usage: 'forge ready [bd-ready-flags]',
+    helpCommand: 'ready',
+    buildBdArgs: (args) => ['ready', ...args],
+  },
+};
+
+function normalizeArgs(args = []) {
+  return args.filter(arg => arg !== '--');
+}
+
+function getExecOptions(projectRoot) {
+  return {
+    cwd: projectRoot,
+    stdio: 'inherit',
+  };
+}
+
+function formatIssueHelp() {
+  const lines = [
+    'Usage: forge issue <subcommand> [...]',
+    '',
+    'Supported subcommands:',
+  ];
+
+  for (const [name, spec] of Object.entries(SUBCOMMANDS)) {
+    lines.push(`  ${name.padEnd(6)} ${spec.description}`);
+  }
+
+  lines.push('');
+  lines.push('Examples:');
+  lines.push('  forge create --title "Add feature" --type feature');
+  lines.push('  forge claim forge-abc');
+  lines.push('  forge update forge-abc --priority 1');
+  lines.push('  forge close forge-abc --reason "Done"');
+  lines.push('  forge issue show forge-abc --json');
+
+  return lines.join('\n');
+}
+
+function extractErrorMessage(error) {
+  if (error?.code === 'ENOENT') {
+    return 'Beads (bd) command not found. Install or initialize Beads before using Forge issue commands.';
+  }
+
+  // With stdio: 'inherit', error.stderr and error.stdout are always null.
+  // Only error.message is available for diagnostics.
+  return error?.message?.trim() || 'Beads command failed';
+}
+
+function buildBdArgs(subcommand, rawArgs) {
+  const spec = SUBCOMMANDS[subcommand];
+  if (!spec) {
+    return { error: `Unknown issue subcommand '${subcommand}'.\n\n${formatIssueHelp()}` };
+  }
+
+  const args = normalizeArgs(rawArgs);
+  if (args.includes('--help') || args.includes('-h')) {
+    return [spec.helpCommand, '--help'];
+  }
+
+  return spec.buildBdArgs(args);
+}
+
+async function runIssueSubcommand(subcommand, args, projectRoot, opts = {}) {
+  const exec = opts._exec || execFileSync;
+  const bdArgs = buildBdArgs(subcommand, args);
+
+  if (!Array.isArray(bdArgs)) {
+    return { success: false, error: bdArgs.error };
+  }
+
+  try {
+    exec('bd', bdArgs, getExecOptions(projectRoot));
+    return { success: true, subcommand };
+  } catch (error) {
+    return {
+      success: false,
+      error: extractErrorMessage(error),
+    };
+  }
+}
+
+function makeAliasCommand(subcommand) {
+  const spec = SUBCOMMANDS[subcommand];
+  if (!spec) {
+    throw new Error(`Unknown issue subcommand '${subcommand}'`);
+  }
+
+  return {
+    name: subcommand,
+    description: spec.description,
+    usage: spec.usage,
+    flags: {},
+    handler: async (args, _flags, projectRoot, opts = {}) =>
+      runIssueSubcommand(subcommand, args, projectRoot, opts),
+  };
+}
+
+function createIssueCommand() {
+  return {
+    name: 'issue',
+    description: 'Manage Beads issues through the Forge command surface',
+    usage: 'forge issue <create|update|claim|close|show|list|ready> [...]',
+    flags: {},
+    handler: async (args, _flags, projectRoot, opts = {}) => {
+      const [subcommand, ...rest] = normalizeArgs(args);
+
+      if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+        return { success: true, output: formatIssueHelp() };
+      }
+
+      return runIssueSubcommand(subcommand, rest, projectRoot, opts);
+    },
+  };
+}
+
+module.exports = {
+  SUBCOMMANDS,
+  buildBdArgs,
+  createIssueCommand,
+  makeAliasCommand,
+  runIssueSubcommand,
+};

package/lib/commands/claim.js

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

package/lib/commands/close.js

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

package/lib/commands/create.js

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

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

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

package/lib/commands/show.js

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-workflow",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "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/lib/eval-runner.js

@@ -9,6 +9,7 @@
  */
 
 const path = require('path');
+const fs = require('fs');
 const { execSync } = require('node:child_process');
 
 // ── active worktree tracking (cleanup on crash) ─────────────────────
@@ -17,6 +18,17 @@ const { execSync } = require('node:child_process');
 // Note: execSync is safe here — all paths are internally generated, never user input.
 const activeEvalWorktrees = new Map(); // path -> branch
 
+/**
+ * Force-remove a directory that git worktree remove may leave behind (Windows).
+ */
+function forceRemoveDir(dirPath) {
+  try {
+    if (fs.existsSync(dirPath)) {
+      fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+  } catch (_err) { /* best-effort */ }
+}
+
 function cleanupActiveWorktrees() {
   if (activeEvalWorktrees.size === 0) return;
   let repoRoot;
@@ -25,6 +37,7 @@ function cleanupActiveWorktrees() {
     try {
       execSync(`git worktree remove --force "${wtPath}"`, { cwd: repoRoot, stdio: 'pipe' });
     } catch (_err) { /* already removed */ }
+    forceRemoveDir(wtPath);
     if (branch && branch.startsWith('eval-')) {
       try {
         execSync(`git branch -D "${branch}"`, { cwd: repoRoot, stdio: 'pipe' });
@@ -35,6 +48,37 @@ function cleanupActiveWorktrees() {
   activeEvalWorktrees.clear();
 }
 
+/**
+ * Remove stale eval-* directories left behind by crashed runs.
+ * Git has already forgotten them (worktree prune), but the directories persist on Windows.
+ */
+function cleanupStaleEvalWorktrees() {
+  try {
+    const worktreesDir = getWorktreesDir();
+    if (!fs.existsSync(worktreesDir)) return;
+
+    // Get the list of paths git still knows about
+    const repoRoot = getRepoRoot();
+    const knownRaw = execSync('git worktree list --porcelain', {
+      cwd: repoRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const knownPaths = new Set(
+      knownRaw.split('\n')
+        .filter((l) => l.startsWith('worktree '))
+        .map((l) => l.slice('worktree '.length).replace(/\\/g, '/'))
+    );
+
+    const entries = fs.readdirSync(worktreesDir);
+    for (const entry of entries) {
+      if (!entry.startsWith('eval-')) continue;
+      const fullPath = path.join(worktreesDir, entry).replace(/\\/g, '/');
+      if (!knownPaths.has(fullPath)) {
+        forceRemoveDir(path.join(worktreesDir, entry));
+      }
+    }
+  } catch (_err) { /* best-effort — don't block eval creation */ }
+}
+
 process.on('exit', cleanupActiveWorktrees);
 process.on('SIGINT', () => {
   const hadWork = activeEvalWorktrees.size > 0;
@@ -78,6 +122,9 @@ function getWorktreesDir() {
  * @returns {Promise<{ path: string, branch: string }>}
  */
 async function createEvalWorktree() {
+  // Self-heal: remove stale eval dirs from previous crashed runs
+  cleanupStaleEvalWorktrees();
+
   const timestamp = Date.now();
   const pid = process.pid;
   const name = `eval-${timestamp}-${pid}`;
@@ -128,6 +175,9 @@ async function destroyEvalWorktree(worktreePath) {
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
+  // Windows: git worktree remove often leaves the directory behind
+  forceRemoveDir(worktreePath);
+
   // Prune to clean up references
   execSync('git worktree prune', {
     cwd: repoRoot,