@kody-ade/kody-engine 0.3.70 → 0.3.72

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.70",
+  version: "0.3.72",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",

package/dist/executables/release/deploy.sh

@@ -91,8 +91,26 @@ open_deploy_pr() {
   if [[ -n "$existing" ]]; then
     echo "  reusing existing deploy PR: ${existing}" >&2
     pr_url="$existing"
-    if ! printf '%s' "$body" | gh pr edit "$pr_url" --body-file - >/dev/null 2>&1; then
-      echo "[deploy] WARN: failed to refresh deploy PR body" >&2
+    # Refresh body via REST API instead of `gh pr edit` — gh's edit path
+    # uses GraphQL which requires read:org scope on KODY_TOKEN. REST PATCH
+    # works with plain `repo` scope.
+    local pr_num="${pr_url##*/}"
+    local owner="${KODY_CFG_GITHUB_OWNER:-}"
+    local repo="${KODY_CFG_GITHUB_REPO:-}"
+    if [[ -z "$owner" || -z "$repo" ]]; then
+      # Fall back to extracting from the URL if config missing.
+      local stripped="${pr_url#https://github.com/}"
+      owner="${stripped%%/*}"
+      repo=$(echo "$stripped" | cut -d/ -f2)
+    fi
+    local edit_err
+    local refreshed_title="deploy: ${default_branch} → ${release_branch} (v${new_version})"
+    if ! edit_err=$(gh api --method PATCH "repos/${owner}/${repo}/pulls/${pr_num}" \
+        -f title="$refreshed_title" \
+        -f body="$body" 2>&1 >/dev/null); then
+      echo "[deploy] WARN: failed to refresh deploy PR title+body for ${pr_url}: ${edit_err}" >&2
+    else
+      echo "  refreshed deploy PR title + body via REST" >&2
     fi
   else
     if ! pr_url=$(printf '%s' "$body" | gh pr create --head "$default_branch" --base "$release_branch" --title "deploy: ${default_branch} → ${release_branch} (v${new_version})" --body-file -); then

package/dist/executables/release/prepare.sh

@@ -107,12 +107,18 @@ generate_changelog() {
 
 format_changelog() {
   local new_version="$1"
-  local date_str
+  local date_str raw
   date_str=$(date -u +%Y-%m-%d)
-  python3 - "$new_version" "$date_str" <<'PY'
-import sys, re
-new_version, date_str = sys.argv[1], sys.argv[2]
-raw = sys.stdin.read()
+  # Capture stdin BEFORE invoking python — the python heredoc below
+  # redirects sys.stdin to the heredoc text itself, so we can't rely on
+  # `sys.stdin.read()` to see the piped `subject||sha` lines. Pass the
+  # raw log through an env var instead.
+  raw=$(cat)
+  RAW_CHANGELOG="$raw" NEW_VER="$new_version" DATE_STR="$date_str" python3 - <<'PY'
+import os, re, sys
+new_version = os.environ["NEW_VER"]
+date_str = os.environ["DATE_STR"]
+raw = os.environ.get("RAW_CHANGELOG", "")
 buckets = {k: [] for k in ("feat", "fix", "perf", "refactor", "docs", "chore", "other")}
 for line in raw.splitlines():
     line = line.strip()

package/dist/executables/release/profile.json

@@ -64,7 +64,7 @@
       },
       { "script": "loadIssueContext" },
       { "script": "loadTaskState" },
-      { "shell": "release.sh" },
+      { "shell": "release.sh", "timeoutSec": 5400 },
       { "script": "skipAgent" }
     ],
     "postflight": [

package/dist/executables/release/publish.sh

@@ -15,14 +15,32 @@ tag_and_publish() {
   local timeout_s=$((timeout_ms / 1000))
   local tag="v${new_version}"
 
-  # Refuse if the tag already exists locally (left over from a prior failed run).
-  if git rev-parse --verify "$tag" >/dev/null 2>&1; then
-    echo "[publish] tag ${tag} already exists locally" >&2
-    return 1
+  # Idempotent tagging: if the tag already exists and points at HEAD,
+  # treat it as already-published. If it points elsewhere, fail loudly —
+  # something is inconsistent and a human should look.
+  local remote_sha local_sha head_sha
+  head_sha=$(git rev-parse HEAD)
+  if local_sha=$(git rev-parse --verify "$tag" 2>/dev/null); then
+    if [[ "$local_sha" == "$head_sha" ]]; then
+      echo "  tag ${tag} already exists locally at HEAD — skipping create" >&2
+    else
+      echo "[publish] tag ${tag} exists locally at ${local_sha} but HEAD is ${head_sha}" >&2
+      return 1
+    fi
+  else
+    git tag -a "$tag" -m "Release ${tag}"
+  fi
+  # Push the tag if it isn't already on origin (or push always; gh will
+  # no-op on existing remote tag at the same sha).
+  if remote_sha=$(git ls-remote --tags origin "refs/tags/${tag}" 2>/dev/null | awk '{print $1}'); then
+    if [[ -z "$remote_sha" ]]; then
+      git push origin "$tag"
+    elif [[ "$remote_sha" != "$head_sha" ]]; then
+      echo "  WARN: remote tag ${tag} points at ${remote_sha}, HEAD is ${head_sha}" >&2
+    fi
+  else
+    git push origin "$tag" || true
   fi
-
-  git tag -a "$tag" -m "Release ${tag}"
-  git push origin "$tag"
 
   # publishCommand (optional). Failure here is recorded but does not abort —
   # we still want the GH release entry so the tag is discoverable.
@@ -48,6 +66,16 @@ create_gh_release() {
   local draft_flag=""
   [[ "$draft" == "true" ]] && draft_flag="--draft"
 
+  # Idempotent: if a release for this tag already exists, reuse it.
+  local existing_url
+  if existing_url=$(gh release view "$tag" --json url -q .url 2>/dev/null); then
+    if [[ -n "$existing_url" ]]; then
+      echo "  GH release for ${tag} already exists: ${existing_url}" >&2
+      echo "$existing_url"
+      return 0
+    fi
+  fi
+
   local release_url=""
   if release_url=$(gh release create "$tag" --title "$tag" --notes "Release ${tag} — automated by kody." $draft_flag 2>&1); then
     echo "$release_url"

package/dist/executables/release/wait.sh

@@ -3,10 +3,12 @@
 # release/wait.sh — wait_for_ci function: poll a PR's check rollup
 # until all non-skipped checks pass, or timeout.
 #
-# Function: wait_for_ci <pr_number> <timeout_minutes>
-# Exits 0 on CI_PASSED, exits 1 on CI_FAILED/CI_TIMEOUT.
+# Function: wait_for_ci <pr_number> <timeout_minutes> [poll_seconds] [initial_wait]
+# Returns 0 on CI passed, 1 on CI failed/timeout.
 #
-# Reads gh pr checks <N> output. Treats SKIPPED as pass.
+# Special-case: if a PR has zero registered checks (no CI configured),
+# treats that as PASSED after a short stabilization window — so a Tester
+# repo without checks doesn't loop forever.
 
 # shellcheck disable=SC2148
 
@@ -24,43 +26,50 @@ wait_for_ci() {
   local deadline=$(( $(date +%s) + timeout_minutes * 60 ))
   echo "→ wait_for_ci: PR #${pr_number}, timeout=${timeout_minutes}m"
 
-  # Initial wait — gives GHA time to register checks.
   sleep "$initial_wait"
 
+  # Track consecutive "no checks" results so we don't bail prematurely
+  # on a PR that's just slow to register checks.
+  local empty_count=0
+  local empty_threshold=4   # ~2 minutes (4 * poll_seconds=30s) before treating as no-CI
+
   while (( $(date +%s) < deadline )); do
-    # gh pr checks <N> --json prints an array of {state, name, ...}.
     local raw
-    if ! raw=$(gh pr checks "$pr_number" --json state,name 2>/dev/null); then
-      echo "  [wait_for_ci] gh pr checks failed; retrying in ${poll_seconds}s" >&2
+    if ! raw=$(gh pr checks "$pr_number" --json state 2>/dev/null); then
+      # gh exits non-zero when there are no checks — treat as no-CI.
+      empty_count=$((empty_count + 1))
+      echo "  [wait_for_ci] gh pr checks returned non-zero (count=${empty_count})"
+      if (( empty_count >= empty_threshold )); then
+        echo "→ wait_for_ci: PR #${pr_number} has no CI checks configured — treating as passed"
+        return 0
+      fi
       sleep "$poll_seconds"
       continue
     fi
 
-    # Tally states. Anything that's still PENDING/IN_PROGRESS/QUEUED → keep waiting.
-    # Anything FAILURE/CANCELLED/TIMED_OUT/ACTION_REQUIRED → fail fast.
-    # SUCCESS/SKIPPED/NEUTRAL → pass.
-    local summary
-    summary=$(printf '%s' "$raw" | python3 -c '
-import json, sys
-data = json.load(sys.stdin)
-buckets = {"pending": 0, "passed": 0, "failed": 0, "failed_names": []}
-for r in data:
-    s = (r.get("state") or "").upper()
-    name = r.get("name") or "?"
-    if s in ("PENDING", "IN_PROGRESS", "QUEUED", ""):
-        buckets["pending"] += 1
-    elif s in ("FAILURE", "CANCELLED", "TIMED_OUT", "ACTION_REQUIRED", "STARTUP_FAILURE"):
-        buckets["failed"] += 1
-        buckets["failed_names"].append(name)
-    else:  # SUCCESS, SKIPPED, NEUTRAL, etc.
-        buckets["passed"] += 1
-print(f"{buckets[\"pending\"]}|{buckets[\"passed\"]}|{buckets[\"failed\"]}|{','.join(buckets[\"failed_names\"][:5])}")
-')
+    # Empty array? Same path.
+    local total
+    total=$(printf '%s' "$raw" | jq 'length' 2>/dev/null || echo "0")
+    if [[ "$total" == "0" ]]; then
+      empty_count=$((empty_count + 1))
+      echo "  [wait_for_ci] no checks registered yet (count=${empty_count})"
+      if (( empty_count >= empty_threshold )); then
+        echo "→ wait_for_ci: PR #${pr_number} has no CI checks configured — treating as passed"
+        return 0
+      fi
+      sleep "$poll_seconds"
+      continue
+    fi
+    empty_count=0
 
-    local pending passed failed failed_names
-    IFS='|' read -r pending passed failed failed_names <<< "$summary"
+    # Tally states via jq.
+    local pending failed passed failed_names
+    pending=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("PENDING","IN_PROGRESS","QUEUED",""))] | length')
+    failed=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("FAILURE","CANCELLED","TIMED_OUT","ACTION_REQUIRED","STARTUP_FAILURE"))] | length')
+    passed=$(printf '%s' "$raw" | jq '[.[] | select((.state // "") | IN("SUCCESS","SKIPPED","NEUTRAL"))] | length')
+    failed_names=$(printf '%s' "$raw" | jq -r '[.[] | select((.state // "") | IN("FAILURE","CANCELLED","TIMED_OUT","ACTION_REQUIRED","STARTUP_FAILURE")) | .name] | join(",")')
 
-    echo "  [wait_for_ci] pending=${pending} passed=${passed} failed=${failed}"
+    echo "  [wait_for_ci] pending=${pending} passed=${passed} failed=${failed} (total=${total})"
 
     if [[ "$failed" -gt 0 ]]; then
       echo "[wait_for_ci] CI failed on PR #${pr_number}: ${failed_names}" >&2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kody-ade/kody-engine",
-  "version": "0.3.70",
+  "version": "0.3.72",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",