forge-workflow 0.0.9 → 0.0.10

package/scripts/beads-upgrade-smoke.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+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})"
+
+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");
+  ' "${COMMAND_LOG_PATH}" "${step}" "${command_name}" "${command_text}" "${exit_code}" "${stdout_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));
+  ' "${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");
+  ' "${COMMAND_LOG_PATH}" "${SUMMARY_PATH}" "${ok}" "${failed_step}" "${failure_message}" "${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}"

package/scripts/behavioral-judge.sh

@@ -66,10 +66,25 @@ else
   INPUT="$(cat)"
 fi
 
-# Extract plan_output text if input is JSON, otherwise use raw input
-PLAN_TEXT="$INPUT"
-if command -v python3 >/dev/null 2>&1; then
-  EXTRACTED=$(echo "$INPUT" | python3 -c "
+extract_plan_text() {
+  if command -v node >/dev/null 2>&1; then
+    node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const parsed = JSON.parse(input);
+    const value = parsed && parsed.plan_output;
+    if (value) process.stdout.write(String(value));
+  } catch (_) {}
+});
+" 2>/dev/null
+    return $?
+  fi
+
+  if command -v python3 >/dev/null 2>&1; then
+    python3 -c "
 import sys, json
 try:
     d = json.load(sys.stdin)
@@ -78,10 +93,16 @@ try:
         print(val)
 except:
     pass
-" 2>/dev/null) || true
-  if [ -n "$EXTRACTED" ]; then
-    PLAN_TEXT="$EXTRACTED"
+" 2>/dev/null
+    return $?
   fi
+}
+
+# Extract plan_output text if input is JSON, otherwise use raw input
+PLAN_TEXT="$INPUT"
+EXTRACTED=$(printf '%s' "$INPUT" | extract_plan_text) || true
+if [ -n "$EXTRACTED" ]; then
+  PLAN_TEXT="$EXTRACTED"
 fi
 
 # ─── Judge prompt ────────────────────────────────────────────────────────────
@@ -158,7 +179,22 @@ parse_scores() {
   local response="$1"
   # Extract the JSON object from the LLM response content
   local content
-  content=$(echo "$response" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    content=$(printf '%s' "$response" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const choice = (data.choices || [])[0] || {};
+    const message = choice.message || {};
+    process.stdout.write(String(message.content || ''));
+  } catch (_) {}
+});
+" 2>/dev/null) || true
+  elif command -v python3 >/dev/null 2>&1; then
+    content=$(printf '%s' "$response" | python3 -c "
 import sys, json
 try:
     data = json.load(sys.stdin)
@@ -170,6 +206,9 @@ try:
 except Exception as e:
     pass
 " 2>/dev/null) || true
+  else
+    content=""
+  fi
 
   if [ -z "$content" ]; then
     echo ""
@@ -178,7 +217,37 @@ except Exception as e:
 
   # Parse scores from content JSON
   local scores
-  scores=$(echo "$content" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    scores=$(printf '%s' "$content" | node -e "
+let text = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { text += chunk; });
+process.stdin.on('end', () => {
+  function emit(value) {
+    const security = Number.parseInt(value.security, 10);
+    const tdd = Number.parseInt(value.tdd, 10);
+    const design = Number.parseInt(value.design, 10);
+    const structural = Number.parseInt(value.structural, 10);
+    if ([security, tdd, design, structural].every(score => Number.isInteger(score) && score >= 0 && score <= 5)) {
+      console.log([security, tdd, design, structural].join(' '));
+      return true;
+    }
+    return false;
+  }
+  try {
+    if (emit(JSON.parse(text.trim()))) return;
+  } catch (_) {}
+  const match = text.match(/\{[^}]+\}/s);
+  if (match) {
+    try {
+      if (emit(JSON.parse(match[0]))) return;
+    } catch (_) {}
+  }
+  process.exit(1);
+});
+" 2>/dev/null) || { echo ""; return 1; }
+  elif command -v python3 >/dev/null 2>&1; then
+    scores=$(printf '%s' "$content" | python3 -c "
 import sys, json, re
 text = sys.stdin.read().strip()
 # Try direct JSON parse first
@@ -209,6 +278,10 @@ if m:
         pass
 sys.exit(1)
 " 2>/dev/null) || { echo ""; return 1; }
+  else
+    echo ""
+    return 1
+  fi
 
   echo "$scores"
 }
@@ -221,10 +294,23 @@ call_openrouter() {
 
   # Escape prompt for JSON
   local escaped_prompt
-  escaped_prompt=$(echo "$prompt" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    escaped_prompt=$(printf '%s' "$prompt" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  process.stdout.write(JSON.stringify(input));
+});
+" 2>/dev/null) || escaped_prompt='""'
+  elif command -v python3 >/dev/null 2>&1; then
+    escaped_prompt=$(printf '%s' "$prompt" | python3 -c "
 import sys, json
 print(json.dumps(sys.stdin.read()))
 " 2>/dev/null) || escaped_prompt='""'
+  else
+    escaped_prompt='""'
+  fi
 
   local body
   body=$(cat <<JSON
@@ -295,7 +381,22 @@ if [ "${BEHAVIORAL_JUDGE_TEST_MODE}" = "1" ]; then
   fi
 
   # Parse mock scores
-  scores=$(echo "$mock_scores" | python3 -c "
+  if command -v node >/dev/null 2>&1; then
+    scores=$(printf '%s' "$mock_scores" | node -e "
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  const scores = JSON.parse(input);
+  const security = Number.parseInt(scores.security ?? 3, 10);
+  const tdd = Number.parseInt(scores.tdd ?? 3, 10);
+  const design = Number.parseInt(scores.design ?? 3, 10);
+  const structural = Number.parseInt(scores.structural ?? 3, 10);
+  console.log([security, tdd, design, structural].join(' '));
+});
+" 2>/dev/null) || scores="3 3 3 3"
+  elif command -v python3 >/dev/null 2>&1; then
+    scores=$(printf '%s' "$mock_scores" | python3 -c "
 import sys, json
 d = json.loads(sys.stdin.read())
 s = int(d.get('security', 3))
@@ -304,6 +405,9 @@ de = int(d.get('design', 3))
 st = int(d.get('structural', 3))
 print(f'{s} {t} {de} {st}')
 " 2>/dev/null) || scores="3 3 3 3"
+  else
+    scores="3 3 3 3"
+  fi
 
   read -r sec tdd_s des str <<< "$scores"
   compute_result "$sec" "$tdd_s" "$des" "$str" "$judge_model" "$judge_calls"