forge-workflow 0.0.9 → 0.1.0-beta.2

package/scripts/beads-context.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# beads-context.sh — Helper script to manage Beads issue context
+# beads-context.sh — Helper script to manage issue context
 # for the Forge 7-stage workflow.
 #
 # Subcommands:
@@ -17,6 +17,9 @@ set -euo pipefail
 
 # Source shared sanitize library
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -f "$SCRIPT_DIR/bootstrap-windows-tools.sh" ]]; then
+  source "$SCRIPT_DIR/bootstrap-windows-tools.sh"
+fi
 source "$SCRIPT_DIR/lib/sanitize.sh"
 
 # ── Helpers ──────────────────────────────────────────────────────────────
@@ -41,11 +44,124 @@ die() {
   exit 1
 }
 
-# Run bd update and check for errors in both exit code and output.
-# bd update exits 0 even for non-existent issues, so we check stdout too.
-bd_update() {
+# Resolve a Windows forge.exe installation for bash-based helper flows.
+# This covers WSL/Git Bash cases where PowerShell can run forge.exe but bash PATH
+# does not include the Windows install directory.
+convert_windows_path() {
+  local raw="${1%$'\r'}"
+
+  if [[ -z "$raw" ]]; then
+    return 1
+  fi
+
+  if [[ ! "$raw" =~ ^[A-Za-z]:\\ ]]; then
+    printf '%s' "$raw"
+    return 0
+  fi
+
+  if command -v wslpath >/dev/null 2>&1; then
+    wslpath -u "$raw" 2>/dev/null && return 0
+  fi
+
+  if command -v cygpath >/dev/null 2>&1; then
+    cygpath -u "$raw" 2>/dev/null && return 0
+  fi
+
+  local drive rest
+  drive="$(printf '%s' "$raw" | cut -c1 | tr '[:upper:]' '[:lower:]')"
+  rest="${raw:2}"
+  rest="${rest//\\//}"
+  printf '/mnt/%s%s' "$drive" "$rest"
+}
+
+is_runnable_forge_candidate() {
+  local candidate="${1:-}"
+
+  if [[ -z "$candidate" || ! -f "$candidate" ]]; then
+    return 1
+  fi
+
+  [[ -x "$candidate" || "$candidate" == *.exe ]]
+}
+
+resolve_forge_cmd() {
+  local candidate=""
+  local converted=""
+
+  if [[ -n "${FORGE_CMD:-}" ]]; then
+    if [[ "${FORGE_CMD}" == *"/"* || "${FORGE_CMD}" == *"\\"* ]]; then
+      converted="$(convert_windows_path "$FORGE_CMD")"
+      if is_runnable_forge_candidate "$converted"; then
+        printf '%s' "$converted"
+        return 0
+      fi
+
+      is_runnable_forge_candidate "$FORGE_CMD" || return 1
+    fi
+    printf '%s' "$FORGE_CMD"
+    return 0
+  fi
+
+  if command -v forge >/dev/null 2>&1; then
+    printf '%s' "forge"
+    return 0
+  fi
+
+  if command -v forge.exe >/dev/null 2>&1; then
+    printf '%s' "forge.exe"
+    return 0
+  fi
+
+  for candidate in \
+    "$HOME/.local/bin/forge" \
+    "$HOME/.local/bin/forge.exe" \
+    "$HOME/.bun/bin/forge" \
+    "$HOME/.bun/bin/forge.exe"
+  do
+    if is_runnable_forge_candidate "$candidate"; then
+      printf '%s' "$candidate"
+      return 0
+    fi
+  done
+
+  if command -v where.exe >/dev/null 2>&1; then
+    while IFS= read -r candidate; do
+      candidate="${candidate%$'\r'}"
+      [[ -z "$candidate" ]] && continue
+
+      converted="$(convert_windows_path "$candidate")"
+      if is_runnable_forge_candidate "$converted"; then
+        printf '%s' "$converted"
+        return 0
+      fi
+
+      if is_runnable_forge_candidate "$candidate"; then
+        printf '%s' "$candidate"
+        return 0
+      fi
+    done < <(where.exe forge 2>/dev/null || true)
+  fi
+
+  return 1
+}
+
+FORGE=""
+
+get_forge_cmd() {
+  if [[ -z "$FORGE" ]]; then
+    FORGE="$(resolve_forge_cmd)" || die "forge is required but not found"
+  fi
+
+  printf '%s' "$FORGE"
+}
+
+# Run forge issue update and check for errors in both exit code and output.
+# The update operation exits 0 even for non-existent issues, so we check stdout too.
+forge_update() {
+  local forge_cmd
+  forge_cmd="$(get_forge_cmd)"
   local output
-  output="$(bd update "$@" 2>&1)"
+  output="$("$forge_cmd" issue update "$@" 2>&1)"
   local rc=$?
 
   if [[ $rc -ne 0 ]]; then
@@ -53,7 +169,7 @@ bd_update() {
     return 1
   fi
 
-  # bd prints "Error resolving/updating ..." to stdout for non-existent issues
+  # Forge prints "Error resolving/updating ..." to stdout for non-existent issues
   # Use specific patterns to avoid false positives from data containing "error"
   if printf '%s' "$output" | grep -Eqi '^Error|Error resolving|Error updating'; then
     echo "$output" >&2
@@ -64,10 +180,12 @@ bd_update() {
   return 0
 }
 
-# Run bd comments add and check for errors similarly.
-bd_comment() {
+# Run forge issue comment and check for errors similarly.
+forge_comment() {
+  local forge_cmd
+  forge_cmd="$(get_forge_cmd)"
   local output
-  output="$(bd comments add "$@" 2>&1)"
+  output="$("$forge_cmd" issue comment "$@" 2>&1)"
   local rc=$?
 
   if [[ $rc -ne 0 ]]; then
@@ -85,6 +203,25 @@ bd_comment() {
   return 0
 }
 
+# Extract concatenated comment text from a `forge issue show --json` payload.
+# Forge/issue show returns comments as an array of objects ({text:...}) — matching
+# the issue-state contract in lib/workflow/state-manager.js — or, defensively, a
+# raw string. jq is preferred; a grep/sed fallback captures "text" fields.
+extract_comments_text() {
+  local json="$1"
+
+  if command -v jq &>/dev/null; then
+    printf '%s' "$json" | jq -r '
+      ((if type == "array" then .[0] else . end).comments // [])
+      | if type == "array" then (map(.text? // tostring) | join("\n"))
+        else tostring end
+    ' 2>/dev/null || true
+    return 0
+  fi
+
+  printf '%s' "$json" | grep -o '"text": *"[^"]*"' | sed 's/^"text": *"//;s/"$//' || true
+}
+
 # ── Subcommands ──────────────────────────────────────────────────────────
 
 cmd_set_design() {
@@ -101,7 +238,7 @@ cmd_set_design() {
 
   local design_text="${task_count} tasks | ${task_file}"
 
-  if ! bd_update "$issue_id" --design "$design_text" > /dev/null; then
+  if ! forge_update "$issue_id" --design "$design_text" > /dev/null; then
     die "Failed to set design on issue ${issue_id}"
   fi
 
@@ -118,7 +255,7 @@ cmd_set_acceptance() {
   local criteria
   criteria="$(sanitize "$2")"
 
-  if ! bd_update "$issue_id" --acceptance "$criteria" > /dev/null; then
+  if ! forge_update "$issue_id" --acceptance "$criteria" > /dev/null; then
     die "Failed to set acceptance on issue ${issue_id}"
   fi
 
@@ -158,7 +295,7 @@ cmd_update_progress() {
 
   local note="Task ${task_num}/${total} done: ${title} | ${test_count} tests | ${commit_sha} | ${gate_count} gates"
 
-  if ! bd_update "$issue_id" --append-notes "$note" > /dev/null; then
+  if ! forge_update "$issue_id" --append-notes "$note" > /dev/null; then
     die "Failed to update progress on issue ${issue_id}"
   fi
 
@@ -172,18 +309,20 @@ cmd_parse_progress() {
   fi
 
   local issue_id="$1"
+  local forge_cmd
+  forge_cmd="$(get_forge_cmd)"
 
   # Get the issue JSON — detect non-existent issues
   local json
-  json="$(bd show "$issue_id" --json 2>&1)" || die "Failed to show issue ${issue_id}"
+  json="$("$forge_cmd" issue show "$issue_id" --json 2>&1)" || die "Failed to show issue ${issue_id}"
 
-  # bd show may exit 0 but print an error for non-existent issues
-  # Match specific bd error patterns, not the word "error" in data fields
+  # show may exit 0 but print an error for non-existent issues
+  # Match specific error patterns, not the word "error" in data fields
   if printf '%s' "$json" | grep -Eqi '^Error (fetching|resolving)'; then
     die "Issue not found: ${issue_id}"
   fi
 
-  # bd show returns "[]" or empty for non-existent issues
+  # show returns "[]" or empty for non-existent issues
   if [[ -z "$json" || "$json" == "[]" || "$json" == "null" ]]; then
     die "Issue not found: ${issue_id}"
   fi
@@ -191,7 +330,7 @@ cmd_parse_progress() {
   # Extract notes field from JSON — prefer jq if available, fall back to grep/sed
   local notes
   if command -v jq &>/dev/null; then
-    # Handle both array ([{...}]) and object ({...}) responses from bd show
+    # Handle both array ([{...}]) and object ({...}) show responses
     notes="$(printf '%s' "$json" | jq -r 'if type == "array" then .[0].notes else .notes end // empty' 2>/dev/null || true)"
   else
     notes="$(printf '%s' "$json" | grep -o '"notes": *"[^"]*"' | head -1 | sed 's/^"notes": *"//;s/"$//' || true)"
@@ -305,7 +444,7 @@ Next: ${flag_next}"
 WorkflowState: ${flag_workflow_state}"
   fi
 
-  if ! bd_comment "$issue_id" "$comment" > /dev/null; then
+  if ! forge_comment "$issue_id" "$comment" > /dev/null; then
     die "Failed to record stage transition on issue ${issue_id}"
   fi
 
@@ -320,15 +459,17 @@ cmd_validate() {
 
   local issue_id="$1"
   local warnings=0
+  local forge_cmd
+  forge_cmd="$(get_forge_cmd)"
 
   # Get issue JSON
   local json
-  json="$(bd show "$issue_id" --json 2>&1)" || {
+  json="$("$forge_cmd" issue show "$issue_id" --json 2>&1)" || {
     echo "Error: Failed to retrieve issue ${issue_id}" >&2
     exit 1
   }
 
-  # Check for bd error patterns
+  # Check for error patterns
   if printf '%s' "$json" | grep -Eqi '^Error|Error resolving|Error fetching'; then
     echo "Error: Issue not found: ${issue_id}" >&2
     exit 1
@@ -355,9 +496,11 @@ cmd_validate() {
     warnings=$((warnings + 1))
   fi
 
-  # Get comments to check for stage transitions
+  # The issue payload returned by `forge issue show --json` already includes its
+  # comment history, so the stage-transition checks read comments from that single
+  # response rather than issuing a separate comment-list query.
   local comments
-  comments="$(bd comments list "$issue_id" 2>/dev/null || true)"
+  comments="$(extract_comments_text "$json")"
 
   # Check 2: At least one stage transition exists
   local has_transition=false

package/scripts/beads-migrate-to-dolt.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+NODE_CMD="${NODE_CMD:-node}"
+
+exec "$NODE_CMD" "$SCRIPT_DIR/lib/beads-migrate-to-dolt.mjs" "$@"

package/scripts/beads-upgrade-smoke.sh

@@ -0,0 +1,284 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+_BEADS_UPGRADE_SMOKE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -f "$_BEADS_UPGRADE_SMOKE_DIR/bootstrap-windows-tools.sh" ]]; then
+  source "$_BEADS_UPGRADE_SMOKE_DIR/bootstrap-windows-tools.sh"
+fi
+
+BD_CMD="${BD_CMD:-bd}"
+NODE_CMD="${NODE_CMD:-node}"
+PROJECT_ROOT="${PROJECT_ROOT:-$(pwd)}"
+ARTIFACT_DIR="${BEADS_UPGRADE_SMOKE_ARTIFACT_DIR:-${PROJECT_ROOT}/.artifacts/beads-upgrade-smoke}"
+COMMAND_LOG_PATH="${ARTIFACT_DIR}/commands.jsonl"
+SUMMARY_PATH="${ARTIFACT_DIR}/summary.json"
+CLEANUP_REASON="Beads upgrade smoke cleanup"
+SMOKE_RUN_ID="${BEADS_UPGRADE_SMOKE_RUN_ID:-$(date +%s)-$$}"
+PRIMARY_ISSUE_TITLE="Beads upgrade smoke primary (${SMOKE_RUN_ID})"
+DEPENDENT_ISSUE_TITLE="Beads upgrade smoke dependent (${SMOKE_RUN_ID})"
+
+node_fs_path() {
+  case "$1" in
+    /[A-Za-z]/*)
+      _drive="$(printf '%s' "${1:1:1}" | tr '[:lower:]' '[:upper:]')"
+      printf '%s:/%s\n' "$_drive" "${1:3}"
+      ;;
+    *)
+      if command -v cygpath >/dev/null 2>&1; then
+        cygpath -m "$1"
+      else
+        printf '%s\n' "$1"
+      fi
+      ;;
+  esac
+}
+
+mkdir -p "${ARTIFACT_DIR}"
+: > "${COMMAND_LOG_PATH}"
+
+created_issue_ids=()
+closed_issue_ids=()
+failed_step=""
+failure_message=""
+
+parse_issue_id() {
+  local output="$1"
+  if [[ "${output}" =~ Created[[:space:]]+issue:[[:space:]]*([[:alnum:]-]+) ]]; then
+    printf '%s' "${BASH_REMATCH[1]}"
+    return 0
+  fi
+  if [[ "${output}" =~ \"id\"[[:space:]]*:[[:space:]]*\"([[:alnum:]-]+)\" ]]; then
+    printf '%s' "${BASH_REMATCH[1]}"
+    return 0
+  fi
+  return 1
+}
+
+find_issue_id_by_title() {
+  local issue_title="$1"
+  local list_output
+  list_output="$("${BD_CMD}" list --json --limit=50 2>/dev/null)" || return 1
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [issueTitle] = process.argv.slice(1);
+    try {
+      const rows = JSON.parse(fs.readFileSync(0, "utf8"));
+      if (!Array.isArray(rows)) {
+        process.exit(1);
+      }
+      const match = rows.find((row) => row && row.title === issueTitle && typeof row.id === "string");
+      if (!match) {
+        process.exit(1);
+      }
+      process.stdout.write(match.id);
+    } catch {
+      process.exit(1);
+    }
+  ' "${issue_title}" <<< "${list_output}"
+}
+
+append_command() {
+  local step="$1"
+  local command_name="$2"
+  local command_text="$3"
+  local exit_code="$4"
+  local stdout_path="$5"
+  local stderr_path="$6"
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [logPath, step, commandName, commandText, exitCode, stdoutPath, stderrPath] = process.argv.slice(1);
+    const entry = {
+      step,
+      commandName,
+      commandText,
+      exitCode: Number(exitCode),
+      stdoutPath,
+      stderrPath,
+    };
+    fs.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+  ' "$(node_fs_path "${COMMAND_LOG_PATH}")" "${step}" "${command_name}" "${command_text}" "${exit_code}" "$(node_fs_path "${stdout_path}")" "$(node_fs_path "${stderr_path}")"
+}
+
+read_output_snippet() {
+  local file_path="$1"
+  if [[ ! -f "${file_path}" ]]; then
+    return 0
+  fi
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [filePath] = process.argv.slice(1);
+    const text = fs.readFileSync(filePath, "utf8");
+    process.stdout.write(text.slice(0, 4096));
+  ' "$(node_fs_path "${file_path}")"
+}
+
+write_summary() {
+  local ok="$1"
+
+  "${NODE_CMD}" -e '
+    const fs = require("node:fs");
+    const [
+      commandLogPath,
+      summaryPath,
+      okValue,
+      failedStep,
+      failureMessage,
+      artifactDir,
+      createdJson,
+      closedJson,
+    ] = process.argv.slice(1);
+    const commands = fs.readFileSync(commandLogPath, "utf8")
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    const summary = {
+      ok: okValue === "true",
+      failedStep: failedStep || null,
+      failureMessage: failureMessage || null,
+      commands,
+      cleanup: {
+        createdIssueIds: JSON.parse(createdJson),
+        closedIssueIds: JSON.parse(closedJson),
+      },
+      failureArtifact: summaryPath,
+      artifactDir,
+    };
+    fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2) + "\n");
+  ' "$(node_fs_path "${COMMAND_LOG_PATH}")" "$(node_fs_path "${SUMMARY_PATH}")" "${ok}" "${failed_step}" "${failure_message}" "$(node_fs_path "${ARTIFACT_DIR}")" "$(printf '%s\n' "${created_issue_ids[@]:-}" | "${NODE_CMD}" -e 'const fs=require("node:fs"); const lines=fs.readFileSync(0,"utf8").split(/\r?\n/).filter(Boolean); process.stdout.write(JSON.stringify(lines));')" "$(printf '%s\n' "${closed_issue_ids[@]:-}" | "${NODE_CMD}" -e 'const fs=require("node:fs"); const lines=fs.readFileSync(0,"utf8").split(/\r?\n/).filter(Boolean); process.stdout.write(JSON.stringify(lines));')"
+}
+
+run_bd_step() {
+  local step="$1"
+  local command_name="$2"
+  shift 2
+
+  local stdout_file stderr_file exit_code command_text
+  stdout_file="${ARTIFACT_DIR}/$(printf '%s' "${step}" | tr '[:upper:]' '[:lower:]').stdout"
+  stderr_file="${ARTIFACT_DIR}/$(printf '%s' "${step}" | tr '[:upper:]' '[:lower:]').stderr"
+  command_text="$*"
+
+  if "${BD_CMD}" "$@" >"${stdout_file}" 2>"${stderr_file}"; then
+    exit_code=0
+  else
+    exit_code=$?
+  fi
+
+  append_command "${step}" "${command_name}" "${command_text}" "${exit_code}" "${stdout_file}" "${stderr_file}"
+
+  if [[ "${exit_code}" -ne 0 ]]; then
+    failed_step="${command_name}"
+    local stderr_text stdout_text
+    stderr_text="$(read_output_snippet "${stderr_file}")"
+    stdout_text="$(read_output_snippet "${stdout_file}")"
+    failure_message="${stderr_text:-${stdout_text:-${command_text}}}"
+    return "${exit_code}"
+  fi
+
+  cat "${stdout_file}"
+}
+
+is_closed_issue() {
+  local issue_id="$1"
+  local existing
+  for existing in "${closed_issue_ids[@]:-}"; do
+    if [[ "${existing}" == "${issue_id}" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+rollback_unclosed_issues() {
+  local idx issue_id
+  for (( idx=${#created_issue_ids[@]} - 1; idx>=0; idx-- )); do
+    issue_id="${created_issue_ids[idx]}"
+    if is_closed_issue "${issue_id}"; then
+      continue
+    fi
+    if run_bd_step "rollback-close-${issue_id}" "close" close "${issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null; then
+      closed_issue_ids+=("${issue_id}")
+    fi
+  done
+}
+
+handle_issue_id_parse_failure() {
+  local issue_title="$1"
+  local message="$2"
+  local recovered_issue_id=""
+
+  failed_step="create"
+  failure_message="${message}"
+
+  recovered_issue_id="$(find_issue_id_by_title "${issue_title}" || true)"
+  if [[ -n "${recovered_issue_id}" ]]; then
+    created_issue_ids+=("${recovered_issue_id}")
+  fi
+
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+primary_output="$(run_bd_step "create-primary" "create" create --title="${PRIMARY_ISSUE_TITLE}" --type=task --priority=4)" || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+primary_issue_id="$(parse_issue_id "${primary_output}")" || {
+  handle_issue_id_parse_failure "${PRIMARY_ISSUE_TITLE}" "Could not parse primary smoke issue ID"
+}
+created_issue_ids+=("${primary_issue_id}")
+
+dependent_output="$(run_bd_step "create-dependent" "create" create --title="${DEPENDENT_ISSUE_TITLE}" --type=task --priority=4)" || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+dependent_issue_id="$(parse_issue_id "${dependent_output}")" || {
+  handle_issue_id_parse_failure "${DEPENDENT_ISSUE_TITLE}" "Could not parse dependent smoke issue ID"
+}
+created_issue_ids+=("${dependent_issue_id}")
+
+run_bd_step "list" "list" list --json --limit=50 >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "show-primary" "show" show "${primary_issue_id}" --json >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "dep-add" "dep" dep add "${primary_issue_id}" "${dependent_issue_id}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+run_bd_step "close-dependent" "close" close "${dependent_issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+closed_issue_ids+=("${dependent_issue_id}")
+
+run_bd_step "close-primary" "close" close "${primary_issue_id}" "--reason=${CLEANUP_REASON}" >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+closed_issue_ids+=("${primary_issue_id}")
+
+run_bd_step "sync" "sync" sync >/dev/null || {
+  rollback_unclosed_issues
+  write_summary "false"
+  exit 1
+}
+
+write_summary "true"
+printf '%s\n' "${SUMMARY_PATH}"