peakypanes 0.0.1 → 0.0.3

package/README.md

@@ -29,20 +29,20 @@ Define your tmux layouts in YAML, share them with your team via git, and get con
 
 ### Install
 
-Using npm
+**Using npm (recommended)**
 
 ```bash
 npm i -g peakypanes
-peakypanes setup
+peakypanes
 ```
 
-> npm packages are currently published for macOS and Linux.  
-> Windows users should install from the GitHub release or build with Go.
+> [!TIP]
+> Run `peakypanes setup` to check dependencies
 
-Run once with npx
+**Run once with npx**
 
 ```bash
-npx -y peakypanes setup
+npx -y peakypanes
 ```
 
 Using Go
@@ -53,12 +53,6 @@ go install github.com/regenrek/peakypanes/cmd/peakypanes@latest
 
 ### Usage
 
-**Just run it:**
-```bash
-cd your-project
-peakypanes
-```
-
 **Start a session (auto-detect layout):**
 ```bash
 peakypanes start
@@ -246,33 +240,40 @@ The dashboard shows:
 - Sessions on the left (with window counts and expandable windows)
 - Live pane preview on the right (window bar at the bottom)
 - Lightweight session thumbnails at the bottom (last activity per session)
+- Quick reply bar (always visible) and target pane highlight for follow-ups
 
 Navigation (always visible):
-- `←/→` project, `↑/↓` session, `⇧↑/⇧↓` window, `?` help
+- `ctrl+a/ctrl+d` project, `ctrl+w/ctrl+s` session, `tab/⇧tab` pane (across windows), `ctrl+g` help
 
-Key bindings (also shown in `?` help):
+Key bindings (also shown in the help view):
+Keymap overrides are available in the global config (`~/.config/peakypanes/config.yml`).
 
 Project
-- `o` open project picker (creates session detached; stay in dashboard)
-- `c` close project (kills all running sessions in project)
+- `ctrl+o` open project picker (creates session detached; stay in dashboard)
+- `ctrl+b` close project (kills all running sessions in project)
 
 Session
-- `enter` attach/start session
-- `n` new session (pick layout)
-- `t` open in new terminal window
-- `K` kill session
+- `enter` attach/start session (when reply is empty)
+- `ctrl+n` new session (pick layout)
+- `ctrl+t` open in new terminal window
+- `ctrl+x` kill session
 - rename session via command palette (`ctrl+p`)
 
 Window
-- `space` toggle window list
+- `ctrl+u` toggle window list
 - rename window via command palette (`ctrl+p`)
 
+Pane
+- rename pane via command palette (`ctrl+p`)
+
 Tmux (inside session)
 - `prefix+g` open dashboard popup (tmux prefix is yours)
 
 Other
 - `ctrl+p` command palette
-- `r` refresh, `e` edit config, `/` filter, `q` quit
+- `ctrl+r` refresh, `ctrl+e` edit config, `ctrl+f` filter, `ctrl+c` quit
+
+Quick reply details: the input is always active—type and press `enter` to send to the highlighted pane. Use `esc` to clear. `tab/⇧tab` still cycles panes while the input is focused.
 
 ### Dashboard Config (optional)
 
@@ -285,10 +286,56 @@ dashboard:
   idle_seconds: 20
   show_thumbnails: true
   preview_mode: grid  # grid | layout
+  attach_behavior: new_terminal  # current | new_terminal | detached
+  keymap:
+    project_left: ["ctrl+a"]
+    project_right: ["ctrl+d"]
+    session_up: ["ctrl+w"]
+    session_down: ["ctrl+s"]
+    pane_next: ["tab"]
+    pane_prev: ["shift+tab"]
+    toggle_windows: ["ctrl+u"]
+    command_palette: ["ctrl+p"]
+    help: ["ctrl+g"]
+    quit: ["ctrl+c"]
   status_regex:
     success: "(?i)done|finished|success|completed|✅"
     error: "(?i)error|failed|panic|❌"
     running: "(?i)running|in progress|building|installing|▶"
+  agent_detection:
+    codex: true
+    claude: true
+```
+
+`attach_behavior` controls what the “attach/start” action does (default `new_terminal`): `current` switches the terminal running PeakyPanes into the session, `new_terminal` opens a fresh terminal to attach, and `detached` only creates the session.
+
+### Agent Status Detection (Codex & Claude Code)
+
+PeakyPanes can read per-pane JSON state files to show accurate running/idle/done status for Codex CLI and Claude Code TUI sessions. This is **on by default** and falls back to regex/idle detection if no state file is present. You can disable it via `dashboard.agent_detection`.
+
+State files are written under `${XDG_RUNTIME_DIR:-/tmp}/peakypanes/agent-state` and keyed by `TMUX_PANE` (override with `PEAKYPANES_AGENT_STATE_DIR`).
+
+**Codex CLI (TUI)**
+
+Add a `notify` command in your Codex config to call the PeakyPanes hook script (Codex passes one JSON arg):
+
+```toml
+# ~/.codex/config.toml
+notify = ["python3", "/absolute/path/to/peakypanes/scripts/agent-state/codex-notify.py"]
+```
+
+Tip: with `npm i -g peakypanes`, the scripts live under `$(npm root -g)/peakypanes/scripts/agent-state/`.
+Note: Codex `notify` only fires on turn completion, so running state still relies on regex/idle detection between turns.
+
+**Claude Code (TUI)**
+
+Configure hooks to run the PeakyPanes hook script (Claude passes JSON on stdin). Recommended events:
+`SessionStart`, `UserPromptSubmit`, `PreToolUse`, `PermissionRequest`, `Stop`, `SessionEnd`.
+
+Example hook command (wire it to each event above in Claude Code):
+
+```bash
+python3 /absolute/path/to/peakypanes/scripts/agent-state/claude-hook.py
 ```
 
 ### Tmux Config & Key Bindings
@@ -315,6 +362,45 @@ settings:
 3. Project entry in `~/.config/peakypanes/config.yml`
 4. Built-in `dev-3` layout (fallback)
 
+## Testing
+
+Run the unit tests with coverage:
+
+```bash
+go test ./... -coverprofile /tmp/peakypanes.cover
+go tool cover -func /tmp/peakypanes.cover | tail -n 1
+```
+
+Race tests:
+
+```bash
+go test ./... -race
+```
+
+Tmux integration tests (requires tmux; opt-in):
+
+```bash
+PEAKYPANES_INTEGRATION=1 go test ./internal/tmuxctl -run Integration -count=1
+```
+
+Manual npm smoke run (fresh HOME/XDG config):
+
+```bash
+scripts/fresh-run
+scripts/fresh-run 0.0.2 --with-project
+```
+
+GitHub Actions runs gofmt checks, go vet, go test with coverage, race, and tmux integration tests on Linux.
+
+## Release
+
+See `RELEASE-DOCS.md` for the full release checklist (tests, tag, GoReleaser, npm publish).
+
+## Windows
+> npm packages are currently published for macOS and Linux.  
+> Windows users should install from the GitHub release or build with Go.
+
+
 ## For Teams
 
 1. Run `peakypanes init --local` in your project
@@ -325,3 +411,18 @@ settings:
 ## License
 
 MIT
+
+
+## Links
+
+- X/Twitter: [@kregenrek](https://x.com/kregenrek)
+- Bluesky: [@kevinkern.dev](https://bsky.app/profile/kevinkern.dev)
+
+## Courses
+- Learn Cursor AI: [Ultimate Cursor Course](https://www.instructa.ai/en/cursor-ai)
+- Learn to build software with AI: [AI Builder Hub](https://www.instructa.ai)
+
+## See my other projects:
+
+* [codefetch](https://github.com/regenrek/codefetch) - Turn code into Markdown for LLMs with one simple terminal command
+* [instructa](https://github.com/orgs/instructa/repositories) - Instructa Projects

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peakypanes",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Tmux layout manager with YAML based configuration.",
   "license": "MIT",
   "homepage": "https://github.com/regenrek/peakypanes",
@@ -12,17 +12,18 @@
     "peakypanes": "bin/peakypanes.js"
   },
   "optionalDependencies": {
-    "peakypanes-darwin-x64": "0.0.1",
-    "peakypanes-darwin-arm64": "0.0.1",
-    "peakypanes-linux-x64": "0.0.1",
-    "peakypanes-linux-arm64": "0.0.1"
+    "peakypanes-darwin-x64": "0.0.3",
+    "peakypanes-darwin-arm64": "0.0.3",
+    "peakypanes-linux-x64": "0.0.3",
+    "peakypanes-linux-arm64": "0.0.3"
   },
   "engines": {
     "node": ">=18"
   },
   "files": [
     "bin/peakypanes.js",
-    "README.md"
+    "README.md",
+    "scripts/agent-state/"
   ],
   "publishConfig": {
     "access": "public"

package/scripts/agent-state/claude-hook.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+
+def state_dir() -> Path:
+    root = os.environ.get("PEAKYPANES_AGENT_STATE_DIR")
+    if root:
+        return Path(root)
+    runtime = os.environ.get("XDG_RUNTIME_DIR") or "/tmp"
+    return Path(runtime) / "peakypanes" / "agent-state"
+
+
+def write_state(pane_id: str, state: str, tool: str, payload: dict) -> None:
+    path = state_dir()
+    path.mkdir(parents=True, exist_ok=True)
+    record = {
+        "state": state,
+        "tool": tool,
+        "updated_at_unix_ms": int(time.time() * 1000),
+        "pane_id": pane_id,
+    }
+    session_id = payload.get("session_id") or payload.get("sessionId")
+    if session_id:
+        record["session_id"] = session_id
+    transcript = payload.get("transcript_path") or payload.get("transcriptPath")
+    if transcript:
+        record["transcript_path"] = transcript
+    target = path / f"{pane_id}.json"
+    tmp = target.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(record))
+    tmp.replace(target)
+
+
+def normalize_event(payload: dict) -> str:
+    for key in ("event", "hook", "type", "name"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            return value.strip().lower()
+    return ""
+
+
+def map_event_to_state(event: str, payload: dict) -> str:
+    if event in {"sessionstart", "session_start"}:
+        return "idle"
+    if event in {"userpromptsubmit", "user_prompt_submit"}:
+        return "running"
+    if event in {"pretooluse", "pre_tool_use"}:
+        return "running"
+    if event in {"posttooluse", "post_tool_use"}:
+        return "running"
+    if event in {"permissionrequest", "permission_request"}:
+        return "waiting"
+    if event in {"notification"}:
+        return "waiting"
+    if event in {"stop"}:
+        return "idle"
+    if event in {"sessionend", "session_end"}:
+        reason = payload.get("reason") or payload.get("end_reason")
+        if isinstance(reason, str) and reason.lower() in {"error", "failed", "failure"}:
+            return "error"
+        exit_code = payload.get("exit_code") or payload.get("exitCode")
+        if isinstance(exit_code, int) and exit_code != 0:
+            return "error"
+        return "done"
+    return ""
+
+
+def main() -> int:
+    pane_id = os.environ.get("TMUX_PANE", "").strip()
+    if not pane_id:
+        return 0
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        return 0
+    event = normalize_event(payload)
+    if not event:
+        return 0
+    state = map_event_to_state(event, payload)
+    if not state:
+        return 0
+    write_state(pane_id, state, "claude", payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/agent-state/codex-notify.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+import time
+from pathlib import Path
+
+
+def state_dir() -> Path:
+    root = os.environ.get("PEAKYPANES_AGENT_STATE_DIR")
+    if root:
+        return Path(root)
+    runtime = os.environ.get("XDG_RUNTIME_DIR") or "/tmp"
+    return Path(runtime) / "peakypanes" / "agent-state"
+
+
+def write_state(pane_id: str, state: str, tool: str, payload: dict) -> None:
+    path = state_dir()
+    path.mkdir(parents=True, exist_ok=True)
+    record = {
+        "state": state,
+        "tool": tool,
+        "updated_at_unix_ms": int(time.time() * 1000),
+        "pane_id": pane_id,
+    }
+    if payload.get("turn-id"):
+        record["turn_id"] = payload.get("turn-id")
+    if payload.get("thread-id"):
+        record["thread_id"] = payload.get("thread-id")
+    if payload.get("cwd"):
+        record["cwd"] = payload.get("cwd")
+    target = path / f"{pane_id}.json"
+    tmp = target.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(record))
+    tmp.replace(target)
+
+
+def main() -> int:
+    pane_id = os.environ.get("TMUX_PANE", "").strip()
+    if not pane_id:
+        return 0
+    if len(sys.argv) < 2:
+        return 0
+    try:
+        payload = json.loads(sys.argv[-1])
+    except json.JSONDecodeError:
+        return 0
+    if payload.get("type") != "agent-turn-complete":
+        return 0
+    write_state(pane_id, "idle", "codex", payload)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())