forge-cw 0.1.0

package/cw/hooks/scripts/review-autoclose.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+CW Review Auto-Close Hook (PostToolUse on Bash)
+================================================
+Detects when Claude posts a review via `gh api` or `gh pr review`
+and automatically closes the review session + tells Claude to stop.
+
+Only triggers session close on APPROVE. REQUEST_CHANGES and COMMENT
+leave the session open so the reviewer can continue iterating.
+
+Reads CW_PROJECT, CW_TASK, CW_TASK_TYPE from environment (set by cmd_review).
+"""
+
+import sys
+import json
+import os
+import re
+from datetime import datetime, timezone
+
+
+def _debug(msg):
+    """Write debug info to a log file for troubleshooting."""
+    try:
+        cw_home = os.environ.get("CW_HOME", os.path.expanduser("~/.cw"))
+        log_path = os.path.join(cw_home, "review-autoclose.log")
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with open(log_path, "a") as f:
+            f.write(f"{now} {msg}\n")
+    except Exception:
+        pass
+
+
+def main():
+    # Only act on review sessions
+    task_type = os.environ.get("CW_TASK_TYPE", "")
+    if task_type != "review":
+        sys.exit(0)
+
+    project = os.environ.get("CW_PROJECT", "")
+    task = os.environ.get("CW_TASK", "")  # e.g. "pr-123"
+    if not project or not task:
+        _debug(f"SKIP: missing env — project={project!r} task={task!r}")
+        sys.exit(0)
+
+    # Read hook data from stdin
+    try:
+        stdin_content = sys.stdin.read().strip()
+        if not stdin_content:
+            sys.exit(0)
+        hook_data = json.loads(stdin_content)
+    except (json.JSONDecodeError, Exception) as e:
+        _debug(f"SKIP: stdin parse error — {e}")
+        sys.exit(0)
+
+    # Check the command submitted a review
+    tool_input = hook_data.get("tool_input", {})
+    command = tool_input.get("command", "")
+
+    is_review = False
+    review_event = ""
+
+    # Pattern 1: gh api ... /reviews ... event=<EVENT> (with -f or -F flags)
+    if "gh api" in command and "reviews" in command:
+        # Match: -f event=APPROVE, -F event=APPROVE, event=APPROVE
+        m = re.search(
+            r'event[=\s]+["\']?(APPROVE|REQUEST_CHANGES|COMMENT)["\']?',
+            command,
+            re.IGNORECASE,
+        )
+        if m:
+            is_review = True
+            review_event = m.group(1).upper()
+        else:
+            # Also match JSON body: "event": "APPROVE" or "event":"APPROVE"
+            m = re.search(
+                r'"event"\s*:\s*"(APPROVE|REQUEST_CHANGES|COMMENT)"',
+                command,
+                re.IGNORECASE,
+            )
+            if m:
+                is_review = True
+                review_event = m.group(1).upper()
+
+    # Pattern 2: gh pr review --approve / --request-changes / --comment
+    if "gh pr review" in command:
+        if "--approve" in command:
+            is_review = True
+            review_event = "APPROVE"
+        elif "--request-changes" in command:
+            is_review = True
+            review_event = "REQUEST_CHANGES"
+        elif "--comment" in command:
+            is_review = True
+            review_event = "COMMENT"
+
+    if not is_review:
+        _debug(f"SKIP: not a review command — {command[:200]}")
+        sys.exit(0)
+
+    _debug(f"DETECTED: {review_event} for {project} {task}")
+
+    # Only auto-close on APPROVE — REQUEST_CHANGES and COMMENT leave
+    # the session open so the reviewer can keep iterating.
+    if review_event != "APPROVE":
+        _debug(f"SKIP: not closing session — event is {review_event}, not APPROVE")
+        sys.exit(0)
+
+    # Check that the command succeeded
+    # tool_response has: stdout, stderr, interrupted — no exit_code field
+    tool_response = hook_data.get("tool_response", {})
+
+    # Guard: tool_response might be a string in some cases
+    if isinstance(tool_response, str):
+        tool_response = {"stdout": tool_response, "stderr": "", "interrupted": False}
+
+    stderr = tool_response.get("stderr", "")
+    stdout = tool_response.get("stdout", "")
+    interrupted = tool_response.get("interrupted", False)
+
+    # gh pr review outputs its success message to stderr (e.g. "✓ Approved pull request #334")
+    # so we can't treat stderr-only output as failure. Instead, only bail if interrupted
+    # or if stderr looks like an actual error (no success indicator and no stdout).
+    has_error = stderr and "error" in stderr.lower() and not stdout
+    if interrupted or has_error:
+        _debug(f"SKIP: command failed — interrupted={interrupted} has_error={has_error} stderr={stderr[:200]}")
+        sys.exit(0)
+
+    # ── Close the review session (same as cw review --done) ──────────
+    cw_home = os.environ.get("CW_HOME", os.path.expanduser("~/.cw"))
+    sessions_log = os.path.join(cw_home, "sessions.log")
+    session_dir = os.path.join(cw_home, "sessions", project, f"review-{task}")
+    session_meta = os.path.join(session_dir, "session.json")
+
+    # Update session.json
+    if os.path.isfile(session_meta):
+        try:
+            with open(session_meta) as f:
+                meta = json.load(f)
+            meta["status"] = "done"
+            meta["review_event"] = review_event
+            meta["closed"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+            with open(session_meta, "w") as f:
+                json.dump(meta, f, indent=2)
+            _debug(f"CLOSED: session updated — {session_meta}")
+        except Exception as e:
+            _debug(f"ERROR: failed to update session — {e}")
+    else:
+        _debug(f"WARN: session.json not found at {session_meta}")
+
+    # Log to sessions.log
+    try:
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+        with open(sessions_log, "a") as f:
+            f.write(f"{now} DONE {project} review={task}\n")
+    except Exception:
+        pass
+
+    # Tell Claude to stop — exit code 2 sends stderr as feedback
+    event_label = review_event.replace("_", " ").title()
+    print(
+        f"STOP. The review session for {project} PR #{task.replace('pr-', '')} "
+        f"has been automatically closed after {event_label}. "
+        "The session metadata and logs have been updated. "
+        "Do NOT continue working. Say a brief goodbye and stop.",
+        file=sys.stderr,
+    )
+    sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

package/cw/install.sh

@@ -0,0 +1,243 @@
+#!/bin/bash
+set -euo pipefail
+
+# CW Installer — Coding Workspace
+# Usage: ./install.sh [--no-shell]
+#   or:  curl -fsSL https://raw.githubusercontent.com/avarajar/cw/main/install.sh | bash
+#
+#   --no-shell  install without adding the shell integration to ~/.zshrc or
+#               ~/.bashrc (for installers such as Forge that call cw by path)
+
+CW_HOME="${CW_HOME:-$HOME/.cw}"
+REPO_URL="https://github.com/avarajar/cw"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}" 2>/dev/null)" && pwd 2>/dev/null || echo ".")"
+
+NC='\033[0m'
+BOLD='\033[1m'
+C='\033[36m'
+G='\033[32m'
+Y='\033[33m'
+R='\033[31m'
+
+log()  { echo -e "${C}[cw]${NC} $*"; }
+ok()   { echo -e "${G}[✓]${NC} $*"; }
+warn() { echo -e "${Y}[!]${NC} $*"; }
+err()  { echo -e "${R}[✗]${NC} $*" >&2; }
+
+# ── Check requirements ──────────────────────────────────────────────────────
+
+check_requirements() {
+    local missing=()
+
+    if ! command -v git &>/dev/null; then
+        missing+=("git")
+    fi
+
+    if ! command -v python3 &>/dev/null; then
+        missing+=("python3")
+    fi
+
+    if ! command -v claude &>/dev/null; then
+        warn "Claude Code CLI not found. Install: npm install -g @anthropic-ai/claude-code"
+    fi
+
+    if [[ ${#missing[@]} -gt 0 ]]; then
+        err "Missing required tools: ${missing[*]}"
+        exit 1
+    fi
+
+    # Check git version (need 2.15+ for worktrees)
+    local git_version
+    git_version=$(git --version | grep -oE '[0-9]+\.[0-9]+' | head -1)
+    local major minor
+    major=$(echo "$git_version" | cut -d. -f1)
+    minor=$(echo "$git_version" | cut -d. -f2)
+    if [[ $major -lt 2 ]] || [[ $major -eq 2 && $minor -lt 15 ]]; then
+        err "Git 2.15+ required for worktree support. Current: $(git --version)"
+        exit 1
+    fi
+
+    # Check that `env bash` resolves to bash 4+. macOS ships /bin/bash 3.2,
+    # which breaks cw at runtime even if install.sh ran under a newer bash.
+    local env_bash_version
+    env_bash_version=$(/usr/bin/env bash -c 'echo "$BASH_VERSINFO"' 2>/dev/null || echo 0)
+    if [[ $env_bash_version -lt 4 ]]; then
+        err "cw requires bash >= 4, but \`env bash\` resolves to bash $env_bash_version on this system."
+        err "On macOS: brew install bash, then ensure /opt/homebrew/bin precedes /bin in PATH."
+        exit 1
+    fi
+
+    ok "Requirements met"
+}
+
+# ── Install ─────────────────────────────────────────────────────────────────
+
+install_files() {
+    local source_dir="$SCRIPT_DIR"
+
+    # If running from curl pipe, clone to temp dir
+    if [[ ! -f "$source_dir/cw" ]]; then
+        log "Downloading CW..."
+        local tmp_dir
+        tmp_dir=$(mktemp -d)
+        git clone --depth 1 "$REPO_URL" "$tmp_dir" 2>/dev/null
+        source_dir="$tmp_dir"
+    fi
+
+    # Create directory structure
+    mkdir -p "$CW_HOME"/{bin,lib,accounts,sessions,templates/workflows,agents,commands,mcps,stacks}
+
+    # Copy scripts
+    cp "$source_dir/cw" "$CW_HOME/bin/cw"
+    chmod +x "$CW_HOME/bin/cw"
+
+    cp "$source_dir/cw-shell-integration.sh" "$CW_HOME/cw-shell-integration.sh"
+
+    # Copy lib
+    if [[ -d "$source_dir/lib" ]]; then
+        cp "$source_dir"/lib/*.sh "$CW_HOME/lib/" 2>/dev/null || true
+        # Copy harness drivers and context adapters
+        for sub in harnesses context; do
+            if [[ -d "$source_dir/lib/$sub" ]]; then
+                mkdir -p "$CW_HOME/lib/$sub"
+                cp "$source_dir"/lib/$sub/*.sh "$CW_HOME/lib/$sub/" 2>/dev/null || true
+            fi
+        done
+        # Copy dashboard
+        if [[ -d "$source_dir/lib/dashboard" ]]; then
+            mkdir -p "$CW_HOME/lib/dashboard"
+            cp "$source_dir"/lib/dashboard/{server.py,index.html,activity-hook.py,start.sh} "$CW_HOME/lib/dashboard/" 2>/dev/null || true
+            ok "Dashboard installed"
+        fi
+    fi
+
+    # Copy templates
+    cp "$source_dir/templates/CLAUDE.template.md" "$CW_HOME/templates/CLAUDE.template.md"
+
+    # Copy agents
+    if [[ -d "$source_dir/agents" ]]; then
+        mkdir -p "$CW_HOME/agents"
+        cp "$source_dir"/agents/*.md "$CW_HOME/agents/" 2>/dev/null || true
+        ok "Agents installed"
+    fi
+
+    # Copy hooks
+    if [[ -d "$source_dir/hooks" ]]; then
+        mkdir -p "$CW_HOME/hooks"
+        cp -r "$source_dir/hooks/." "$CW_HOME/hooks/"
+        ok "Hooks installed"
+    fi
+
+    # Copy MCP configs
+    if [[ -d "$source_dir/mcps" ]]; then
+        mkdir -p "$CW_HOME/mcps"
+        cp "$source_dir"/mcps/*.json "$CW_HOME/mcps/" 2>/dev/null || true
+        ok "MCP configs installed"
+    fi
+
+    # Initialize projects.json if not exists
+    [[ -f "$CW_HOME/projects.json" ]] || echo '{}' > "$CW_HOME/projects.json"
+
+    ok "Files installed to $CW_HOME"
+
+    # Cleanup temp dir if used. Must be `if` (not `[[ ]] && cmd`) because a
+    # false test on the function's last statement propagates exit 1 and
+    # `set -e` would abort the script before setup_shell runs.
+    if [[ -n "${tmp_dir:-}" && -d "$tmp_dir" ]]; then
+        rm -rf "$tmp_dir"
+    fi
+}
+
+# ── Shell integration ───────────────────────────────────────────────────────
+
+setup_shell() {
+    local shell_line='[[ -f "$HOME/.cw/cw-shell-integration.sh" ]] && source "$HOME/.cw/cw-shell-integration.sh"'
+    local added=false
+
+    # Detect the user's actual shell
+    local user_shell
+    user_shell=$(basename "${SHELL:-/bin/zsh}")
+
+    # Prioritize the active shell's rc file
+    local rc_files=()
+    if [[ "$user_shell" == "zsh" ]]; then
+        rc_files=("$HOME/.zshrc" "$HOME/.bashrc")
+    else
+        rc_files=("$HOME/.bashrc" "$HOME/.zshrc")
+    fi
+
+    for rc in "${rc_files[@]}"; do
+        if [[ -f "$rc" ]]; then
+            if ! grep -q "cw-shell-integration" "$rc" 2>/dev/null; then
+                echo "" >> "$rc"
+                echo "# CW — Coding Workspace" >> "$rc"
+                echo "$shell_line" >> "$rc"
+                ok "Added to $rc"
+                added=true
+            else
+                ok "Already in $rc"
+                added=true
+            fi
+        fi
+    done
+
+    # If no rc file exists for the active shell, create it
+    if ! $added; then
+        local target_rc="$HOME/.${user_shell}rc"
+        echo "" >> "$target_rc"
+        echo "# CW — Coding Workspace" >> "$target_rc"
+        echo "$shell_line" >> "$target_rc"
+        ok "Created and added to $target_rc"
+        added=true
+    fi
+
+    # Verify PATH will work after sourcing
+    if ! echo "$PATH" | tr ':' '\n' | grep -q "$CW_HOME/bin"; then
+        echo ""
+        warn "PATH does not include ${C}$CW_HOME/bin${NC} yet."
+        echo -e "  Run: ${C}source ~/.${user_shell}rc${NC}  or restart your terminal."
+    fi
+}
+
+# ── Main ────────────────────────────────────────────────────────────────────
+
+main() {
+    local shell_integration=true
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --no-shell) shell_integration=false ;;
+            *) err "Unknown option: $1"; echo "Usage: ./install.sh [--no-shell]" >&2; exit 1 ;;
+        esac
+        shift
+    done
+
+    echo ""
+    echo -e "${BOLD}CW — Coding Workspace${NC}"
+    echo -e "Installing to ${C}$CW_HOME${NC}"
+    echo ""
+
+    check_requirements
+    install_files
+    if $shell_integration; then
+        setup_shell
+    else
+        log "Skipped shell integration (--no-shell): run ${C}$CW_HOME/bin/cw${NC} by path"
+    fi
+
+    echo ""
+    ok "Installation complete!"
+    echo ""
+    echo -e "  ${BOLD}Next steps:${NC}"
+    if $shell_integration; then
+        echo -e "  1. Restart your terminal (or: ${C}source ~/.zshrc${NC})"
+    else
+        echo -e "  1. Add ${C}$CW_HOME/bin${NC} to your PATH to run cw from a terminal"
+    fi
+    echo -e "  2. ${C}cw init${NC}"
+    echo -e "  3. ${C}cw account add work${NC}"
+    echo -e "  4. ${C}cw project register <path> --account work${NC}"
+    echo -e "  5. ${C}cw work <project> <task>${NC}"
+    echo ""
+}
+
+main "$@"

package/cw/lib/context/github.sh

@@ -0,0 +1,51 @@
+# github needs no cw credential; gh carries its own auth
+context_credential_github() {
+    command -v gh >/dev/null 2>&1
+}
+
+# passes gh the canonical url so it never resolves the repo from the caller's cwd
+context_fetch_github() {
+    local url="$1"
+    local re='^https?://(www\.)?github\.com/([^/[:space:]]+)/([^/[:space:]]+)/(issues|pull)/([0-9]+)([/?#].*)?$'
+    [[ "$url" =~ $re ]] || return 1
+    local owner="${BASH_REMATCH[2]}" repo="${BASH_REMATCH[3]}" path="${BASH_REMATCH[4]}" num="${BASH_REMATCH[5]}"
+    local kind=issue
+    [[ "$path" == pull ]] && kind=pr
+    local canonical="https://github.com/$owner/$repo/$path/$num"
+    local json
+    json=$(gh "$kind" view "$canonical" --json title,body,number,state,labels 2>/dev/null) || return 1
+    CW_GH_JSON="$json" CW_GH_NUM="$num" python3 - <<'PY'
+import json, os, sys
+try:
+    d = json.loads(os.environ["CW_GH_JSON"])
+except Exception:
+    sys.exit(1)
+# a response for a different number means gh answered a different question
+if str(d.get("number")) != os.environ["CW_GH_NUM"]:
+    sys.exit(1)
+labels = ", ".join(l["name"] for l in d.get("labels", []))
+print(f"**#{d.get('number')} — {d.get('title','')}**")
+print(f"State: {d.get('state','')}" + (f" · Labels: {labels}" if labels else ""))
+print()
+print(d.get("body") or "_No description._")
+PY
+}
+
+# prints a pull request's head branch, asking gh with the canonical url
+context_pr_branch_github() {
+    local url="$1"
+    local re='^https?://(www\.)?github\.com/([^/[:space:]]+)/([^/[:space:]]+)/pull/([0-9]+)([/?#].*)?$'
+    [[ "$url" =~ $re ]] || return 1
+    local canonical="https://github.com/${BASH_REMATCH[2]}/${BASH_REMATCH[3]}/pull/${BASH_REMATCH[4]}"
+    local json
+    json=$(gh pr view "$canonical" --json headRefName 2>/dev/null) || return 1
+    CW_GH_JSON="$json" python3 -c '
+import json, os, sys
+try:
+    branch = json.loads(os.environ["CW_GH_JSON"]).get("headRefName") or ""
+except Exception:
+    sys.exit(1)
+if not branch:
+    sys.exit(1)
+print(branch, end="")'
+}

package/cw/lib/context/linear.sh

@@ -0,0 +1,49 @@
+# linear needs a personal api key from the env or ~/.cw/tokens.env
+context_credential_linear() {
+    [[ -n "${LINEAR_API_KEY:-}" ]] && return 0
+    [[ -f "$CW_HOME/tokens.env" ]] && grep -q '^LINEAR_API_KEY=' "$CW_HOME/tokens.env"
+}
+
+context_fetch_linear() {
+    local url="$1"
+    local id; id=$(printf '%s' "$url" | grep -oE '[A-Z]+-[0-9]+' | head -1)
+    [[ -n "$id" ]] || return 1
+    local key="${LINEAR_API_KEY:-}"
+    [[ -z "$key" && -f "$CW_HOME/tokens.env" ]] && \
+        key=$(sed -n 's/^LINEAR_API_KEY=//p' "$CW_HOME/tokens.env" | head -1)
+    [[ -n "$key" ]] || return 1
+    local api="${CW_LINEAR_API:-https://api.linear.app/graphql}"
+    CW_LINEAR_KEY="$key" CW_LINEAR_ID="$id" CW_LINEAR_URL="$api" CW_LINEAR_META="${CW_CONTEXT_META:-}" python3 - <<'PY'
+import json, os, sys, urllib.request
+q = """query($id:String!){issue(id:$id){identifier title description branchName priority
+      comments{nodes{body}}}}"""
+req = urllib.request.Request(
+    os.environ["CW_LINEAR_URL"],
+    data=json.dumps({"query": q, "variables": {"id": os.environ["CW_LINEAR_ID"]}}).encode(),
+    headers={"Authorization": os.environ["CW_LINEAR_KEY"], "Content-Type": "application/json"},
+)
+try:
+    with urllib.request.urlopen(req, timeout=15) as r:
+        d = json.load(r)
+except Exception as e:
+    print(f"_Linear fetch failed: {e}_", file=sys.stderr)
+    sys.exit(1)
+i = (d.get("data") or {}).get("issue")
+if not i:
+    sys.exit(1)
+# the branch goes to cw as json too, so it never has to parse the markdown
+if os.environ["CW_LINEAR_META"] and i.get("branchName"):
+    with open(os.environ["CW_LINEAR_META"], "w") as f:
+        json.dump({"branch": i["branchName"]}, f)
+print(f"**{i['identifier']} — {i['title']}**")
+if i.get("branchName"):
+    print(f"Branch: `{i['branchName']}`")
+print()
+print(i.get("description") or "_No description._")
+nodes = (i.get("comments") or {}).get("nodes") or []
+if nodes:
+    print("\n**Comments**")
+    for c in nodes:
+        print(f"- {c['body']}")
+PY
+}