@jonit-dev/night-watch-cli 1.5.9 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jonit-dev/night-watch-cli",
-  "version": "1.5.9",
+  "version": "1.7.0",
   "description": "Autonomous PRD execution using AI Provider CLIs + cron",
   "type": "module",
   "bin": {
@@ -19,6 +19,9 @@
     "build:cli": "tsc",
     "test": "vitest run",
     "dev": "tsx src/cli.ts",
+    "dev:sandbox": "NIGHT_WATCH_HOME=/tmp/nw-sandbox tsx src/cli.ts",
+    "dev:sandbox:inspect": "sqlite3 /tmp/nw-sandbox/state.db",
+    "dev:sandbox:reset": "rm -rf /tmp/nw-sandbox && echo 'Sandbox cleared'",
     "dev:web": "concurrently --names \"api,vite\" --prefix-colors \"cyan,magenta\" \"tsx src/cli.ts serve\" \"yarn --cwd web dev\"",
     "prepublishOnly": "npm run build && npm test",
     "publish:npm": "npm publish --access public",
@@ -54,6 +57,7 @@
     "url": "https://github.com/jonit-dev/night-watch-cli/issues"
   },
   "dependencies": {
+    "better-sqlite3": "^12.6.2",
     "blessed": "^0.1.81",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
@@ -66,10 +70,11 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/blessed": "^0.1.27",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
-    "@types/node": "^20.11.0",
+    "@types/node": "^22.0.0",
     "@types/supertest": "^6.0.3",
     "concurrently": "^9.2.1",
     "eslint": "^10.0.0",
@@ -77,9 +82,9 @@
     "tsx": "^4.7.0",
     "typescript": "^5.3.0",
     "typescript-eslint": "^8.56.0",
-    "vitest": "^1.2.0"
+    "vitest": "^4.0.0"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   }
 }

package/scripts/night-watch-cron.sh

@@ -84,6 +84,48 @@ else
   BOOKKEEP_PRD_DIR="${BOOKKEEP_WORKTREE_DIR}/${PRD_DIR_REL}"
 fi
 
+count_prs_for_branch() {
+  local pr_state="${1:?pr_state required}"
+  local branch_name="${2:?branch_name required}"
+  local count
+  count=$(
+    { gh pr list --state "${pr_state}" --json headRefName --jq '.[].headRefName' 2>/dev/null || true; } \
+      | { grep -xF "${branch_name}" || true; } \
+      | wc -l \
+      | tr -d '[:space:]'
+  )
+  echo "${count:-0}"
+}
+
+finalize_prd_done() {
+  local reason="${1:?reason required}"
+
+  release_claim "${PRD_DIR}" "${ELIGIBLE_PRD}"
+  # NOTE: PRDs are moved to done/ immediately when a PR is opened (or already merged)
+  # rather than waiting for reviewer/merge loops.
+  if prepare_detached_worktree "${PROJECT_DIR}" "${BOOKKEEP_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
+    if mark_prd_done "${BOOKKEEP_PRD_DIR}" "${ELIGIBLE_PRD}"; then
+      night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" success --exit-code 0 2>/dev/null || true
+      if [[ "${PRD_DIR_REL}" = /* ]]; then
+        git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}" || true
+      else
+        git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}/" || true
+      fi
+      git -C "${BOOKKEEP_WORKTREE_DIR}" commit -m "chore: mark ${ELIGIBLE_PRD} as done (${reason})
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>" || true
+      git -C "${BOOKKEEP_WORKTREE_DIR}" push origin "HEAD:${DEFAULT_BRANCH}" || true
+      log "DONE: ${ELIGIBLE_PRD} ${reason}, PRD moved to done/"
+      return 0
+    fi
+    log "WARN: Failed to move ${ELIGIBLE_PRD} to done/ in bookkeeping worktree"
+    return 1
+  fi
+
+  log "WARN: Unable to prepare bookkeeping worktree for ${ELIGIBLE_PRD}"
+  return 1
+}
+
 log "START: Processing ${ELIGIBLE_PRD} on branch ${BRANCH_NAME} (worktree: ${WORKTREE_DIR})"
 
 PROMPT="Implement the PRD at docs/PRDs/night-watch/${ELIGIBLE_PRD}
@@ -127,6 +169,17 @@ if [ "${NW_DRY_RUN:-0}" = "1" ]; then
   exit 0
 fi
 
+# If this PRD already has a merged PR for its branch, finalize it immediately.
+MERGED_PR_COUNT=$(count_prs_for_branch merged "${BRANCH_NAME}")
+if [ "${MERGED_PR_COUNT}" -gt 0 ]; then
+  log "INFO: Found merged PR for ${BRANCH_NAME}; skipping provider run"
+  if finalize_prd_done "already merged on ${BRANCH_NAME}"; then
+    exit 0
+  fi
+  night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
+  exit 1
+fi
+
 if ! prepare_branch_worktree "${PROJECT_DIR}" "${WORKTREE_DIR}" "${BRANCH_NAME}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
   log "FAIL: Unable to create isolated worktree ${WORKTREE_DIR} for ${BRANCH_NAME}"
   night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
@@ -203,33 +256,21 @@ while [ "${ATTEMPT}" -lt "${MAX_RETRIES}" ]; do
 done
 
 if [ ${EXIT_CODE} -eq 0 ]; then
-  PR_EXISTS=$(gh pr list --state open --json headRefName --jq '.[].headRefName' 2>/dev/null | grep -cF "${BRANCH_NAME}" || echo "0")
-  if [ "${PR_EXISTS}" -gt 0 ]; then
-    release_claim "${PRD_DIR}" "${ELIGIBLE_PRD}"
-    # NOTE: PRDs are moved to done/ immediately when a PR is opened rather than waiting for
-    # the PR to merge. This is intentional — once a PR exists, the agent's implementation
-    # work is complete and it should not pick up this PRD again. Human review takes it from here.
-    if prepare_detached_worktree "${PROJECT_DIR}" "${BOOKKEEP_WORKTREE_DIR}" "${DEFAULT_BRANCH}" "${LOG_FILE}"; then
-      if mark_prd_done "${BOOKKEEP_PRD_DIR}" "${ELIGIBLE_PRD}"; then
-        night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" success --exit-code 0 2>/dev/null || true
-        if [[ "${PRD_DIR_REL}" = /* ]]; then
-          git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}" || true
-        else
-          git -C "${BOOKKEEP_WORKTREE_DIR}" add -A "${PRD_DIR_REL}/" || true
-        fi
-        git -C "${BOOKKEEP_WORKTREE_DIR}" commit -m "chore: mark ${ELIGIBLE_PRD} as done (PR opened on ${BRANCH_NAME})
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>" || true
-        git -C "${BOOKKEEP_WORKTREE_DIR}" push origin "HEAD:${DEFAULT_BRANCH}" || true
-        log "DONE: ${ELIGIBLE_PRD} implemented, PR opened, PRD moved to done/"
-      else
-        log "WARN: Failed to move ${ELIGIBLE_PRD} to done/ in bookkeeping worktree"
+  OPEN_PR_COUNT=$(count_prs_for_branch open "${BRANCH_NAME}")
+  if [ "${OPEN_PR_COUNT}" -gt 0 ]; then
+    if ! finalize_prd_done "implemented, PR opened on ${BRANCH_NAME}"; then
+      night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
+    fi
+  else
+    MERGED_PR_COUNT=$(count_prs_for_branch merged "${BRANCH_NAME}")
+    if [ "${MERGED_PR_COUNT}" -gt 0 ]; then
+      if ! finalize_prd_done "already merged on ${BRANCH_NAME}"; then
+        night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
       fi
     else
-      log "WARN: Unable to prepare bookkeeping worktree for ${ELIGIBLE_PRD}"
+      log "WARN: ${PROVIDER_CMD} exited 0 but no open/merged PR found on ${BRANCH_NAME} — recording cooldown to avoid repeated stuck runs"
+      night_watch_history record "${PROJECT_DIR}" "${ELIGIBLE_PRD}" failure --exit-code 1 2>/dev/null || true
     fi
-  else
-    log "WARN: ${PROVIDER_CMD} exited 0 but no PR found on ${BRANCH_NAME} — PRD NOT moved to done"
   fi
 elif [ ${EXIT_CODE} -eq 124 ]; then
   log "TIMEOUT: Night watch killed after ${MAX_RUNTIME}s while processing ${ELIGIBLE_PRD}"

package/scripts/night-watch-slicer-cron.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Night Watch Slicer Cron Runner (project-agnostic)
+# Usage: night-watch-slicer-cron.sh /path/to/project
+#
+# This is a thin wrapper that acquires a lock and calls `night-watch slice`.
+# The CLI command handles all the logic directly in TypeScript.
+#
+# NOTE: This script expects environment variables to be set by the caller.
+# The Node.js CLI will inject config values via environment variables.
+# Required env vars (with defaults shown):
+#   NW_SLICER_MAX_RUNTIME=600  - Maximum runtime in seconds (10 minutes)
+#   NW_PROVIDER_CMD=claude     - AI provider CLI to use (claude, codex, etc.)
+#   NW_DRY_RUN=0               - Set to 1 for dry-run mode (prints diagnostics only)
+
+PROJECT_DIR="${1:?Usage: $0 /path/to/project}"
+PROJECT_NAME=$(basename "${PROJECT_DIR}")
+LOG_DIR="${PROJECT_DIR}/logs"
+LOG_FILE="${LOG_DIR}/night-watch-slicer.log"
+LOCK_FILE=""
+MAX_RUNTIME="${NW_SLICER_MAX_RUNTIME:-600}"  # 10 minutes
+MAX_LOG_SIZE="524288"  # 512 KB
+PROVIDER_CMD="${NW_PROVIDER_CMD:-claude}"
+
+# Ensure NVM / Node / Night Watch CLI are on PATH
+export NVM_DIR="${HOME}/.nvm"
+[ -s "${NVM_DIR}/nvm.sh" ] && . "${NVM_DIR}/nvm.sh"
+
+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-slicer-${PROJECT_RUNTIME_KEY}.lock"
+
+# Validate provider
+if ! validate_provider "${PROVIDER_CMD}"; then
+  echo "ERROR: Unknown provider: ${PROVIDER_CMD}" >&2
+  exit 1
+fi
+
+rotate_log
+
+if ! acquire_lock "${LOCK_FILE}"; then
+  exit 0
+fi
+
+cleanup_on_exit() {
+  rm -f "${LOCK_FILE}"
+}
+
+trap cleanup_on_exit EXIT
+
+log "START: Running roadmap slicer for ${PROJECT_DIR}"
+
+# Dry-run mode: print diagnostics and exit
+if [ "${NW_DRY_RUN:-0}" = "1" ]; then
+  echo "=== Dry Run: Roadmap Slicer ==="
+  echo "Provider: ${PROVIDER_CMD}"
+  echo "Project Dir: ${PROJECT_DIR}"
+  echo "Timeout: ${MAX_RUNTIME}s"
+  exit 0
+fi
+
+# Resolve night-watch CLI
+CLI_BIN=""
+if ! CLI_BIN=$(resolve_night_watch_cli); then
+  log "ERROR: Could not resolve night-watch CLI"
+  exit 1
+fi
+
+# Run the slice command with timeout
+EXIT_CODE=0
+if timeout "${MAX_RUNTIME}" "${CLI_BIN}" slice >> "${LOG_FILE}" 2>&1; then
+  EXIT_CODE=0
+else
+  EXIT_CODE=$?
+fi
+
+if [ ${EXIT_CODE} -eq 0 ]; then
+  log "DONE: Slicer completed successfully"
+elif [ ${EXIT_CODE} -eq 124 ]; then
+  log "TIMEOUT: Slicer killed after ${MAX_RUNTIME}s"
+else
+  log "FAIL: Slicer exited with code ${EXIT_CODE}"
+fi
+
+exit ${EXIT_CODE}

package/templates/night-watch-slicer.md

@@ -0,0 +1,219 @@
+You are a **PRD Creator Agent**. Your job: analyze the codebase and write a complete Product Requirements Document (PRD) for a feature.
+
+When this activates: `PRD Creator: Initializing`
+
+---
+
+## Input
+
+You are creating a PRD for the following roadmap item:
+
+**Section:** {{SECTION}}
+**Title:** {{TITLE}}
+**Description:** {{DESCRIPTION}}
+
+The PRD must be written to this exact file path:
+**Output File:** `{{OUTPUT_FILE_PATH}}`
+
+The PRD directory is: `{{PRD_DIR}}`
+
+---
+
+## Your Task
+
+1. **Explore the Codebase** - Read relevant existing files to understand the project structure, patterns, and conventions. Look for:
+   - CLAUDE.md or similar AI assistant documentation files
+   - Existing code patterns in the area you'll be modifying
+   - Related features or modules that this feature interacts with
+   - Test patterns and verification commands
+
+2. **Assess Complexity** - Score the complexity using the rubric below and determine whether this is LOW, MEDIUM, or HIGH complexity.
+
+3. **Write a Complete PRD** - Create a full PRD following the template structure below. The PRD must be actionable, with concrete file paths, implementation steps, and test specifications.
+
+4. **Write the PRD File** - Use the Write tool to create the PRD file at the exact path specified in `{{OUTPUT_FILE_PATH}}`.
+
+---
+
+## Complexity Scoring
+
+```
+COMPLEXITY SCORE (sum all that apply):
++1  Touches 1-5 files
++2  Touches 6-10 files
++3  Touches 10+ files
++2  New system/module from scratch
++2  Complex state logic / concurrency
++2  Multi-package changes
++1  Database schema changes
++1  External API integration
+
+| Score | Level  | Template Mode                                   |
+| ----- | ------ | ----------------------------------------------- |
+| 1-3   | LOW    | Minimal (skip sections marked with MEDIUM/HIGH) |
+| 4-6   | MEDIUM | Standard (all sections)                         |
+| 7+    | HIGH   | Full + mandatory checkpoints every phase        |
+```
+
+---
+
+## PRD Template Structure
+
+Your PRD MUST follow this exact structure:
+
+```markdown
+# PRD: [Title from roadmap item]
+
+**Depends on:** [List any prerequisite PRDs/files, or omit if none]
+
+**Complexity: [SCORE] → [LEVEL] mode**
+
+- [Complexity breakdown as bullet list]
+
+---
+
+## 1. Context
+
+**Problem:** [1-2 sentences describing the issue being solved]
+
+**Files Analyzed:**
+- `path/to/file.ts` — [what the file does]
+- [List all files you inspected before planning]
+
+**Current Behavior:**
+- [3-5 bullets describing current state]
+
+### Integration Points Checklist
+
+**How will this feature be reached?**
+- [ ] Entry point identified: [e.g., route, event, cron, CLI command]
+- [ ] Caller file identified: [file that will invoke this new code]
+- [ ] Registration/wiring needed: [e.g., add route to router, register handler, add menu item]
+
+**Is this user-facing?**
+- [ ] YES → UI components required (list them)
+- [ ] NO → Internal/background feature (explain how it's triggered)
+
+**Full user flow:**
+1. User does: [action]
+2. Triggers: [what code path]
+3. Reaches new feature via: [specific connection point]
+4. Result displayed in: [where user sees outcome]
+
+---
+
+## 2. Solution
+
+**Approach:**
+- [3-5 bullets explaining the chosen solution]
+
+**Architecture Diagram** <!-- (MEDIUM/HIGH complexity) -->:
+
+```mermaid
+flowchart LR
+    A[Component A] --> B[Component B] --> C[Component C]
+```
+
+**Key Decisions:**
+- [Library/framework choices, error-handling strategy, reused utilities]
+
+**Data Changes:** [New schemas/migrations, or "None"]
+
+---
+
+## 3. Sequence Flow <!-- (MEDIUM/HIGH complexity) -->
+
+```mermaid
+sequenceDiagram
+    participant A as Component A
+    participant B as Component B
+    A->>B: methodName(args)
+    alt Error case
+        B-->>A: ErrorType
+    else Success
+        B-->>A: Response
+    end
+```
+
+---
+
+## 4. Execution Phases
+
+**CRITICAL RULES:**
+1. Each phase = ONE user-testable vertical slice
+2. Max 5 files per phase (split if larger)
+3. Each phase MUST include concrete tests
+4. Checkpoint after each phase (automated ALWAYS required)
+
+### Phase 1: [Name] — [User-visible outcome in 1 sentence]
+
+**Files (max 5):**
+- `src/path/file.ts` — [what changes]
+
+**Implementation:**
+- [ ] Step 1
+- [ ] Step 2
+
+**Tests Required:**
+| Test File | Test Name | Assertion |
+|-----------|-----------|-----------|
+| `src/__tests__/feature.test.ts` | `should do X when Y` | `expect(result).toBe(Z)` |
+
+**Verification Plan:**
+1. **Unit Tests:** File and test names
+2. **Integration Test:** (if applicable)
+3. **User Verification:**
+   - Action: [what to do]
+   - Expected: [what should happen]
+
+**Checkpoint:** Run automated review after this phase completes.
+
+---
+
+[Repeat for additional phases as needed]
+
+---
+
+## 5. Acceptance Criteria
+
+- [ ] All phases complete
+- [ ] All specified tests pass
+- [ ] Verification commands pass
+- [ ] All automated checkpoint reviews passed
+- [ ] Feature is reachable (entry point connected, not orphaned code)
+- [ ] [additional criterion specific to this feature]
+- [ ] [additional criterion specific to this feature]
+```
+
+---
+
+## Critical Instructions
+
+1. **Read all relevant existing files BEFORE writing any code**
+2. **Follow existing patterns in the codebase**
+3. **Write the PRD with concrete file paths and implementation details**
+4. **Include specific test names and assertions**
+5. **Use the Write tool to create the PRD file at `{{OUTPUT_FILE_PATH}}`**
+6. **The PRD must be complete and actionable - no TODO placeholders**
+
+DO NOT leave placeholder text like "[Name]" or "[description]" in the final PRD.
+DO NOT skip any sections.
+DO NOT forget to write the file.
+
+---
+
+## Output
+
+After writing the PRD file, report:
+
+```markdown
+## PRD Creation Complete
+
+**File:** {{OUTPUT_FILE_PATH}}
+**Title:** [PRD title]
+**Complexity:** [score] → [level]
+**Phases:** [count]
+
+### Summary
+[1-2 sentences summarizing the PRD content]
+```

package/templates/night-watch.config.json

@@ -5,6 +5,7 @@
   "provider": "claude",
   "reviewerEnabled": true,
   "prdDir": "docs/PRDs/night-watch",
+  "templatesDir": ".night-watch/templates",
   "maxRuntime": 7200,
   "reviewerMaxRuntime": 3600,
   "branchPrefix": "night-watch",