@kody-ade/kody-engine 0.4.154 → 0.4.156

package/dist/bin/kody.js

@@ -1061,7 +1061,7 @@ var init_loadPriorArt = __esm({
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.4.154",
+  version: "0.4.156",
   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

@@ -82,6 +82,18 @@ open_deploy_pr() {
   local body
   body=$(build_pr_body "$new_version" "$changelog_section" "$default_branch" "$release_branch" "$issue_arg")
 
+  # GitHub rejects a PR body over 65536 chars (GraphQL createPullRequest).
+  # A large accumulated CHANGELOG section can blow past it, so clamp: drop the
+  # changelog to a budget and rebuild, then hard-truncate as a final guard.
+  local body_max=65000
+  if (( ${#body} > body_max )); then
+    echo "[deploy] PR body ${#body} chars > ${body_max} — truncating changelog" >&2
+    local budget=$(( body_max - 2000 ))
+    changelog_section="${changelog_section:0:budget}"$'\n\n_…changelog truncated; see CHANGELOG.md on the branch._'
+    body=$(build_pr_body "$new_version" "$changelog_section" "$default_branch" "$release_branch" "$issue_arg")
+    (( ${#body} > body_max )) && body="${body:0:body_max}"
+  fi
+
   # Idempotency: reuse an open PR for this branch pair if one exists.
   local existing pr_url
   existing=$(gh pr list --head "$default_branch" --base "$release_branch" --state open --json url --limit 1 2>/dev/null \

package/dist/executables/release/release.sh

@@ -135,8 +135,22 @@ if [[ "$publish_status" == "failed" ]]; then
 fi
 
 # ── 5. Deploy PR (default → release branch) ───────────────────────────────
+# Distinguish three outcomes: rc!=0 is a real failure (do NOT mask as no-op);
+# rc==0 + empty URL is a genuine single-branch no-op; rc==0 + URL is success.
 current_step="deploy"
-deploy_pr_url=$(open_deploy_pr "$new_version" "$issue" || echo "")
+set +e
+deploy_pr_url=$(open_deploy_pr "$new_version" "$issue")
+deploy_rc=$?
+set -e
+release_branch="${KODY_CFG_RELEASE_RELEASEBRANCH:-}"
+if [[ "$deploy_rc" -ne 0 ]]; then
+  echo "[release] deploy step failed (rc=${deploy_rc}) — published v${new_version} but the ${default_branch}→${release_branch} promotion PR was not opened" >&2
+  echo "KODY_REASON=release v${new_version}: published, but the ${default_branch}→${release_branch} deploy PR failed"
+  echo "RELEASE_TAG=${tag}"
+  [[ -n "$release_url" ]] && echo "RELEASE_URL=${release_url}"
+  echo "RELEASE_FAILED=true"
+  exit 1
+fi
 if [[ -z "$deploy_pr_url" ]]; then
   echo "  (deploy: no-op — single-branch repo)"
 else

package/dist/executables/release-deploy/deploy.sh

@@ -142,6 +142,18 @@ if [[ "$issue_arg" =~ ^[0-9]+$ && "$issue_arg" != "0" ]]; then
 fi
 body=$(build_pr_body "$tracking_line")
 
+# GitHub rejects a PR body over 65536 chars (GraphQL createPullRequest). A
+# large accumulated CHANGELOG section can blow past it, so clamp: drop the
+# changelog to a budget and rebuild, then hard-truncate as a final guard.
+body_max=65000
+if (( ${#body} > body_max )); then
+  echo "[kody release-deploy] PR body ${#body} chars > ${body_max} — truncating changelog" >&2
+  budget=$(( body_max - 2000 ))
+  changelog_section="${changelog_section:0:budget}"$'\n\n_…changelog truncated; see CHANGELOG.md on the branch._'
+  body=$(build_pr_body "$tracking_line")
+  (( ${#body} > body_max )) && body="${body:0:body_max}"
+fi
+
 if [[ -n "$existing" ]]; then
   echo "  reusing existing deploy PR: ${existing}"
   pr_url="$existing"

package/dist/executables/release-publish/publish.sh

@@ -56,44 +56,70 @@ tag="v${version}"
 
 echo "→ release publish: ${tag}"
 
-# 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
-  fail "release publish: tag ${tag} already exists" 1
+# Recovery is resume-not-overwrite: a release is three steps (push tag, run
+# publishCommand, create GH release) and any of them may already be done from
+# a prior partial run. We probe each step's state and perform only the missing
+# parts. An already-fully-released version is therefore a no-op success, and we
+# never re-point or force an existing tag (that would rewrite a shipped version).
+tag_local=false
+tag_remote=false
+release_exists=false
+if git rev-parse --verify "$tag" >/dev/null 2>&1; then tag_local=true; fi
+if git ls-remote --exit-code --tags origin "refs/tags/$tag" >/dev/null 2>&1; then tag_remote=true; fi
+if gh release view "$tag" >/dev/null 2>&1; then release_exists=true; fi
+
+if [[ "$tag_local" == "true" || "$tag_remote" == "true" || "$release_exists" == "true" ]]; then
+  echo "  resuming: tag exists (local=${tag_local} remote=${tag_remote}), gh-release=${release_exists}"
 fi
 
 if [[ "$dry_run" == "true" ]]; then
-  echo "KODY_REASON=dry-run — would tag + publish ${tag}"
+  echo "KODY_REASON=dry-run — would tag + publish ${tag} (tag_remote=${tag_remote}, gh-release=${release_exists})"
   echo "KODY_SKIP_AGENT=true"
   exit 0
 fi
 
-# Tag + push.
-git tag -a "$tag" -m "Release ${tag}"
-git push origin "$tag"
+# Tag + push (skip whichever half already exists).
+if [[ "$tag_local" == "false" && "$tag_remote" == "false" ]]; then
+  git tag -a "$tag" -m "Release ${tag}"
+fi
+if [[ "$tag_remote" == "false" ]]; then
+  git push origin "$tag"
+fi
 
-# publishCommand (optional). Failure here is recorded but does not abort —
-# we still want the GH release entry so the tag is discoverable.
+# publishCommand (optional). A version that's already on the registry is the
+# expected recovery case, not an error: treat "already published" as done.
+# Any other non-zero is a real failure (recorded, but we still create the GH
+# release so the tag is discoverable).
 publish_status="skipped"
 if [[ -n "$publish_cmd" ]]; then
   cmd="${publish_cmd//\$VERSION/$version}"
   echo "  publish: ${cmd}"
-  if timeout "${timeout_s}" bash -c "$cmd"; then
+  publish_out=""
+  if publish_out=$(timeout "${timeout_s}" bash -c "$cmd" 2>&1); then
     publish_status="ok"
+  elif echo "$publish_out" | grep -qiE "already exists|cannot publish over|previously published|403 Forbidden"; then
+    publish_status="already-published"
+    echo "[kody release-publish] version ${version} already on registry — treating as published"
   else
     publish_status="failed"
     echo "[kody release-publish] publishCommand failed (continuing to create GH release)" >&2
   fi
+  echo "$publish_out"
 fi
 
-# GitHub release.
+# GitHub release (create only if missing).
 release_url=""
-draft_flag=""
-[[ "$draft" == "true" ]] && draft_flag="--draft"
-if release_url=$(gh release create "$tag" --title "$tag" --notes "Release ${tag} — automated by kody." $draft_flag 2>&1); then
-  :
+if [[ "$release_exists" == "true" ]]; then
+  release_url=$(gh release view "$tag" --json url --jq .url 2>/dev/null || echo "")
 else
-  echo "[kody release-publish] gh release create failed: $release_url" >&2
-  release_url=""
+  draft_flag=""
+  [[ "$draft" == "true" ]] && draft_flag="--draft"
+  if release_url=$(gh release create "$tag" --title "$tag" --notes "Release ${tag} — automated by kody." $draft_flag 2>&1); then
+    :
+  else
+    echo "[kody release-publish] gh release create failed: $release_url" >&2
+    release_url=""
+  fi
 fi
 
 echo "RELEASE_TAG=${tag}"
@@ -108,3 +134,4 @@ fi
 [[ -n "$release_url" ]] && echo "KODY_PR_URL=${release_url}"
 echo "KODY_REASON=tagged ${tag}, published${publish_status:+ ($publish_status)}"
 echo "KODY_SKIP_AGENT=true"
+exit 0

package/package.json

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