@kody-ade/kody-engine 0.3.70-beta.6 → 0.3.70

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.70-beta.6",
+  version: "0.3.70",
   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,23 +91,8 @@ open_deploy_pr() {
   if [[ -n "$existing" ]]; then
     echo "  reusing existing deploy PR: ${existing}" >&2
     pr_url="$existing"
-    # 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
-    if ! edit_err=$(gh api --method PATCH "repos/${owner}/${repo}/pulls/${pr_num}" -f body="$body" 2>&1 >/dev/null); then
-      echo "[deploy] WARN: failed to refresh deploy PR body for ${pr_url}: ${edit_err}" >&2
-    else
-      echo "  refreshed deploy PR body via REST" >&2
+    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
     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,18 +107,12 @@ generate_changelog() {
 
 format_changelog() {
   local new_version="$1"
-  local date_str raw
+  local date_str
   date_str=$(date -u +%Y-%m-%d)
-  # 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", "")
+  python3 - "$new_version" "$date_str" <<'PY'
+import sys, re
+new_version, date_str = sys.argv[1], sys.argv[2]
+raw = sys.stdin.read()
 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", "timeoutSec": 5400 },
+      { "shell": "release.sh" },
       { "script": "skipAgent" }
     ],
     "postflight": [

package/dist/executables/release/publish.sh

@@ -15,33 +15,15 @@ tag_and_publish() {
   local timeout_s=$((timeout_ms / 1000))
   local tag="v${new_version}"
 
-  # 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
+  # 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
   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.
   local publish_status="skipped"
@@ -66,16 +48,6 @@ 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,12 +3,10 @@
 # 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> [poll_seconds] [initial_wait]
-# Returns 0 on CI passed, 1 on CI failed/timeout.
+# Function: wait_for_ci <pr_number> <timeout_minutes>
+# Exits 0 on CI_PASSED, exits 1 on CI_FAILED/CI_TIMEOUT.
 #
-# 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.
+# Reads gh pr checks <N> output. Treats SKIPPED as pass.
 
 # shellcheck disable=SC2148
 
@@ -26,50 +24,43 @@ 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 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
+    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
       sleep "$poll_seconds"
       continue
     fi
 
-    # 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
+    # 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])}")
+')
 
-    # 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(",")')
+    local pending passed failed failed_names
+    IFS='|' read -r pending passed failed failed_names <<< "$summary"
 
-    echo "  [wait_for_ci] pending=${pending} passed=${passed} failed=${failed} (total=${total})"
+    echo "  [wait_for_ci] pending=${pending} passed=${passed} failed=${failed}"
 
     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-beta.6",
+  "version": "0.3.70",
   "description": "kody — autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   "license": "MIT",
   "type": "module",