@kody-ade/kody-engine 0.3.82 → 0.3.84

package/dist/bin/kody.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@kody-ade/kody-engine",
-  version: "0.3.82",
+  version: "0.3.84",
   description: "kody \u2014 autonomous development engine. Single-session Claude Code agent behind a generic executor + declarative executable profiles.",
   license: "MIT",
   type: "module",
@@ -820,14 +820,58 @@ function commitTurn(cwd, sessionId, verbose) {
   const paths = [sessionRel, eventsRel].filter((p) => fs5.existsSync(path5.join(cwd, p)));
   if (paths.length === 0) return;
   const stdio = verbose ? "inherit" : "pipe";
+  const exec = (args) => execFileSync2("git", args, { cwd, stdio });
   try {
-    execFileSync2("git", ["add", "-f", ...paths], { cwd, stdio });
-    execFileSync2("git", ["commit", "--quiet", "-m", `chat: interactive turn for ${sessionId}`], { cwd, stdio });
-    execFileSync2("git", ["push", "--quiet", "origin", "HEAD"], { cwd, stdio });
+    exec(["add", "-f", ...paths]);
+    exec(["commit", "--quiet", "-m", `chat: interactive turn for ${sessionId}`]);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[kody:chat:interactive] commit/push skipped: ${msg}
+    process.stderr.write(`[kody:chat:interactive] commit failed: ${msg}
 `);
+    return;
+  }
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    try {
+      exec(["push", "--quiet", "origin", "HEAD"]);
+      return;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isNonFf = /non-fast-forward|fetch first|rejected/i.test(msg);
+      if (!isNonFf || attempt === 3) {
+        process.stderr.write(`[kody:chat:interactive] push failed (attempt ${attempt}): ${msg}
+`);
+        return;
+      }
+      process.stderr.write(`[kody:chat:interactive] push rejected (attempt ${attempt}); fetch+rebase+retry
+`);
+      try {
+        exec(["fetch", "--quiet", "origin"]);
+        const branch = currentBranch2(cwd);
+        if (branch) {
+          exec(["rebase", "--quiet", `origin/${branch}`]);
+        } else {
+          process.stderr.write(`[kody:chat:interactive] cannot rebase: no current branch
+`);
+          return;
+        }
+      } catch (rebaseErr) {
+        const rmsg = rebaseErr instanceof Error ? rebaseErr.message : String(rebaseErr);
+        process.stderr.write(`[kody:chat:interactive] rebase failed: ${rmsg}
+`);
+        return;
+      }
+    }
+  }
+}
+function currentBranch2(cwd) {
+  try {
+    const out = execFileSync2("git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return out.toString("utf-8").trim() || null;
+  } catch {
+    return null;
   }
 }
 async function emitExit(opts, reason, turnsCompleted) {

package/dist/executables/goal-scheduler/profile.json

@@ -0,0 +1,43 @@
+{
+  "name": "goal-scheduler",
+  "role": "watch",
+  "describe": "Scheduled: for every active goal under .kody/goals/<id>/state.json, invoke goal-tick once. No agent on the scheduler itself.",
+  "kind": "scheduled",
+  "schedule": "*/5 * * * *",
+  "inputs": [],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": 0,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "",
+      "allowedUses": ["api", "issue", "pr"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      { "shell": "scheduler.sh" },
+      { "script": "skipAgent" }
+    ],
+    "postflight": []
+  }
+}

package/dist/executables/goal-scheduler/scheduler.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+#
+# goal-scheduler: enumerate every goal state file under .kody/goals/ and
+# dispatch goal-tick once for each whose state == "active". Runs as a
+# scheduled executable (cron `*/5 * * * *`). No agent.
+#
+# A failed individual tick logs and continues — one stuck goal must not
+# starve the rest.
+
+set -euo pipefail
+
+goals_dir=".kody/goals"
+
+if [ ! -d "$goals_dir" ]; then
+  echo "[goal-scheduler] no $goals_dir — nothing to schedule"
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+shopt -s nullglob
+state_files=("$goals_dir"/*/state.json)
+shopt -u nullglob
+
+if [ "${#state_files[@]}" = "0" ]; then
+  echo "[goal-scheduler] no goal state files yet"
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+active=0
+for state_file in "${state_files[@]}"; do
+  [ -f "$state_file" ] || continue
+  goal_id=$(basename "$(dirname "$state_file")")
+
+  state=$(python3 -c "import json,sys; print(json.load(open(sys.argv[1])).get('state',''))" "$state_file" 2>/dev/null || echo "")
+
+  if [ "$state" != "active" ]; then
+    continue
+  fi
+
+  active=$((active + 1))
+  echo "[goal-scheduler] → tick $goal_id"
+
+  # Run the tick in a subshell so a non-zero exit doesn't kill the loop.
+  if ! kody dispatch goal-tick --goal "$goal_id"; then
+    echo "[goal-scheduler] tick $goal_id failed (continuing)"
+  fi
+done
+
+echo "[goal-scheduler] ticked $active active goal(s) of ${#state_files[@]} total"
+echo "KODY_SKIP_AGENT=true"
+exit 0

package/dist/executables/goal-tick/profile.json

@@ -0,0 +1,50 @@
+{
+  "name": "goal-tick",
+  "role": "primitive",
+  "describe": "One deterministic tick for one goal: read .kody/goals/<id>/state.json, dispatch @kody on the next ready task (or mark goal done when all tasks closed). No agent.",
+  "kind": "oneshot",
+  "inputs": [
+    {
+      "name": "goal",
+      "flag": "--goal",
+      "type": "string",
+      "required": true,
+      "describe": "Goal id — directory name under .kody/goals/."
+    }
+  ],
+  "claudeCode": {
+    "model": "inherit",
+    "permissionMode": "default",
+    "maxTurns": 0,
+    "maxThinkingTokens": null,
+    "systemPromptAppend": null,
+    "tools": [],
+    "hooks": [],
+    "skills": [],
+    "commands": [],
+    "subagents": [],
+    "plugins": [],
+    "mcpServers": []
+  },
+  "cliTools": [
+    {
+      "name": "gh",
+      "install": {
+        "required": true,
+        "checkCommand": "command -v gh"
+      },
+      "verify": "gh auth status",
+      "usage": "Use `gh issue list/comment/edit` to read goal-labelled tasks and dispatch @kody.",
+      "allowedUses": ["issue", "pr", "api"]
+    }
+  ],
+  "inputArtifacts": [],
+  "outputArtifacts": [],
+  "scripts": {
+    "preflight": [
+      { "shell": "tick.sh" },
+      { "script": "skipAgent" }
+    ],
+    "postflight": []
+  }
+}

package/dist/executables/goal-tick/tick.sh

@@ -0,0 +1,169 @@
+#!/usr/bin/env bash
+#
+# goal-tick: one deterministic tick for one goal. No agent. Pure scripts +
+# `gh` against the connected repo.
+#
+# Inputs (env, set by the executor):
+#   KODY_ARG_GOAL   the goal id (directory name under .kody/goals/)
+#
+# What it does, per tick:
+#   1. Read .kody/goals/<id>/state.json. If missing or state != "active", exit.
+#   2. List issues with label `goal:<id>`.
+#   3. If every such issue is closed → set state=done, completedAt=now,
+#      commit + push state.json, exit.
+#   4. Otherwise pick the lowest-numbered open issue without label
+#      `goal-runner:dispatched`. Dispatch `@kody` on it (one new task per tick),
+#      add the label so we don't re-dispatch on the next tick.
+#   5. Bump updatedAt and commit state.json (cheap, but lets the engine
+#      track per-tick activity in the repo history).
+#
+# Stdout signals:
+#   KODY_SKIP_AGENT=true   — always; this is a no-agent flow.
+#   KODY_REASON=<text>     — failure context (rare; gh errors etc).
+
+set -euo pipefail
+
+goal_id="${KODY_ARG_GOAL:-}"
+if [ -z "$goal_id" ]; then
+  echo "KODY_REASON=missing --goal"
+  echo "KODY_SKIP_AGENT=true"
+  exit 1
+fi
+
+# Defensive: refuse path traversal in goal id.
+if [[ "$goal_id" == *"/"* || "$goal_id" == *".."* ]]; then
+  echo "KODY_REASON=invalid goal id (no slashes or '..' allowed)"
+  echo "KODY_SKIP_AGENT=true"
+  exit 1
+fi
+
+state_dir=".kody/goals/${goal_id}"
+state_file="${state_dir}/state.json"
+
+if [ ! -f "$state_file" ]; then
+  echo "[goal-tick] no state file at $state_file — nothing to tick"
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+# Read current state. python3 is already required by other shell executables
+# (e.g. release-prepare.sh), so we lean on it for JSON read/write.
+state=$(python3 -c "import json,sys; print(json.load(open(sys.argv[1])).get('state',''))" "$state_file")
+
+if [ "$state" != "active" ]; then
+  echo "[goal-tick] $goal_id is '$state' — skipping"
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+label="goal:${goal_id}"
+dispatched_label="goal-runner:dispatched"
+
+# Fetch up to 100 goal-labelled issues. 100 is a soft ceiling — if a goal
+# grows past that, we'll need pagination.
+#
+# Use `gh api` (not `gh issue list --label`) because the latter chokes on
+# colons in label names, which is exactly the convention used here
+# (`goal:<id>` etc). `gh api` also lets us filter PRs out cleanly via the
+# `pull_request` field GitHub attaches to issue payloads.
+issues_json=$(gh api \
+  "repos/{owner}/{repo}/issues?labels=${label}&state=all&per_page=100" \
+  --jq '[.[] | select(.pull_request == null) | {number, state: (.state | ascii_upcase), labels: .labels}]')
+
+total=$(echo "$issues_json" | python3 -c "import json,sys; print(len(json.load(sys.stdin)))")
+if [ "$total" = "0" ]; then
+  echo "[goal-tick] no issues with label '$label' — leaving state untouched"
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+open_count=$(echo "$issues_json" | python3 -c "import json,sys; print(sum(1 for i in json.load(sys.stdin) if i['state']=='OPEN'))")
+
+# All done? mark goal done and commit.
+if [ "$open_count" = "0" ]; then
+  echo "[goal-tick] all $total task(s) closed — marking goal done"
+  python3 - "$state_file" <<'PY'
+import json, sys
+from datetime import datetime, timezone
+path = sys.argv[1]
+with open(path) as f:
+    s = json.load(f)
+now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+s["state"] = "done"
+s["completedAt"] = now
+s["updatedAt"] = now
+with open(path, "w") as f:
+    json.dump(s, f, indent=2)
+    f.write("\n")
+PY
+  git add "$state_file"
+  if ! git diff --cached --quiet; then
+    git commit -m "chore(goals): mark $goal_id done" --quiet
+    git push --quiet || echo "[goal-tick] push failed (will retry next tick)"
+  fi
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+# Pick the lowest-numbered open issue without the dispatched marker.
+next_issue=$(echo "$issues_json" | python3 -c "
+import json, sys
+data = json.load(sys.stdin)
+opens = [
+    i for i in data
+    if i['state'] == 'OPEN'
+    and 'goal-runner:dispatched' not in [l['name'] for l in i.get('labels', [])]
+]
+opens.sort(key=lambda x: x['number'])
+print(opens[0]['number'] if opens else '')
+")
+
+if [ -z "$next_issue" ]; then
+  echo "[goal-tick] all open tasks already dispatched — waiting for them to complete"
+  # Bump updatedAt so the dashboard can show "last ticked at" without parsing logs.
+  python3 - "$state_file" <<'PY'
+import json, sys
+from datetime import datetime, timezone
+path = sys.argv[1]
+with open(path) as f:
+    s = json.load(f)
+s["updatedAt"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+with open(path, "w") as f:
+    json.dump(s, f, indent=2)
+    f.write("\n")
+PY
+  git add "$state_file"
+  if ! git diff --cached --quiet; then
+    git commit -m "chore(goals): tick $goal_id (idle)" --quiet
+    git push --quiet || echo "[goal-tick] push failed (will retry next tick)"
+  fi
+  echo "KODY_SKIP_AGENT=true"
+  exit 0
+fi
+
+echo "[goal-tick] dispatching @kody on task #$next_issue"
+gh issue comment "$next_issue" --body "@kody"
+gh issue edit "$next_issue" --add-label "$dispatched_label" || true
+
+# Bump updatedAt so the file changes (cheap audit trail in git log).
+python3 - "$state_file" "$next_issue" <<'PY'
+import json, sys
+from datetime import datetime, timezone
+path = sys.argv[1]
+issue = int(sys.argv[2])
+with open(path) as f:
+    s = json.load(f)
+s["updatedAt"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+s["lastDispatchedIssue"] = issue
+with open(path, "w") as f:
+    json.dump(s, f, indent=2)
+    f.write("\n")
+PY
+git add "$state_file"
+if ! git diff --cached --quiet; then
+  git commit -m "chore(goals): dispatched #${next_issue} for ${goal_id}" --quiet
+  git push --quiet || echo "[goal-tick] push failed (will retry next tick)"
+fi
+
+echo "KODY_SKIP_AGENT=true"
+exit 0

package/package.json

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