@jonit-dev/night-watch-cli 1.5.0 → 1.5.2

package/scripts/night-watch-helpers.sh

@@ -19,6 +19,44 @@ validate_provider() {
   esac
 }
 
+# Resolve a usable night-watch CLI binary for nested script calls.
+# Resolution order:
+# 1) NW_CLI_BIN from parent environment (absolute path set by installer/runtime)
+# 2) `night-watch` found in PATH
+# 3) bundled bin path next to scripts/ in this package checkout/install
+resolve_night_watch_cli() {
+  if [ -n "${NW_CLI_BIN:-}" ] && [ -x "${NW_CLI_BIN}" ]; then
+    printf "%s" "${NW_CLI_BIN}"
+    return 0
+  fi
+
+  if command -v night-watch >/dev/null 2>&1; then
+    printf "%s" "night-watch"
+    return 0
+  fi
+
+  local script_dir
+  if [ -n "${SCRIPT_DIR:-}" ]; then
+    script_dir="${SCRIPT_DIR}"
+  else
+    script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  fi
+
+  local bundled_bin="${script_dir}/../bin/night-watch.mjs"
+  if [ -x "${bundled_bin}" ]; then
+    printf "%s" "${bundled_bin}"
+    return 0
+  fi
+
+  return 1
+}
+
+night_watch_history() {
+  local cli_bin
+  cli_bin=$(resolve_night_watch_cli) || return 127
+  "${cli_bin}" history "$@"
+}
+
 # ── Logging ──────────────────────────────────────────────────────────────────
 
 log() {
@@ -167,6 +205,7 @@ is_claimed() {
 find_eligible_prd() {
   local prd_dir="${1:?prd_dir required}"
   local max_runtime="${2:-7200}"
+  local project_dir="${3:-}"
   local done_dir="${prd_dir}/done"
 
   local prd_files
@@ -210,6 +249,12 @@ find_eligible_prd() {
       continue
     fi
 
+    # Skip if in cooldown after a recent failure (checked via execution history ledger)
+    if [ -n "${project_dir}" ] && night_watch_history check "${project_dir}" "${prd_file}" --cooldown "${max_runtime}" 2>/dev/null; then
+      log "SKIP-PRD: ${prd_file} — in cooldown after recent failure"
+      continue
+    fi
+
     # Skip if a PR already exists for this PRD
     if echo "${open_branches}" | grep -qF "${prd_name}"; then
       log "SKIP-PRD: ${prd_file} — open PR already exists"
@@ -247,17 +292,151 @@ cleanup_worktrees() {
   local project_dir="${1:?project_dir required}"
   local project_name
   project_name=$(basename "${project_dir}")
+  local marker="${2:-${project_name}-nw}"
 
   git -C "${project_dir}" worktree list --porcelain 2>/dev/null \
     | grep '^worktree ' \
     | awk '{print $2}' \
-    | grep "${project_name}-nw" \
+    | grep "${marker}" \
     | while read -r wt; do
         log "CLEANUP: Removing leftover worktree ${wt}"
         git -C "${project_dir}" worktree remove --force "${wt}" 2>/dev/null || true
       done || true
 }
 
+# ── Runtime workspace isolation ───────────────────────────────────────────────
+
+project_runtime_key() {
+  local project_dir="${1:?project_dir required}"
+  local project_name
+  local hash
+  project_name=$(basename "${project_dir}")
+
+  if command -v sha1sum >/dev/null 2>&1; then
+    hash=$(printf "%s" "${project_dir}" | sha1sum | awk '{print $1}')
+  elif command -v shasum >/dev/null 2>&1; then
+    hash=$(printf "%s" "${project_dir}" | shasum | awk '{print $1}')
+  else
+    hash=$(printf "%s" "${project_dir}" | cksum | awk '{print $1}')
+  fi
+
+  printf "%s-%s" "${project_name}" "${hash:0:12}"
+}
+
+resolve_runtime_base_ref() {
+  local git_dir="${1:?git_dir required}"
+  local default_branch="${2:?default_branch required}"
+
+  if git -C "${git_dir}" rev-parse --verify --quiet "refs/remotes/origin/${default_branch}" >/dev/null; then
+    printf "%s" "refs/remotes/origin/${default_branch}"
+    return 0
+  fi
+
+  if git -C "${git_dir}" rev-parse --verify --quiet "refs/heads/${default_branch}" >/dev/null; then
+    printf "%s" "refs/heads/${default_branch}"
+    return 0
+  fi
+
+  if git -C "${git_dir}" rev-parse --verify --quiet "refs/remotes/origin/HEAD" >/dev/null; then
+    printf "%s" "refs/remotes/origin/HEAD"
+    return 0
+  fi
+
+  return 1
+}
+
+prepare_runtime_workspace() {
+  local project_dir="${1:?project_dir required}"
+  local default_branch="${2:?default_branch required}"
+  local log_file="${3:-${LOG_FILE:-/dev/null}}"
+  local runtime_root="${NW_RUNTIME_ROOT:-${HOME}/.night-watch/runtime}"
+  local runtime_key
+  local runtime_base
+  local mirror_dir
+  local runs_dir
+  local worktree_dir
+  local clone_source=""
+  local base_ref=""
+
+  runtime_key=$(project_runtime_key "${project_dir}")
+  runtime_base="${runtime_root}/${runtime_key}"
+  mirror_dir="${runtime_base}/mirror.git"
+  runs_dir="${runtime_base}/runs"
+  worktree_dir="${runs_dir}/run-$(date +%Y%m%d-%H%M%S)-$$"
+
+  mkdir -p "${runs_dir}"
+
+  if [ ! -d "${mirror_dir}" ]; then
+    clone_source=$(git -C "${project_dir}" config --get remote.origin.url 2>/dev/null || echo "")
+
+    if [ -n "${clone_source}" ]; then
+      if ! git clone --mirror "${clone_source}" "${mirror_dir}" >> "${log_file}" 2>&1; then
+        git clone --mirror "${project_dir}" "${mirror_dir}" >> "${log_file}" 2>&1
+      fi
+    else
+      git clone --mirror "${project_dir}" "${mirror_dir}" >> "${log_file}" 2>&1
+    fi
+  fi
+
+  git -C "${mirror_dir}" remote update --prune >> "${log_file}" 2>&1 || true
+
+  base_ref=$(resolve_runtime_base_ref "${mirror_dir}" "${default_branch}") || return 1
+  git -C "${mirror_dir}" worktree add --detach "${worktree_dir}" "${base_ref}" >> "${log_file}" 2>&1
+
+  printf "%s\n%s\n" "${mirror_dir}" "${worktree_dir}"
+}
+
+cleanup_runtime_workspace() {
+  local mirror_dir="${1:?mirror_dir required}"
+  local worktree_dir="${2:?worktree_dir required}"
+
+  git -C "${mirror_dir}" worktree remove --force "${worktree_dir}" 2>/dev/null || true
+  git -C "${mirror_dir}" worktree prune 2>/dev/null || true
+}
+
+prepare_branch_checkout() {
+  local repo_dir="${1:?repo_dir required}"
+  local branch_name="${2:?branch_name required}"
+  local default_branch="${3:?default_branch required}"
+  local log_file="${4:-${LOG_FILE:-/dev/null}}"
+  local base_ref=""
+
+  git -C "${repo_dir}" fetch origin "${default_branch}" "${branch_name}" >> "${log_file}" 2>&1 || true
+
+  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/heads/${branch_name}" >/dev/null; then
+    git -C "${repo_dir}" checkout "${branch_name}" >> "${log_file}" 2>&1
+    return $?
+  fi
+
+  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/remotes/origin/${branch_name}" >/dev/null; then
+    git -C "${repo_dir}" checkout -b "${branch_name}" "origin/${branch_name}" >> "${log_file}" 2>&1
+    return $?
+  fi
+
+  base_ref=$(resolve_runtime_base_ref "${repo_dir}" "${default_branch}") || return 1
+  git -C "${repo_dir}" checkout -b "${branch_name}" "${base_ref}" >> "${log_file}" 2>&1
+}
+
+checkout_default_branch() {
+  local repo_dir="${1:?repo_dir required}"
+  local default_branch="${2:?default_branch required}"
+  local log_file="${3:-${LOG_FILE:-/dev/null}}"
+
+  git -C "${repo_dir}" fetch origin "${default_branch}" >> "${log_file}" 2>&1 || true
+
+  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/remotes/origin/${default_branch}" >/dev/null; then
+    git -C "${repo_dir}" checkout -B "${default_branch}" "origin/${default_branch}" >> "${log_file}" 2>&1
+    return $?
+  fi
+
+  if git -C "${repo_dir}" rev-parse --verify --quiet "refs/heads/${default_branch}" >/dev/null; then
+    git -C "${repo_dir}" checkout "${default_branch}" >> "${log_file}" 2>&1
+    return $?
+  fi
+
+  git -C "${repo_dir}" checkout -B "${default_branch}" HEAD >> "${log_file}" 2>&1
+}
+
 # ── Mark PRD as done ─────────────────────────────────────────────────────────
 
 mark_prd_done() {
@@ -276,3 +455,12 @@ mark_prd_done() {
     return 1
   fi
 }
+
+# ── Rate limit detection ────────────────────────────────────────────────────
+
+# Check if the last N lines of the log contain a 429 rate limit error.
+# Returns 0 if rate limited, 1 otherwise.
+check_rate_limited() {
+  local log_file="${1:?log_file required}"
+  tail -20 "${log_file}" 2>/dev/null | grep -q "429"
+}

package/scripts/night-watch-pr-reviewer-cron.sh

@@ -15,12 +15,14 @@ PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
 PROJECT_NAME=$(basename "${PROJECT_DIR}")
 LOG_DIR="${PROJECT_DIR}/logs"
 LOG_FILE="${LOG_DIR}/night-watch-pr-reviewer.log"
-LOCK_FILE="/tmp/night-watch-pr-reviewer-${PROJECT_NAME}.lock"
+LOCK_FILE=""
 MAX_RUNTIME="${NW_REVIEWER_MAX_RUNTIME:-3600}"  # 1 hour
 MAX_LOG_SIZE="524288"  # 512 KB
 PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
 MIN_REVIEW_SCORE="${NW_MIN_REVIEW_SCORE:-80}"
 BRANCH_PATTERNS_RAW="${NW_BRANCH_PATTERNS:-feat/,night-watch/}"
+RUNTIME_MIRROR_DIR=""
+RUNTIME_PROJECT_DIR=""
 
 # Ensure NVM / Node / Claude are on PATH
 export NVM_DIR="${HOME}/.nvm"
@@ -34,6 +36,8 @@ mkdir -p "${LOG_DIR}"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 # shellcheck source=night-watch-helpers.sh
 source "${SCRIPT_DIR}/night-watch-helpers.sh"
+PROJECT_RUNTIME_KEY=$(project_runtime_key "${PROJECT_DIR}")
+LOCK_FILE="/tmp/night-watch-pr-reviewer-${PROJECT_RUNTIME_KEY}.lock"
 
 # Validate provider
 if ! validate_provider "${PROVIDER_CMD}"; then
@@ -47,7 +51,37 @@ if ! acquire_lock "${LOCK_FILE}"; then
   exit 0
 fi
 
-cd "${PROJECT_DIR}"
+cleanup_on_exit() {
+  rm -f "${LOCK_FILE}"
+
+  if [ -n "${RUNTIME_MIRROR_DIR}" ] && [ -n "${RUNTIME_PROJECT_DIR}" ]; then
+    cleanup_runtime_workspace "${RUNTIME_MIRROR_DIR}" "${RUNTIME_PROJECT_DIR}" || true
+  fi
+}
+
+trap cleanup_on_exit EXIT
+
+if [ -n "${NW_DEFAULT_BRANCH:-}" ]; then
+  DEFAULT_BRANCH="${NW_DEFAULT_BRANCH}"
+else
+  DEFAULT_BRANCH=$(detect_default_branch "${PROJECT_DIR}")
+fi
+
+runtime_info=()
+if mapfile -t runtime_info < <(prepare_runtime_workspace "${PROJECT_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"); then
+  RUNTIME_MIRROR_DIR="${runtime_info[0]:-}"
+  RUNTIME_PROJECT_DIR="${runtime_info[1]:-}"
+else
+  log "FAIL: Could not prepare runtime workspace for reviewer"
+  exit 1
+fi
+
+if [ -z "${RUNTIME_MIRROR_DIR}" ] || [ -z "${RUNTIME_PROJECT_DIR}" ]; then
+  log "FAIL: Runtime workspace paths are missing for reviewer"
+  exit 1
+fi
+
+cd "${RUNTIME_PROJECT_DIR}"
 
 # Convert comma-separated branch prefixes into a regex that matches branch starts.
 BRANCH_REGEX=""
@@ -122,38 +156,55 @@ fi
 
 log "START: Found PR(s) needing work:${PRS_NEEDING_WORK}"
 
-cleanup_worktrees "${PROJECT_DIR}"
-
 # Dry-run mode: print diagnostics and exit
 if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   echo "=== Dry Run: PR Reviewer ==="
   echo "Provider: ${PROVIDER_CMD}"
   echo "Branch Patterns: ${BRANCH_PATTERNS_RAW}"
   echo "Min Review Score: ${MIN_REVIEW_SCORE}"
+  echo "Default Branch: ${DEFAULT_BRANCH}"
+  echo "Runtime Dir: ${RUNTIME_PROJECT_DIR}"
   echo "Open PRs needing work:${PRS_NEEDING_WORK}"
   echo "Timeout: ${MAX_RUNTIME}s"
   exit 0
 fi
 
+if [ -f "${RUNTIME_PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md" ]; then
+  REVIEW_WORKFLOW=$(cat "${RUNTIME_PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md")
+else
+  REVIEW_WORKFLOW=$(cat "${SCRIPT_DIR}/../templates/night-watch-pr-reviewer.md")
+fi
+
+REVIEW_PROMPT="You are running in an isolated runtime workspace at ${RUNTIME_PROJECT_DIR}.
+Do not run git checkout/switch in ${PROJECT_DIR}.
+Do not create or remove worktrees; the runtime controller handles that.
+Apply all fixes only inside the current runtime workspace.
+
+${REVIEW_WORKFLOW}"
+
 EXIT_CODE=0
 
 case "${PROVIDER_CMD}" in
   claude)
-    if timeout "${MAX_RUNTIME}" \
-      claude -p "/night-watch-pr-reviewer" \
-        --dangerously-skip-permissions \
-        >> "${LOG_FILE}" 2>&1; then
+    if (
+      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        claude -p "${REVIEW_PROMPT}" \
+          --dangerously-skip-permissions \
+          >> "${LOG_FILE}" 2>&1
+    ); then
       EXIT_CODE=0
     else
       EXIT_CODE=$?
     fi
     ;;
   codex)
-    if timeout "${MAX_RUNTIME}" \
-      codex --quiet \
-        --yolo \
-        --prompt "$(cat "${PROJECT_DIR}/.claude/commands/night-watch-pr-reviewer.md")" \
-        >> "${LOG_FILE}" 2>&1; then
+    if (
+      cd "${RUNTIME_PROJECT_DIR}" && timeout "${MAX_RUNTIME}" \
+        codex --quiet \
+          --yolo \
+          --prompt "${REVIEW_PROMPT}" \
+          >> "${LOG_FILE}" 2>&1
+    ); then
       EXIT_CODE=0
     else
       EXIT_CODE=$?
@@ -165,8 +216,6 @@ case "${PROVIDER_CMD}" in
     ;;
 esac
 
-cleanup_worktrees "${PROJECT_DIR}"
-
 if [ ${EXIT_CODE} -eq 0 ]; then
   log "DONE: PR reviewer completed successfully"
 elif [ ${EXIT_CODE} -eq 124 ]; then

package/templates/night-watch-pr-reviewer.md

@@ -67,18 +67,18 @@ A PR needs attention if **either** the review score is below 80 **or** any CI jo
 
 4. **Fix the PR**:
 
-   a. **Check out the PR branch**:
+   a. **Use the pre-provisioned runtime workspace**:
+      - You are already running in an isolated runtime workspace.
+      - Do **not** run `git checkout`/`git switch` in the original project directory.
+      - Do **not** create/remove worktrees manually; the runtime controller handles isolation and cleanup.
+
+   b. **Check out the PR branch inside the runtime workspace**:
       ```
       git fetch origin
       git checkout <branch-name>
       git pull origin <branch-name>
       ```
-
-   b. **Create a worktree** for the fixes:
-      ```
-      git worktree add ../${PROJECT_NAME}-nw-review-<branch-name> <branch-name>
-      ```
-      `cd` into worktree, run package install (npm install, yarn install, or pnpm install as appropriate).
+      Run package install (npm install, yarn install, or pnpm install as appropriate).
 
    c. **Address CI failures** (if any):
       - Read the failed job logs carefully to understand the root cause.
@@ -135,10 +135,6 @@ A PR needs attention if **either** the review score is below 80 **or** any CI jo
       Night Watch PR Reviewer"
       ```
 
-   h. **Clean up worktree**: `git worktree remove ../${PROJECT_NAME}-nw-review-<branch-name>`
-
 5. **Repeat** for all open PRs that need work.
 
-6. When done, return to ${DEFAULT_BRANCH}: `git checkout ${DEFAULT_BRANCH}`
-
 Start now. Check for open PRs that need review feedback addressed or CI failures fixed.

package/templates/night-watch.md

@@ -20,20 +20,13 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
 
    b. **Branch naming**: The branch MUST be named exactly `night-watch/<prd-filename-without-.md>`. Do NOT use `feat/`, `feature/`, or any other prefix. Example: for `health-check-endpoints.md` the branch is `night-watch/health-check-endpoints`.
 
-   c. **Create a feature branch** from ${DEFAULT_BRANCH}:
+   c. **Use the pre-provisioned runtime workspace**:
+      - You are already running in an isolated runtime workspace.
+      - The target branch `night-watch/<prd-filename-without-.md>` is already prepared.
+      - Do **not** run `git checkout`/`git switch` in the original project directory.
+      - Do **not** create/remove worktrees manually; the runtime controller handles isolation and cleanup.
 
-   ```
-   git checkout ${DEFAULT_BRANCH} && git pull origin ${DEFAULT_BRANCH}
-   git checkout -b night-watch/<prd-filename-without-.md>
-   ```
-
-   d. **Create a git worktree** for isolated work:
-
-   ```
-   git worktree add ../${PROJECT_NAME}-nw-<prd-name> night-watch/<prd-name>
-   ```
-
-   Then `cd` into the worktree and run package install (npm install, yarn install, or pnpm install as appropriate).
+   d. Install dependencies in the current runtime workspace (npm install, yarn install, or pnpm install as appropriate).
 
    e. **Implement the PRD using the PRD Executor workflow**:
       - Read `.claude/commands/prd-executor.md` and follow its full execution pipeline.
@@ -64,11 +57,9 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
    gh pr create --title "feat: <short title>" --body "<summary with PRD reference>"
    ```
 
-   j. **Move PRD to done** (back in main repo on ${DEFAULT_BRANCH}):
+   j. **Move PRD to done**:
 
    ```
-   cd ${PROJECT_DIR}
-   git checkout ${DEFAULT_BRANCH}
    mkdir -p docs/PRDs/night-watch/done
    mv docs/PRDs/night-watch/<file>.md docs/PRDs/night-watch/done/
    ```
@@ -91,10 +82,8 @@ You are the Night Watch agent. Your job is to autonomously pick up PRD tickets a
 
    l. **Commit** the move + summary update, push ${DEFAULT_BRANCH}.
 
-   m. **Clean up worktree**: `git worktree remove ../${PROJECT_NAME}-nw-<prd-name>`
-
-   n. **STOP after this PRD**. Do NOT continue to the next PRD. One PRD per run prevents timeouts and reduces risk. The next cron trigger will pick up the next PRD.
+   m. **STOP after this PRD**. Do NOT continue to the next PRD. One PRD per run prevents timeouts and reduces risk. The next cron trigger will pick up the next PRD.
 
-5. **On failure**: Do NOT move the PRD to done. Log the failure in NIGHT-WATCH-SUMMARY.md with status "Failed" and the reason. Clean up worktree and **stop** -- do not attempt the next PRD.
+5. **On failure**: Do NOT move the PRD to done. Log the failure in NIGHT-WATCH-SUMMARY.md with status "Failed" and the reason. The runtime controller handles cleanup. Then **stop** -- do not attempt the next PRD.
 
 Start now. Scan for available PRDs and process the first eligible one.