@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/.claude/commands/test-routing.md

@@ -1,362 +0,0 @@
----
-model: haiku
-description: Test RTK command routing without execution (dry-run) - verifies which commands have filters
----
-
-# /test-routing
-
-Vérifie le routing de commandes RTK sans exécution (dry-run). Utile pour tester si une commande a un filtre disponible avant de l'exécuter.
-
-## Usage
-
-```
-/test-routing <command> [args...]
-```
-
-## Exemples
-
-```bash
-/test-routing git status
-# Output: ✅ RTK filter available: git status → rtk git status
-
-/test-routing npm install
-# Output: ⚠️  No RTK filter, would execute raw: npm install
-
-/test-routing cargo test
-# Output: ✅ RTK filter available: cargo test → rtk cargo test
-```
-
-## Quand utiliser
-
-- **Avant d'exécuter une commande**: Vérifier si RTK a un filtre
-- **Debugging hook integration**: Tester le command routing sans side-effects
-- **Documentation**: Identifier quelles commandes RTK supporte
-- **Testing**: Valider routing logic sans exécuter de vraies commandes
-
-## Implémentation
-
-### Option 1: Check RTK Help Output
-
-```bash
-COMMAND="$1"
-shift
-ARGS="$@"
-
-# Check if RTK has subcommand for this command
-if rtk --help | grep -E "^  $COMMAND" >/dev/null 2>&1; then
-    echo "✅ RTK filter available: $COMMAND $ARGS → rtk $COMMAND $ARGS"
-    echo ""
-    echo "Expected behavior:"
-    echo "  - Command will be filtered through RTK"
-    echo "  - Output condensed for token efficiency"
-    echo "  - Exit code preserved from original command"
-else
-    echo "⚠️  No RTK filter available, would execute raw: $COMMAND $ARGS"
-    echo ""
-    echo "Expected behavior:"
-    echo "  - Command executed without RTK filtering"
-    echo "  - Full command output (no token savings)"
-    echo "  - Original command behavior unchanged"
-fi
-```
-
-### Option 2: Check RTK Source Code
-
-```bash
-COMMAND="$1"
-shift
-ARGS="$@"
-
-# List of supported RTK commands (from src/main.rs)
-RTK_COMMANDS=(
-    "git"
-    "grep"
-    "ls"
-    "read"
-    "err"
-    "test"
-    "log"
-    "json"
-    "lint"
-    "tsc"
-    "next"
-    "prettier"
-    "playwright"
-    "prisma"
-    "gh"
-    "vitest"
-    "pnpm"
-    "ruff"
-    "pytest"
-    "pip"
-    "go"
-    "golangci-lint"
-    "docker"
-    "cargo"
-    "smart"
-    "summary"
-    "diff"
-    "env"
-    "discover"
-    "gain"
-    "proxy"
-)
-
-# Check if command in supported list
-if [[ " ${RTK_COMMANDS[@]} " =~ " ${COMMAND} " ]]; then
-    echo "✅ RTK filter available: $COMMAND $ARGS → rtk $COMMAND $ARGS"
-    echo ""
-
-    # Show filter details if available
-    case "$COMMAND" in
-        git)
-            echo "Filter: git operations (status, log, diff, etc.)"
-            echo "Token savings: 60-80% depending on subcommand"
-            ;;
-        cargo)
-            echo "Filter: cargo build/test/clippy output"
-            echo "Token savings: 80-90% (failures only for tests)"
-            ;;
-        gh)
-            echo "Filter: GitHub CLI (pr, issue, run)"
-            echo "Token savings: 26-87% depending on subcommand"
-            ;;
-        pnpm)
-            echo "Filter: pnpm package manager"
-            echo "Token savings: 70-90% (dependency trees)"
-            ;;
-        *)
-            echo "Filter: Available for $COMMAND"
-            echo "Token savings: 60-90% (typical)"
-            ;;
-    esac
-else
-    echo "⚠️  No RTK filter available, would execute raw: $COMMAND $ARGS"
-    echo ""
-    echo "Note: You can still use 'rtk proxy $COMMAND $ARGS' to:"
-    echo "  - Execute command without filtering"
-    echo "  - Track usage in 'rtk gain --history'"
-    echo "  - Measure potential for new filter development"
-fi
-```
-
-### Option 3: Interactive Mode
-
-```bash
-COMMAND="$1"
-shift
-ARGS="$@"
-
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "🧪 RTK Command Routing Test"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo ""
-echo "Command: $COMMAND $ARGS"
-echo ""
-
-# Check if RTK installed
-if ! command -v rtk >/dev/null 2>&1; then
-    echo "❌ ERROR: RTK not installed"
-    echo "   Install with: cargo install --path ."
-    exit 1
-fi
-
-# Check RTK version
-RTK_VERSION=$(rtk --version 2>/dev/null | awk '{print $2}')
-echo "RTK Version: $RTK_VERSION"
-echo ""
-
-# Check if command has filter
-if rtk --help | grep -E "^  $COMMAND" >/dev/null 2>&1; then
-    echo "✅ Filter: Available"
-    echo ""
-    echo "Routing:"
-    echo "  Input:  $COMMAND $ARGS"
-    echo "  Route:  rtk $COMMAND $ARGS"
-    echo "  Filter: Applied"
-    echo ""
-
-    # Estimate token savings (based on historical data)
-    case "$COMMAND" in
-        git)
-            echo "Expected Token Savings: 60-80%"
-            echo "Startup Time: <10ms"
-            ;;
-        cargo)
-            echo "Expected Token Savings: 80-90%"
-            echo "Startup Time: <10ms"
-            ;;
-        gh)
-            echo "Expected Token Savings: 26-87%"
-            echo "Startup Time: <10ms"
-            ;;
-        *)
-            echo "Expected Token Savings: 60-90%"
-            echo "Startup Time: <10ms"
-            ;;
-    esac
-else
-    echo "⚠️  Filter: Not available"
-    echo ""
-    echo "Routing:"
-    echo "  Input:  $COMMAND $ARGS"
-    echo "  Route:  $COMMAND $ARGS (raw, no RTK)"
-    echo "  Filter: None"
-    echo ""
-    echo "Alternatives:"
-    echo "  - Use 'rtk proxy $COMMAND $ARGS' to track usage"
-    echo "  - Consider contributing a filter for this command"
-fi
-
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-```
-
-## Expected Output
-
-### Cas 1: Commande avec filtre
-
-```bash
-/test-routing git status
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🧪 RTK Command Routing Test
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Command: git status
-
-RTK Version: 0.16.0
-
-✅ Filter: Available
-
-Routing:
-  Input:  git status
-  Route:  rtk git status
-  Filter: Applied
-
-Expected Token Savings: 60-80%
-Startup Time: <10ms
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### Cas 2: Commande sans filtre
-
-```bash
-/test-routing npm install express
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🧪 RTK Command Routing Test
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Command: npm install express
-
-RTK Version: 0.16.0
-
-⚠️  Filter: Not available
-
-Routing:
-  Input:  npm install express
-  Route:  npm install express (raw, no RTK)
-  Filter: None
-
-Alternatives:
-  - Use 'rtk proxy npm install express' to track usage
-  - Consider contributing a filter for this command
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-### Cas 3: RTK non installé
-
-```bash
-/test-routing cargo test
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🧪 RTK Command Routing Test
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Command: cargo test
-
-❌ ERROR: RTK not installed
-   Install with: cargo install --path .
-```
-
-## Use Cases
-
-### Use Case 1: Pre-Flight Check
-
-Avant d'exécuter une commande coûteuse, vérifier si RTK a un filtre :
-
-```bash
-/test-routing cargo build --all-targets
-# ✅ Filter available → use rtk cargo build
-# ⚠️  No filter → use raw cargo build
-```
-
-### Use Case 2: Hook Debugging
-
-Tester le hook integration sans side-effects :
-
-```bash
-# Test several commands
-/test-routing git log -10
-/test-routing gh pr view 123
-/test-routing docker ps
-
-# Verify routing logic works for all
-```
-
-### Use Case 3: Documentation
-
-Générer liste de commandes supportées :
-
-```bash
-# Test all common commands
-for cmd in git cargo gh pnpm docker npm yarn; do
-    /test-routing $cmd
-done
-
-# Output shows which have filters
-```
-
-### Use Case 4: Contributing New Filter
-
-Identifier commandes sans filtre qui pourraient bénéficier :
-
-```bash
-/test-routing pytest
-# ⚠️  No filter
-
-# Consider contributing pytest filter
-# Expected savings: 90% (failures only)
-# Complexity: Medium (JSON output parsing)
-```
-
-## Integration avec Claude Code
-
-Dans Claude Code, cette command permet de :
-
-1. **Vérifier hook integration** : Test si hooks rewrites commands correctement
-2. **Debugging** : Identifier pourquoi certaines commandes ne sont pas filtrées
-3. **Documentation** : Montrer à l'utilisateur quelles commandes RTK supporte
-
-**Exemple workflow** :
-
-```
-User: "Is git status supported by RTK?"
-Assistant: "Let me check with /test-routing git status"
-[Runs command]
-Assistant: "Yes! RTK has a filter for git status with 60-80% token savings."
-```
-
-## Limitations
-
-- **Dry-run only** : Ne teste pas l'exécution réelle (pas de validation output)
-- **No side-effects** : Aucune commande n'est exécutée
-- **Routing check only** : Vérifie seulement la disponibilité du filtre, pas la qualité
-
-Pour tester le filtre complet, utiliser :
-```bash
-rtk <cmd>  # Exécution réelle avec filtre
-```

package/temp/rtk/.claude/hooks/bash/pre-commit-format.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-# Auto-format Rust code before commits
-# Hook: PreToolUse for git commit
-
-echo "🦀 Running Rust pre-commit checks..."
-
-# Format code
-cargo fmt --all
-
-# Check for compilation errors only (warnings allowed)
-if cargo clippy --all-targets 2>&1 | grep -q "error:"; then
-    echo "❌ Clippy found errors. Fix them before committing."
-    exit 1
-fi
-
-echo "✅ Pre-commit checks passed (warnings allowed)"

package/temp/rtk/.claude/hooks/rtk-rewrite.sh

@@ -1,70 +0,0 @@
-#!/bin/bash
-# RTK auto-rewrite hook for Claude Code PreToolUse:Bash
-# Transparently rewrites raw commands to their RTK equivalents.
-# Uses `rtk rewrite` as single source of truth — no duplicate mapping logic here.
-#
-# To add support for new commands, update src/discover/registry.rs (PATTERNS + RULES).
-
-# --- Audit logging (opt-in via RTK_HOOK_AUDIT=1) ---
-_rtk_audit_log() {
-  if [ "${RTK_HOOK_AUDIT:-0}" != "1" ]; then return; fi
-  local action="$1" original="$2" rewritten="${3:--}"
-  local dir="${RTK_AUDIT_DIR:-${HOME}/.local/share/rtk}"
-  mkdir -p "$dir"
-  printf '%s | %s | %s | %s\n' \
-    "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$action" "$original" "$rewritten" \
-    >> "${dir}/hook-audit.log"
-}
-
-# Guards: skip silently if dependencies missing
-if ! command -v rtk &>/dev/null || ! command -v jq &>/dev/null; then
-  _rtk_audit_log "skip:no_deps" "-"
-  exit 0
-fi
-
-set -euo pipefail
-
-INPUT=$(cat)
-CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
-
-if [ -z "$CMD" ]; then
-  _rtk_audit_log "skip:empty" "-"
-  exit 0
-fi
-
-# Skip heredocs (rtk rewrite also skips them, but bail early)
-case "$CMD" in
-  *'<<'*) _rtk_audit_log "skip:heredoc" "$CMD"; exit 0 ;;
-esac
-
-# Rewrite via rtk — single source of truth for all command mappings.
-# Exit 1 = no RTK equivalent, pass through unchanged.
-# Exit 0 = rewritten command (or already RTK, identical output).
-REWRITTEN=$(rtk rewrite "$CMD" 2>/dev/null) || {
-  _rtk_audit_log "skip:no_match" "$CMD"
-  exit 0
-}
-
-# If output is identical, command was already using RTK — nothing to do.
-if [ "$CMD" = "$REWRITTEN" ]; then
-  _rtk_audit_log "skip:already_rtk" "$CMD"
-  exit 0
-fi
-
-_rtk_audit_log "rewrite" "$CMD" "$REWRITTEN"
-
-# Build the updated tool_input with all original fields preserved, only command changed.
-ORIGINAL_INPUT=$(echo "$INPUT" | jq -c '.tool_input')
-UPDATED_INPUT=$(echo "$ORIGINAL_INPUT" | jq --arg cmd "$REWRITTEN" '.command = $cmd')
-
-# Output the rewrite instruction in Claude Code hook format.
-jq -n \
-  --argjson updated "$UPDATED_INPUT" \
-  '{
-    "hookSpecificOutput": {
-      "hookEventName": "PreToolUse",
-      "permissionDecision": "allow",
-      "permissionDecisionReason": "RTK auto-rewrite",
-      "updatedInput": $updated
-    }
-  }'

package/temp/rtk/.claude/hooks/rtk-suggest.sh

@@ -1,152 +0,0 @@
-#!/bin/bash
-# RTK suggest hook for Claude Code PreToolUse:Bash
-# Emits system reminders when rtk-compatible commands are detected.
-# Outputs JSON with systemMessage to inform Claude Code without modifying execution.
-
-set -euo pipefail
-
-INPUT=$(cat)
-CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty')
-
-if [ -z "$CMD" ]; then
-  exit 0
-fi
-
-# Extract the first meaningful command (before pipes, &&, etc.)
-FIRST_CMD="$CMD"
-
-# Skip if already using rtk
-case "$FIRST_CMD" in
-  rtk\ *|*/rtk\ *) exit 0 ;;
-esac
-
-# Skip commands with heredocs, variable assignments, etc.
-case "$FIRST_CMD" in
-  *'<<'*) exit 0 ;;
-esac
-
-SUGGESTION=""
-
-# --- Git commands ---
-if echo "$FIRST_CMD" | grep -qE '^git\s+status(\s|$)'; then
-  SUGGESTION="rtk git status"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+diff(\s|$)'; then
-  SUGGESTION="rtk git diff"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+log(\s|$)'; then
-  SUGGESTION="rtk git log"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+add(\s|$)'; then
-  SUGGESTION="rtk git add"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+commit(\s|$)'; then
-  SUGGESTION="rtk git commit"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+push(\s|$)'; then
-  SUGGESTION="rtk git push"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+pull(\s|$)'; then
-  SUGGESTION="rtk git pull"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+branch(\s|$)'; then
-  SUGGESTION="rtk git branch"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+fetch(\s|$)'; then
-  SUGGESTION="rtk git fetch"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+stash(\s|$)'; then
-  SUGGESTION="rtk git stash"
-elif echo "$FIRST_CMD" | grep -qE '^git\s+show(\s|$)'; then
-  SUGGESTION="rtk git show"
-
-# --- GitHub CLI ---
-elif echo "$FIRST_CMD" | grep -qE '^gh\s+(pr|issue|run)(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^gh /rtk gh /')
-
-# --- Cargo ---
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+test(\s|$)'; then
-  SUGGESTION="rtk cargo test"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+build(\s|$)'; then
-  SUGGESTION="rtk cargo build"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+clippy(\s|$)'; then
-  SUGGESTION="rtk cargo clippy"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+check(\s|$)'; then
-  SUGGESTION="rtk cargo check"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+install(\s|$)'; then
-  SUGGESTION="rtk cargo install"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+nextest(\s|$)'; then
-  SUGGESTION="rtk cargo nextest"
-elif echo "$FIRST_CMD" | grep -qE '^cargo\s+fmt(\s|$)'; then
-  SUGGESTION="rtk cargo fmt"
-
-# --- File operations ---
-elif echo "$FIRST_CMD" | grep -qE '^cat\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^cat /rtk read /')
-elif echo "$FIRST_CMD" | grep -qE '^(rg|grep)\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed -E 's/^(rg|grep) /rtk grep /')
-elif echo "$FIRST_CMD" | grep -qE '^ls(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^ls/rtk ls/')
-elif echo "$FIRST_CMD" | grep -qE '^tree(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^tree/rtk tree/')
-elif echo "$FIRST_CMD" | grep -qE '^find\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^find /rtk find /')
-elif echo "$FIRST_CMD" | grep -qE '^diff\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^diff /rtk diff /')
-elif echo "$FIRST_CMD" | grep -qE '^head\s+'; then
-  # Suggest rtk read with --max-lines transformation
-  if echo "$FIRST_CMD" | grep -qE '^head\s+-[0-9]+\s+'; then
-    LINES=$(echo "$FIRST_CMD" | sed -E 's/^head +-([0-9]+) +.+$/\1/')
-    FILE=$(echo "$FIRST_CMD" | sed -E 's/^head +-[0-9]+ +(.+)$/\1/')
-    SUGGESTION="rtk read $FILE --max-lines $LINES"
-  elif echo "$FIRST_CMD" | grep -qE '^head\s+--lines=[0-9]+\s+'; then
-    LINES=$(echo "$FIRST_CMD" | sed -E 's/^head +--lines=([0-9]+) +.+$/\1/')
-    FILE=$(echo "$FIRST_CMD" | sed -E 's/^head +--lines=[0-9]+ +(.+)$/\1/')
-    SUGGESTION="rtk read $FILE --max-lines $LINES"
-  fi
-
-# --- JS/TS tooling ---
-elif echo "$FIRST_CMD" | grep -qE '^(pnpm\s+)?vitest(\s|$)'; then
-  SUGGESTION="rtk vitest run"
-elif echo "$FIRST_CMD" | grep -qE '^pnpm\s+test(\s|$)'; then
-  SUGGESTION="rtk vitest run"
-elif echo "$FIRST_CMD" | grep -qE '^pnpm\s+tsc(\s|$)'; then
-  SUGGESTION="rtk tsc"
-elif echo "$FIRST_CMD" | grep -qE '^(npx\s+)?tsc(\s|$)'; then
-  SUGGESTION="rtk tsc"
-elif echo "$FIRST_CMD" | grep -qE '^pnpm\s+lint(\s|$)'; then
-  SUGGESTION="rtk lint"
-elif echo "$FIRST_CMD" | grep -qE '^(npx\s+)?eslint(\s|$)'; then
-  SUGGESTION="rtk lint"
-elif echo "$FIRST_CMD" | grep -qE '^(npx\s+)?prettier(\s|$)'; then
-  SUGGESTION="rtk prettier"
-elif echo "$FIRST_CMD" | grep -qE '^(npx\s+)?playwright(\s|$)'; then
-  SUGGESTION="rtk playwright"
-elif echo "$FIRST_CMD" | grep -qE '^pnpm\s+playwright(\s|$)'; then
-  SUGGESTION="rtk playwright"
-elif echo "$FIRST_CMD" | grep -qE '^(npx\s+)?prisma(\s|$)'; then
-  SUGGESTION="rtk prisma"
-
-# --- Containers ---
-elif echo "$FIRST_CMD" | grep -qE '^docker\s+(ps|images|logs)(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^docker /rtk docker /')
-elif echo "$FIRST_CMD" | grep -qE '^kubectl\s+(get|logs)(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^kubectl /rtk kubectl /')
-
-# --- Network ---
-elif echo "$FIRST_CMD" | grep -qE '^curl\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^curl /rtk curl /')
-elif echo "$FIRST_CMD" | grep -qE '^wget\s+'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^wget /rtk wget /')
-
-# --- pnpm package management ---
-elif echo "$FIRST_CMD" | grep -qE '^pnpm\s+(list|ls|outdated)(\s|$)'; then
-  SUGGESTION=$(echo "$CMD" | sed 's/^pnpm /rtk pnpm /')
-fi
-
-# If no suggestion, allow command as-is
-if [ -z "$SUGGESTION" ]; then
-  exit 0
-fi
-
-# Output suggestion as system message
-jq -n \
-  --arg suggestion "$SUGGESTION" \
-  '{
-    "hookSpecificOutput": {
-      "hookEventName": "PreToolUse",
-      "permissionDecision": "allow",
-      "systemMessage": ("⚡ RTK available: `" + $suggestion + "` (60-90% token savings)")
-    }
-  }'