@gi4nks/ph 1.3.2

package/docs/hooks.md

@@ -0,0 +1,83 @@
+# ph Implementation Status — Complete Report
+
+    ✅ Completed
+
+    ┌───────────────────────────────────────────────────────────┬────────────────────────────┬────────┐
+    │                          Feature                          │            File            │ Status │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Git Context Snapshot                                      │ src/runner/git-context.ts  │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Background Analysis                                       │ src/background/analyzer.ts │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Work Sessions (ph sessions)                               │ src/sessions/index.ts      │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Prompt Rerunning (TUI r)                                  │ src/ui/BrowseApp.tsx       │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Ollama embeddings (nomic-embed-text-v2-moe)               │ src/embedding/index.ts     │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Response column in DB + FTS5 migration                    │ src/db/index.ts            │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ ph log command (flag + stdin JSON)                        │ src/cli.ts                 │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ TUI detail view with response                             │ src/ui/BrowseApp.tsx       │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Export markdown with response + git context               │ src/cli.ts                 │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Gemini importer response capture                          │ src/importer/gemini.ts     │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Claude importer from transcript files                     │ src/importer/claude.ts     │ ✅     │
+    ├───────────────────────────────────────────────────────────┼────────────────────────────┼────────┤
+    │ Documentation (README, CLAUDE.md, GEMINI.md, ROADMAP.md)  │ various                    │ ✅     │
+    └───────────────────────────────────────────────────────────┴────────────────────────────┴────────┘
+
+    🔄 In Progress (background agent)
+
+    - Claude Code hook (~/.claude/settings.json + ~/.claude/ph-hook.sh): Stop hook that calls ph log after each response
+    - Gemini CLI skill/hook: similar integration for the Gemini CLI
+
+    📋 Hook Architecture (being implemented)
+
+    Claude finishes a response
+      → Stop hook in settings.json
+      → ~/.claude/ph-hook.sh receives JSON on stdin
+      → jq extracts last user prompt + assistant response text
+      → ph log --tool claude --prompt "..." --response "..."
+      → record inserted into DB with background analysis
+
+    ⏳ Still To Do (after hooks)
+
+    - Claude importer from history.jsonl: already replaced by the new transcript importer — ✅ covered
+    - End-to-end testing of hooks in a real session
+    - ph import claude update in cli.ts: verify that cmdImport calls the new importer correctly (the file was rewritten but the caller in cli.ts might still reference history.jsonl in the output log)
+
+    Final Data Flow
+
+    Gemini CLI / Claude Code
+        ↓ (automatic hook after each exchange)
+    ph log (stdin JSON)
+        ↓
+    SQLite (~/.prompt_history.db)
+        ↓
+    background analysis (Ollama gemma3:1b)
+        ↓
+    metadata: project, language, role, tags, relevance
+        ↓
+    ph browse / ph search / ph sessions
+
+    The main agent is completing the hook part — once finished you will have the completely automatic system without having to use ph as a wrapper.
+
+
+    ⏺ Everything is set. Summary of what has been done:
+
+  ---
+  Claude Code — Stop hook registered in ~/.claude/settings.json:
+  - Reads the session's JSONL transcript
+  - Extracts the last user prompt (those with promptId, not tool-result) and the last assistant response
+  - Calls ph log in the background (disown) → never blocks Claude
+
+  Gemini CLI — AfterAgent hook registered in ~/.gemini/settings.json:
+  - Directly receives the JSON payload containing prompt and prompt_response from Gemini CLI
+  - Extracts the user prompt and the assistant response
+  - Calls ph log in the background → never blocks Gemini
+
+  From this moment, every exchange in Claude Code or Gemini CLI is automatically saved in ph without the need to use it as a wrapper.

package/docs/ph-manual.md

@@ -0,0 +1,283 @@
+# ph — Prompt History CLI
+
+**Architecture, Hook System & Usage Guide**
+
+---
+
+## 1. Overview
+
+ph is a transparent capture layer for AI CLI tools such as Claude Code and Gemini CLI. Every prompt you type — and the AI response that follows — is automatically saved to a local SQLite database with full-text and semantic search, Git context, and optional background analysis.
+
+The core design principle is zero friction: ph never interrupts your workflow. Capture happens silently in the background. Your AI sessions remain unchanged.
+
+### Key Features
+
+- **Automatic Capture** — saves prompts, responses, and metadata without any manual action
+- **Git Context** — records current branch, modified files, and diff at capture time
+- **Full-text & Semantic Search** — FTS5 text search and vector-based semantic search (via Ollama embeddings)
+- **Background Analysis** — automatic role/tag/relevance classification via Ollama or Gemini
+- **Interactive TUI** — browse, filter, edit, re-run, and export your history with `ph browse`
+- **Privacy First** — all data stays local; no data ever leaves your machine
+
+---
+
+## 2. Architecture
+
+ph uses a two-tier storage model: a SQLite database with FTS5 full-text indexing for fast retrieval, and a JSON config file for runtime settings. Both live in your home directory by default.
+
+### Storage Layout
+
+| Item | Default Path | Description |
+|------|-------------|-------------|
+| Database | `~/.prompt_history.db` | SQLite with FTS5 + vector embeddings |
+| Config | `~/.ph_config.json` | JSON config file (0o600 permissions) |
+
+The database uses WAL (Write-Ahead Logging) mode, enabling concurrent reads and writes. This is essential for the background analysis system, which processes prompts asynchronously without blocking your terminal session.
+
+---
+
+## 3. The Hook System
+
+The hook system is ph's most powerful integration mechanism. Rather than requiring you to manually invoke ph for each session, hooks let the AI CLI tools themselves notify ph after every interaction — automatically, silently, and without any impact on response latency.
+
+> **Key insight:** Hooks are post-action handlers registered inside the AI tool's own config. ph never wraps or intercepts the AI process. The AI runs normally; the hook fires after the session ends.
+
+### How Hooks Work
+
+Each supported AI CLI tool exposes a native hook mechanism:
+
+- **Claude Code** — provides a `Stop` hook, triggered after each agent session completes
+- **Gemini CLI** — provides an `AfterAgent` hook, triggered after each agent turn
+
+When the hook fires, the AI tool passes a JSON payload on stdin to your registered script. The script reads that payload, extracts the prompt and response, and pipes the data to `ph log` — which persists everything to the local SQLite database.
+
+The entire operation runs in the background using shell job control (`& + disown`), so it never adds latency to your terminal session and never blocks the AI tool from exiting.
+
+---
+
+### Claude Code Hook
+
+#### How Claude Code delivers data
+
+When the `Stop` hook fires, Claude Code sends a JSON object on stdin:
+
+```json
+{
+  "session_id": "abc123...",
+  "transcript_path": "/path/to/session.jsonl"
+}
+```
+
+The transcript is a JSONL file — one JSON object per line — containing the full session history. Each line is one of:
+
+| Turn type | Identifier |
+|-----------|-----------|
+| Human turn | Has `promptId` key; `message.content` is a plain string |
+| Tool result | Has `toolUseResult` key; `message.content` is an array |
+| Assistant turn | `message.role == "assistant"`; content is an array of typed blocks |
+
+#### What the hook script does
+
+1. Reads the hook input from stdin to obtain the transcript path
+2. Uses `jq` with slurp mode to parse the entire JSONL in one pass
+3. Filters for genuine human turns: must have `promptId`, string content, and no `toolUseResult` key
+4. Extracts the last human turn as the prompt
+5. Scans assistant turns for the last `text`-type block as the response
+6. Builds a JSON payload with `tool`, `prompt`, `response`, and `workdir` fields
+7. Pipes the payload to `ph log` running in the background (`& + disown`)
+8. Exits `0` unconditionally — Claude Code is never blocked
+
+#### Hook installation — Claude Code
+
+```bash
+# Step 1: link the hook script
+ln -sf /path/to/ph/hooks/claude/ph-hook.sh ~/.claude/ph-hook.sh
+
+# Step 2: register in ~/.claude/settings.json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.claude/ph-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+---
+
+### Gemini CLI Hook
+
+#### How Gemini CLI delivers data
+
+Gemini CLI's `AfterAgent` hook is simpler: it delivers the prompt and response directly in the stdin payload, with no transcript file to parse:
+
+```json
+{
+  "session_id": "...",
+  "transcript_path": "...",
+  "cwd": "/path/to/workdir",
+  "hook_event_name": "AfterAgent",
+  "timestamp": "...",
+  "prompt": "the user's prompt text",
+  "prompt_response": "the assistant's full response text"
+}
+```
+
+#### What the hook script does
+
+1. Reads the JSON payload from stdin
+2. Extracts `prompt`, `prompt_response`, and `cwd` directly via `jq`
+3. Builds a JSON payload with `tool`, `prompt`, `response`, and `workdir` fields
+4. Pipes to `ph log` in the background
+5. Exits `0` unconditionally
+
+#### Hook installation — Gemini CLI
+
+```bash
+# Step 1: link the hook script
+ln -sf /path/to/ph/hooks/gemini/ph-hook.sh ~/.gemini/ph-hook.sh
+
+# Step 2: register in ~/.gemini/settings.json
+{
+  "hooks": {
+    "AfterAgent": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "~/.gemini/ph-hook.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+---
+
+### Hook Comparison
+
+| Aspect | Claude Code | Gemini CLI |
+|--------|------------|------------|
+| Hook name | `Stop` | `AfterAgent` |
+| Data delivery | `transcript_path` (JSONL file) | Direct JSON on stdin |
+| Prompt extraction | Parse JSONL with `jq` slurp | `jq .prompt` field |
+| Response extraction | Last assistant text block | `jq .prompt_response` field |
+| Async support | Yes (`async: true` in config) | Yes (`& + disown` in script) |
+| Blocks AI exit? | Never (exits `0`) | Never (exits `0`) |
+
+---
+
+## 4. Installation
+
+### From Source
+
+```bash
+git clone git@github.com:gi4nks/ph.git
+cd ph
+npm install
+make build
+make install    # installs the global 'ph' symlink
+```
+
+### Via npm
+
+```bash
+# Install globally:
+npm install -g @gi4nks/ph
+```
+
+### Initial Configuration
+
+```bash
+# Set your Gemini API key (optional — Ollama works without it)
+ph config set gemini-api-key "YOUR_KEY"
+
+# Choose your analysis provider
+ph config set analyze-provider ollama   # default, fully local
+# ph config set analyze-provider gemini  # cloud alternative
+
+# Enable background analysis
+ph config set background-analysis true
+
+# Optional: move the database to a custom location
+ph config set db-path "/path/to/your/custom.db"
+```
+
+---
+
+## 5. Usage
+
+### Search
+
+```bash
+# Full-text search
+ph search "how to refactor"
+
+# Semantic search (vector similarity)
+ph search --semantic "refactoring patterns"
+```
+
+### Interactive TUI
+
+```bash
+ph browse
+```
+
+Available hotkeys inside the TUI:
+
+| Key | Action |
+|-----|--------|
+| `f` | Open filters panel |
+| `e` | Edit prompt metadata (tags, notes) |
+| `r` | Re-run selected prompt in your AI tool |
+| `y` | Copy prompt to clipboard |
+| `x` | Delete prompt from history |
+
+### Export
+
+```bash
+# Export last 5 prompts as Markdown
+ph export --format md --limit 5 > prompts.md
+```
+
+### Database Maintenance
+
+```bash
+# Remove short or old prompts
+ph cleanup --min-length 20 --days 30
+
+# Compact the database
+ph vacuum
+
+# Dry-run to preview what would be removed
+ph cleanup --dry-run --days 60
+```
+
+---
+
+## 6. Why Prompt History Matters
+
+Every interaction with an AI tool is a unit of intellectual work. A well-crafted prompt encodes context, intent, and engineering decisions that took time to develop. Without capture, that work is lost the moment the session closes.
+
+ph treats your prompt history as a first-class artifact: searchable, annotated, versioned with Git context, and available for re-use. Over time, your history becomes a personal knowledge base of how you think and work with AI tools.
+
+> **The problem:** Manually saving prompts takes time, breaks flow, and rarely happens consistently. Without structure, even saved prompts become unsearchable noise.
+
+> **The solution:** ph captures everything automatically via hooks, indexes it locally, and gives you semantic search so you can find what you need — even if you only remember the intent, not the exact wording.
+
+---
+
+## Repository
+
+[https://github.com/gi4nks/ph](https://github.com/gi4nks/ph)

package/hooks/claude/README.md

@@ -0,0 +1,45 @@
+# Claude Code Hook for ph
+
+This hook allows Claude Code to automatically save every prompt and response to the `ph` database.
+
+## Installation
+
+1. Ensure `ph` is installed and working.
+2. Create a symbolic link of the script in Claude's configuration folder:
+
+```bash
+ln -sf "$(pwd)/ph-hook.sh" ~/.claude/ph-hook.sh
+chmod +x ~/.claude/ph-hook.sh
+```
+
+## Claude Code Configuration
+
+Add (or update) the `hooks` section in your `~/.claude/settings.json` file:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/gianluca/.claude/ph-hook.sh",
+            "async": true
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Note:** Ensure the path in the command correctly points to the symbolic link or the actual script. Using the symbolic link at `~/.claude/ph-hook.sh` keeps the configuration portable.
+
+## How it works
+
+The script is executed by Claude Code at the `Stop` event (end of an exchange).
+1. Reads the current session transcript.
+2. Extracts the last user prompt and the last assistant response.
+3. Sends the data to `ph log` in the background.

package/hooks/claude/ph-hook.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# ph-hook.sh — Claude Code Stop hook: logs the last prompt+response pair to ph
+#
+# Claude Code passes a JSON object on stdin with:
+#   { "session_id": "...", "transcript_path": "/path/to/session.jsonl" }
+#
+# The transcript is a JSONL file where each line is one of:
+#   - Human turn:    { "promptId": "...", "message": {"role":"user", "content": "string"}, "cwd": "...", ... }
+#   - Tool result:   { "toolUseResult": ..., "message": {"role":"user", "content": [...]}, ... }
+#   - Assistant turn: { "message": {"role":"assistant", "content": [{type,text},...] }, ... }
+#
+# This script:
+#   1. Reads the hook input to get transcript_path
+#   2. Uses jq to find the last genuine human-typed user message (has promptId, string content)
+#   3. Extracts the last assistant text block
+#   4. Pipes {"tool":"claude","prompt":"...","response":"...","workdir":"..."} to ph log
+#   5. Always exits 0 so Claude Code is never blocked
+
+set -uo pipefail
+
+# ── Read hook input ──────────────────────────────────────────────────────────
+HOOK_INPUT=$(cat)
+
+TRANSCRIPT_PATH=$(printf '%s' "$HOOK_INPUT" | jq -r '.transcript_path // empty')
+
+# Nothing to do if no transcript path provided
+if [[ -z "$TRANSCRIPT_PATH" ]] || [[ ! -f "$TRANSCRIPT_PATH" ]]; then
+  exit 0
+fi
+
+# ── Extract last user prompt using jq slurp ──────────────────────────────────
+# Filter for genuine human turns: has "promptId" AND message.content is a string
+# (tool result lines also have role:user but have "toolUseResult" key and array content)
+LAST_USER_JSON=$(
+  jq -Rs '
+    split("\n")
+    | map(select(length > 0))
+    | map(. as $line | try (. | fromjson) catch null)
+    | map(select(. != null))
+    | map(select(
+        has("promptId")
+        and has("message")
+        and (.message.role == "user")
+        and (.message.content | type == "string")
+        and (has("toolUseResult") | not)
+      ))
+    | last
+  ' "$TRANSCRIPT_PATH" 2>/dev/null
+)
+
+if [[ -z "$LAST_USER_JSON" ]] || [[ "$LAST_USER_JSON" == "null" ]]; then
+  exit 0
+fi
+
+LAST_USER_PROMPT=$(printf '%s' "$LAST_USER_JSON" | jq -r '.message.content // empty' 2>/dev/null)
+WORKDIR=$(printf '%s' "$LAST_USER_JSON" | jq -r '.cwd // empty' 2>/dev/null)
+
+# Skip if no user prompt found
+if [[ -z "$LAST_USER_PROMPT" ]]; then
+  exit 0
+fi
+
+if [[ -z "$WORKDIR" ]]; then
+  WORKDIR="$HOME"
+fi
+
+# ── Extract last assistant text response ─────────────────────────────────────
+# Assistant messages have message.content as an array of typed blocks.
+# We want the last "text" block across recent assistant messages.
+LAST_ASSISTANT_RESPONSE=$(
+  jq -Rs '
+    split("\n")
+    | map(select(length > 0))
+    | map(. as $line | try (. | fromjson) catch null)
+    | map(select(. != null))
+    | map(select(
+        has("message")
+        and (.message.role == "assistant")
+        and (.message.content | type == "array")
+      ))
+    | map(.message.content | map(select(.type == "text") | .text) | join(""))
+    | map(select(length > 0))
+    | last // ""
+  ' "$TRANSCRIPT_PATH" 2>/dev/null | jq -r '.' 2>/dev/null
+)
+
+# ── Call ph log ───────────────────────────────────────────────────────────────
+# Use jq to safely build the JSON payload (handles escaping automatically)
+JSON_PAYLOAD=$(
+  jq -n \
+    --arg tool "claude" \
+    --arg prompt "$LAST_USER_PROMPT" \
+    --arg response "${LAST_ASSISTANT_RESPONSE:-}" \
+    --arg workdir "$WORKDIR" \
+    '{"tool":$tool,"prompt":$prompt,"response":$response,"workdir":$workdir}'
+)
+
+# Run ph log in the background so it never blocks Claude Code's exit
+# Redirect all output to /dev/null to keep things silent
+printf '%s' "$JSON_PAYLOAD" | ph log >/dev/null 2>&1 &
+disown $! 2>/dev/null || true
+
+exit 0

package/hooks/gemini/README.md

@@ -0,0 +1,43 @@
+# Gemini CLI Hook for ph
+
+This hook allows Gemini CLI to automatically save every prompt and response to the `ph` database.
+
+## Installation
+
+1. Ensure `ph` is installed and working.
+2. Create a symbolic link of the script in Gemini's configuration folder:
+
+```bash
+ln -sf "$(pwd)/ph-hook.sh" ~/.gemini/ph-hook.sh
+chmod +x ~/.gemini/ph-hook.sh
+```
+
+## Gemini CLI Configuration
+
+Add (or update) the `hooks` section in your `~/.gemini/settings.json` file:
+
+```json
+{
+  "hooks": {
+    "AfterAgent": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/Users/gianluca/.gemini/ph-hook.sh"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+**Note:** Ensure the path in the command correctly points to the symbolic link or the actual script. Using the symbolic link at `~/.gemini/ph-hook.sh` keeps the configuration portable.
+
+## How it works
+
+The script is executed by Gemini CLI at the `AfterAgent` event (after each agent response).
+1. Receives the JSON input from Gemini CLI containing the prompt and response.
+2. Extracts the user prompt and the assistant response.
+3. Sends the data to `ph log` in the background.

package/hooks/gemini/ph-hook.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# ph-hook.sh — Gemini CLI AfterAgent hook: logs the last prompt+response pair to ph
+#
+# Gemini CLI sends a JSON object on stdin with:
+#   {
+#     "session_id": "...",
+#     "transcript_path": "...",
+#     "cwd": "/path/to/workdir",
+#     "hook_event_name": "AfterAgent",
+#     "timestamp": "...",
+#     "prompt": "the user's prompt text",
+#     "prompt_response": "the assistant's full response text"
+#   }
+#
+# This script:
+#   1. Reads the hook input JSON
+#   2. Extracts prompt, prompt_response, and cwd
+#   3. Pipes {"tool":"gemini","prompt":"...","response":"...","workdir":"..."} to ph log
+#   4. Always exits 0 so Gemini CLI is never blocked
+
+set -uo pipefail
+
+# ── Read hook input ──────────────────────────────────────────────────────────
+HOOK_INPUT=$(cat)
+
+PROMPT=$(printf '%s' "$HOOK_INPUT" | jq -r '.prompt // empty')
+RESPONSE=$(printf '%s' "$HOOK_INPUT" | jq -r '.prompt_response // empty')
+WORKDIR=$(printf '%s' "$HOOK_INPUT" | jq -r '.cwd // empty')
+
+# Nothing to do if no prompt
+if [[ -z "$PROMPT" ]]; then
+  exit 0
+fi
+
+# Fallback workdir
+if [[ -z "$WORKDIR" ]]; then
+  WORKDIR="$HOME"
+fi
+
+# ── Call ph log ───────────────────────────────────────────────────────────────
+# Use jq to safely build the JSON payload (handles escaping automatically)
+JSON_PAYLOAD=$(
+  jq -n \
+    --arg tool "gemini" \
+    --arg prompt "$PROMPT" \
+    --arg response "${RESPONSE:-}" \
+    --arg workdir "$WORKDIR" \
+    '{"tool":$tool,"prompt":$prompt,"response":$response,"workdir":$workdir}'
+)
+
+# Run ph log in the background so it never blocks Gemini CLI
+# Redirect all output to /dev/null to keep things silent
+printf '%s' "$JSON_PAYLOAD" | ph log >/dev/null 2>&1 &
+disown $! 2>/dev/null || true
+
+exit 0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@gi4nks/ph",
+  "version": "1.3.2",
+  "description": "Transparent CLI wrapper that captures and indexes AI prompts",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "ph": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "docs",
+    "CHANGELOG.md",
+    "hooks"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gi4nks/ph.git"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "start": "node dist/cli.js",
+    "test": "vitest run",
+    "lint": "eslint src",
+    "release:patch": "standard-version --release-as patch",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major"
+  },
+  "dependencies": {
+    "@gi4nks/ink": "^1.5.0",
+    "@lydell/node-pty": "^1.2.0-beta.3",
+    "better-sqlite3": "^12.8.0",
+    "ink": "^6.8.0",
+    "react": "^19.2.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.5.0",
+    "@types/react": "^19.2.14",
+    "@typescript-eslint/eslint-plugin": "^8.57.2",
+    "@typescript-eslint/parser": "^8.57.2",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "standard-version": "^9.5.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  }
+}