xtrm-tools 2.0.0

package/skills/hook-development/scripts/test-hook.sh

@@ -0,0 +1,252 @@
+#!/bin/bash
+# Hook Testing Helper
+# Tests a hook with sample input and shows output
+
+set -euo pipefail
+
+# Usage
+show_usage() {
+  echo "Usage: $0 [options] <hook-script> <test-input.json>"
+  echo ""
+  echo "Options:"
+  echo "  -h, --help      Show this help message"
+  echo "  -v, --verbose   Show detailed execution information"
+  echo "  -t, --timeout N Set timeout in seconds (default: 60)"
+  echo ""
+  echo "Examples:"
+  echo "  $0 validate-bash.sh test-input.json"
+  echo "  $0 -v -t 30 validate-write.sh write-input.json"
+  echo ""
+  echo "Creates sample test input with:"
+  echo "  $0 --create-sample <event-type>"
+  exit 0
+}
+
+# Create sample input
+create_sample() {
+  event_type="$1"
+
+  case "$event_type" in
+    PreToolUse)
+      cat <<'EOF'
+{
+  "session_id": "test-session",
+  "transcript_path": "/tmp/transcript.txt",
+  "cwd": "/tmp/test-project",
+  "permission_mode": "ask",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Write",
+  "tool_input": {
+    "file_path": "/tmp/test.txt",
+    "content": "Test content"
+  }
+}
+EOF
+      ;;
+    PostToolUse)
+      cat <<'EOF'
+{
+  "session_id": "test-session",
+  "transcript_path": "/tmp/transcript.txt",
+  "cwd": "/tmp/test-project",
+  "permission_mode": "ask",
+  "hook_event_name": "PostToolUse",
+  "tool_name": "Bash",
+  "tool_result": "Command executed successfully"
+}
+EOF
+      ;;
+    Stop|SubagentStop)
+      cat <<'EOF'
+{
+  "session_id": "test-session",
+  "transcript_path": "/tmp/transcript.txt",
+  "cwd": "/tmp/test-project",
+  "permission_mode": "ask",
+  "hook_event_name": "Stop",
+  "reason": "Task appears complete"
+}
+EOF
+      ;;
+    UserPromptSubmit)
+      cat <<'EOF'
+{
+  "session_id": "test-session",
+  "transcript_path": "/tmp/transcript.txt",
+  "cwd": "/tmp/test-project",
+  "permission_mode": "ask",
+  "hook_event_name": "UserPromptSubmit",
+  "user_prompt": "Test user prompt"
+}
+EOF
+      ;;
+    SessionStart|SessionEnd)
+      cat <<'EOF'
+{
+  "session_id": "test-session",
+  "transcript_path": "/tmp/transcript.txt",
+  "cwd": "/tmp/test-project",
+  "permission_mode": "ask",
+  "hook_event_name": "SessionStart"
+}
+EOF
+      ;;
+    *)
+      echo "Unknown event type: $event_type"
+      echo "Valid types: PreToolUse, PostToolUse, Stop, SubagentStop, UserPromptSubmit, SessionStart, SessionEnd"
+      exit 1
+      ;;
+  esac
+}
+
+# Parse arguments
+VERBOSE=false
+TIMEOUT=60
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -h|--help)
+      show_usage
+      ;;
+    -v|--verbose)
+      VERBOSE=true
+      shift
+      ;;
+    -t|--timeout)
+      TIMEOUT="$2"
+      shift 2
+      ;;
+    --create-sample)
+      create_sample "$2"
+      exit 0
+      ;;
+    *)
+      break
+      ;;
+  esac
+done
+
+if [ $# -ne 2 ]; then
+  echo "Error: Missing required arguments"
+  echo ""
+  show_usage
+fi
+
+HOOK_SCRIPT="$1"
+TEST_INPUT="$2"
+
+# Validate inputs
+if [ ! -f "$HOOK_SCRIPT" ]; then
+  echo "❌ Error: Hook script not found: $HOOK_SCRIPT"
+  exit 1
+fi
+
+if [ ! -x "$HOOK_SCRIPT" ]; then
+  echo "⚠️  Warning: Hook script is not executable. Attempting to run with bash..."
+  HOOK_SCRIPT="bash $HOOK_SCRIPT"
+fi
+
+if [ ! -f "$TEST_INPUT" ]; then
+  echo "❌ Error: Test input not found: $TEST_INPUT"
+  exit 1
+fi
+
+# Validate test input JSON
+if ! jq empty "$TEST_INPUT" 2>/dev/null; then
+  echo "❌ Error: Test input is not valid JSON"
+  exit 1
+fi
+
+echo "🧪 Testing hook: $HOOK_SCRIPT"
+echo "📥 Input: $TEST_INPUT"
+echo ""
+
+if [ "$VERBOSE" = true ]; then
+  echo "Input JSON:"
+  jq . "$TEST_INPUT"
+  echo ""
+fi
+
+# Set up environment
+export CLAUDE_PROJECT_DIR="${CLAUDE_PROJECT_DIR:-/tmp/test-project}"
+export CLAUDE_PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(pwd)}"
+export CLAUDE_ENV_FILE="${CLAUDE_ENV_FILE:-/tmp/test-env-$$}"
+
+if [ "$VERBOSE" = true ]; then
+  echo "Environment:"
+  echo "  CLAUDE_PROJECT_DIR=$CLAUDE_PROJECT_DIR"
+  echo "  CLAUDE_PLUGIN_ROOT=$CLAUDE_PLUGIN_ROOT"
+  echo "  CLAUDE_ENV_FILE=$CLAUDE_ENV_FILE"
+  echo ""
+fi
+
+# Run the hook
+echo "▶️  Running hook (timeout: ${TIMEOUT}s)..."
+echo ""
+
+start_time=$(date +%s)
+
+set +e
+output=$(timeout "$TIMEOUT" bash -c "cat '$TEST_INPUT' | $HOOK_SCRIPT" 2>&1)
+exit_code=$?
+set -e
+
+end_time=$(date +%s)
+duration=$((end_time - start_time))
+
+# Analyze results
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Results:"
+echo ""
+echo "Exit Code: $exit_code"
+echo "Duration: ${duration}s"
+echo ""
+
+case $exit_code in
+  0)
+    echo "✅ Hook approved/succeeded"
+    ;;
+  2)
+    echo "🚫 Hook blocked/denied"
+    ;;
+  124)
+    echo "⏱️  Hook timed out after ${TIMEOUT}s"
+    ;;
+  *)
+    echo "⚠️  Hook returned unexpected exit code: $exit_code"
+    ;;
+esac
+
+echo ""
+echo "Output:"
+if [ -n "$output" ]; then
+  echo "$output"
+  echo ""
+
+  # Try to parse as JSON
+  if echo "$output" | jq empty 2>/dev/null; then
+    echo "Parsed JSON output:"
+    echo "$output" | jq .
+  fi
+else
+  echo "(no output)"
+fi
+
+# Check for environment file
+if [ -f "$CLAUDE_ENV_FILE" ]; then
+  echo ""
+  echo "Environment file created:"
+  cat "$CLAUDE_ENV_FILE"
+  rm -f "$CLAUDE_ENV_FILE"
+fi
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+if [ $exit_code -eq 0 ] || [ $exit_code -eq 2 ]; then
+  echo "✅ Test completed successfully"
+  exit 0
+else
+  echo "❌ Test failed"
+  exit 1
+fi

package/skills/hook-development/scripts/validate-hook-schema.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+# Hook Schema Validator
+# Validates hooks.json structure and checks for common issues
+
+set -euo pipefail
+
+# Usage
+if [ $# -eq 0 ]; then
+  echo "Usage: $0 <path/to/hooks.json>"
+  echo ""
+  echo "Validates hook configuration file for:"
+  echo "  - Valid JSON syntax"
+  echo "  - Required fields"
+  echo "  - Hook type validity"
+  echo "  - Matcher patterns"
+  echo "  - Timeout ranges"
+  exit 1
+fi
+
+HOOKS_FILE="$1"
+
+if [ ! -f "$HOOKS_FILE" ]; then
+  echo "❌ Error: File not found: $HOOKS_FILE"
+  exit 1
+fi
+
+echo "🔍 Validating hooks configuration: $HOOKS_FILE"
+echo ""
+
+# Check 1: Valid JSON
+echo "Checking JSON syntax..."
+if ! jq empty "$HOOKS_FILE" 2>/dev/null; then
+  echo "❌ Invalid JSON syntax"
+  exit 1
+fi
+echo "✅ Valid JSON"
+
+# Check 2: Root structure
+echo ""
+echo "Checking root structure..."
+VALID_EVENTS=("PreToolUse" "PostToolUse" "UserPromptSubmit" "Stop" "SubagentStop" "SessionStart" "SessionEnd" "PreCompact" "Notification")
+
+for event in $(jq -r 'keys[]' "$HOOKS_FILE"); do
+  found=false
+  for valid_event in "${VALID_EVENTS[@]}"; do
+    if [ "$event" = "$valid_event" ]; then
+      found=true
+      break
+    fi
+  done
+
+  if [ "$found" = false ]; then
+    echo "⚠️  Unknown event type: $event"
+  fi
+done
+echo "✅ Root structure valid"
+
+# Check 3: Validate each hook
+echo ""
+echo "Validating individual hooks..."
+
+error_count=0
+warning_count=0
+
+for event in $(jq -r 'keys[]' "$HOOKS_FILE"); do
+  hook_count=$(jq -r ".\"$event\" | length" "$HOOKS_FILE")
+
+  for ((i=0; i<hook_count; i++)); do
+    # Check matcher exists
+    matcher=$(jq -r ".\"$event\"[$i].matcher // empty" "$HOOKS_FILE")
+    if [ -z "$matcher" ]; then
+      echo "❌ $event[$i]: Missing 'matcher' field"
+      ((error_count++))
+      continue
+    fi
+
+    # Check hooks array exists
+    hooks=$(jq -r ".\"$event\"[$i].hooks // empty" "$HOOKS_FILE")
+    if [ -z "$hooks" ] || [ "$hooks" = "null" ]; then
+      echo "❌ $event[$i]: Missing 'hooks' array"
+      ((error_count++))
+      continue
+    fi
+
+    # Validate each hook in the array
+    hook_array_count=$(jq -r ".\"$event\"[$i].hooks | length" "$HOOKS_FILE")
+
+    for ((j=0; j<hook_array_count; j++)); do
+      hook_type=$(jq -r ".\"$event\"[$i].hooks[$j].type // empty" "$HOOKS_FILE")
+
+      if [ -z "$hook_type" ]; then
+        echo "❌ $event[$i].hooks[$j]: Missing 'type' field"
+        ((error_count++))
+        continue
+      fi
+
+      if [ "$hook_type" != "command" ] && [ "$hook_type" != "prompt" ]; then
+        echo "❌ $event[$i].hooks[$j]: Invalid type '$hook_type' (must be 'command' or 'prompt')"
+        ((error_count++))
+        continue
+      fi
+
+      # Check type-specific fields
+      if [ "$hook_type" = "command" ]; then
+        command=$(jq -r ".\"$event\"[$i].hooks[$j].command // empty" "$HOOKS_FILE")
+        if [ -z "$command" ]; then
+          echo "❌ $event[$i].hooks[$j]: Command hooks must have 'command' field"
+          ((error_count++))
+        else
+          # Check for hardcoded paths
+          if [[ "$command" == /* ]] && [[ "$command" != *'${CLAUDE_PLUGIN_ROOT}'* ]]; then
+            echo "⚠️  $event[$i].hooks[$j]: Hardcoded absolute path detected. Consider using \${CLAUDE_PLUGIN_ROOT}"
+            ((warning_count++))
+          fi
+        fi
+      elif [ "$hook_type" = "prompt" ]; then
+        prompt=$(jq -r ".\"$event\"[$i].hooks[$j].prompt // empty" "$HOOKS_FILE")
+        if [ -z "$prompt" ]; then
+          echo "❌ $event[$i].hooks[$j]: Prompt hooks must have 'prompt' field"
+          ((error_count++))
+        fi
+
+        # Check if prompt-based hooks are used on supported events
+        if [ "$event" != "Stop" ] && [ "$event" != "SubagentStop" ] && [ "$event" != "UserPromptSubmit" ] && [ "$event" != "PreToolUse" ]; then
+          echo "⚠️  $event[$i].hooks[$j]: Prompt hooks may not be fully supported on $event (best on Stop, SubagentStop, UserPromptSubmit, PreToolUse)"
+          ((warning_count++))
+        fi
+      fi
+
+      # Check timeout
+      timeout=$(jq -r ".\"$event\"[$i].hooks[$j].timeout // empty" "$HOOKS_FILE")
+      if [ -n "$timeout" ] && [ "$timeout" != "null" ]; then
+        if ! [[ "$timeout" =~ ^[0-9]+$ ]]; then
+          echo "❌ $event[$i].hooks[$j]: Timeout must be a number"
+          ((error_count++))
+        elif [ "$timeout" -gt 600 ]; then
+          echo "⚠️  $event[$i].hooks[$j]: Timeout $timeout seconds is very high (max 600s)"
+          ((warning_count++))
+        elif [ "$timeout" -lt 5 ]; then
+          echo "⚠️  $event[$i].hooks[$j]: Timeout $timeout seconds is very low"
+          ((warning_count++))
+        fi
+      fi
+    done
+  done
+done
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+if [ $error_count -eq 0 ] && [ $warning_count -eq 0 ]; then
+  echo "✅ All checks passed!"
+  exit 0
+elif [ $error_count -eq 0 ]; then
+  echo "⚠️  Validation passed with $warning_count warning(s)"
+  exit 0
+else
+  echo "❌ Validation failed with $error_count error(s) and $warning_count warning(s)"
+  exit 1
+fi

package/skills/obsidian-cli/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: obsidian-cli
+description: Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to interact with their Obsidian vault, manage notes, search vault content, perform vault operations from the command line, or develop and debug Obsidian plugins and themes.
+---
+
+# Obsidian CLI
+
+Use the `obsidian` CLI to interact with a running Obsidian instance. Requires Obsidian to be open.
+
+## Command reference
+
+Run `obsidian help` to see all available commands. This is always up to date. Full docs: https://help.obsidian.md/cli
+
+## Syntax
+
+**Parameters** take a value with `=`. Quote values with spaces:
+
+```bash
+obsidian create name="My Note" content="Hello world"
+```
+
+**Flags** are boolean switches with no value:
+
+```bash
+obsidian create name="My Note" silent overwrite
+```
+
+For multiline content use `\n` for newline and `\t` for tab.
+
+## File targeting
+
+Many commands accept `file` or `path` to target a file. Without either, the active file is used.
+
+- `file=<name>` — resolves like a wikilink (name only, no path or extension needed)
+- `path=<path>` — exact path from vault root, e.g. `folder/note.md`
+
+## Vault targeting
+
+Commands target the most recently focused vault by default. Use `vault=<name>` as the first parameter to target a specific vault:
+
+```bash
+obsidian vault="My Vault" search query="test"
+```
+
+## Common patterns
+
+```bash
+obsidian read file="My Note"
+obsidian create name="New Note" content="# Hello" template="Template" silent
+obsidian append file="My Note" content="New line"
+obsidian search query="search term" limit=10
+obsidian daily:read
+obsidian daily:append content="- [ ] New task"
+obsidian property:set name="status" value="done" file="My Note"
+obsidian tasks daily todo
+obsidian tags sort=count counts
+obsidian backlinks file="My Note"
+```
+
+Use `--copy` on any command to copy output to clipboard. Use `silent` to prevent files from opening. Use `total` on list commands to get a count.
+
+## Plugin development
+
+### Develop/test cycle
+
+After making code changes to a plugin or theme, follow this workflow:
+
+1. **Reload** the plugin to pick up changes:
+   ```bash
+   obsidian plugin:reload id=my-plugin
+   ```
+2. **Check for errors** — if errors appear, fix and repeat from step 1:
+   ```bash
+   obsidian dev:errors
+   ```
+3. **Verify visually** with a screenshot or DOM inspection:
+   ```bash
+   obsidian dev:screenshot path=screenshot.png
+   obsidian dev:dom selector=".workspace-leaf" text
+   ```
+4. **Check console output** for warnings or unexpected logs:
+   ```bash
+   obsidian dev:console level=error
+   ```
+
+### Additional developer commands
+
+Run JavaScript in the app context:
+
+```bash
+obsidian eval code="app.vault.getFiles().length"
+```
+
+Inspect CSS values:
+
+```bash
+obsidian dev:css selector=".workspace-leaf" prop=background-color
+```
+
+Toggle mobile emulation:
+
+```bash
+obsidian dev:mobile on
+```
+
+Run `obsidian help` to see additional developer commands including CDP and debugger controls.

package/skills/orchestrating-agents/SKILL.md

@@ -0,0 +1,135 @@
+---
+name: orchestrating-agents
+description: Orchestrates task handoff and "handshaking" between Gemini and Qwen CLI agents. Facilitates specialized reviews, second opinions, and cross-validation of complex logic. Use when a task requires multi-model collaboration, a second LLM perspective, or iterative feedback between terminal agents.
+gemini-command: orchestrate
+gemini-args:
+  - name: workflow
+    description: "Orchestration workflow type"
+    type: choice
+    choices:
+      - value: collaborative
+        label: "Collaborative Design"
+        description: "Multi-turn design session for new features/architecture"
+      - value: adversarial
+        label: "Adversarial Review"
+        description: "Red-team security audit with attack/defense rounds"
+      - value: troubleshoot
+        label: "Troubleshoot Session"
+        description: "Deep debugging with hypothesis testing"
+      - value: handshake
+        label: "Single Handshake"
+        description: "Quick one-turn second opinion"
+    default: collaborative
+  - name: prompt
+    description: "Task description for orchestration"
+    type: string
+    required: true
+gemini-prompt: |
+  You are orchestrating a multi-agent collaboration workflow.
+
+  Workflow Type: {{workflow}}
+  Task: {{prompt}}
+
+  Steps:
+  1. Detect available neighbor agents (gemini, qwen)
+  2. Map workflow type to execution pattern:
+     - collaborative → Collaborative Design (3 turns)
+     - adversarial → Adversarial Review (3 turns)
+     - troubleshoot → Troubleshoot Session (4 turns)
+     - handshake → Single Handshake (1 turn)
+  3. Execute the turn protocol defined in references/workflows.md
+  4. Synthesize and present results
+---
+
+# Orchestrating Agents
+
+This skill provides a structured workflow for multi-model collaboration between Gemini and Qwen, enabling deep "handshaking" sessions for complex tasks.
+
+## Usage
+
+### Command-Line Invocation (Gemini)
+```bash
+# With workflow parameter (recommended)
+/orchestrate collaborative "Design authentication system with JWT"
+/orchestrate adversarial "Review payment processing security"
+/orchestrate troubleshoot "Debug production memory leak"
+/orchestrate handshake "Quick review of rate limiting logic"
+
+# Without parameter (interactive selection)
+/orchestrate "Design authentication system"
+```
+
+### Workflow Types
+
+| Workflow | Turns | Use Case |
+|----------|-------|----------|
+| **collaborative** | 3 | New features, architecture planning, design decisions |
+| **adversarial** | 3 | Security audits, vulnerability assessment, red-team review |
+| **troubleshoot** | 4 | Complex debugging, production errors, emergency fixes |
+| **handshake** | 1 | Quick second opinion, simple validation |
+
+## Interactive Selection (Fallback)
+
+If no workflow type is specified, the agent will prompt for selection:
+
+### For Gemini CLI (`ask_user`)
+```typescript
+ask_user({
+  questions: [{
+    question: "This task requires deep collaboration. Which orchestration workflow should we use?",
+    header: "Orchestrate",
+    options: [
+      { label: "Collaborative Design", description: "Agent A proposes -> Agent B critiques -> Agent A refines." },
+      { label: "Adversarial Review", description: "Agent A proposes -> Agent B attacks (Red Team) -> Agent A defends." },
+      { label: "Troubleshoot Session", description: "Multi-agent hypothesis testing for emergency bugs." },
+      { label: "Single Handshake", description: "Standard one-turn second opinion." }
+    ]
+  }]
+});
+```
+
+### For Claude Code (`AskUserQuestion`)
+```typescript
+AskUserQuestion({
+  questions: [{
+    question: "This task requires deep collaboration. Which orchestration workflow should we use?",
+    header: "Orchestrate",
+    options: [
+      { label: "Collaborative Design", description: "Agent A proposes -> Agent B critiques -> Agent A refines." },
+      { label: "Adversarial Review", description: "Agent A proposes -> Agent B attacks (Red Team) -> Agent A defends." },
+      { label: "Troubleshoot Session", description: "Multi-agent hypothesis testing for emergency bugs." },
+      { label: "Single Handshake", description: "Standard one-turn second opinion." }
+    ]
+  }]
+});
+```
+
+## Workflows
+
+### 1. Handshake Protocol (Standard)
+| Agent | Initial Command | Follow-up (Resume) |
+| :--- | :--- | :--- |
+| **Gemini** | `gemini -p "..."` | `gemini -r latest -p "..."` |
+| **Qwen** | `qwen "..."` | `qwen -c "..."` |
+
+### 2. Multi-Turn Loops
+For complex scenarios, follow the turns defined in [references/workflows.md](references/workflows.md).
+
+```
+Loop Progress:
+- [ ] Turn 1: Proposal (Agent A)
+- [ ] Turn 2: Cross-Examination (Agent B)
+- [ ] Turn 3: Final Synthesis (Agent A)
+```
+
+## Resources
+
+- **Workflows**: See [references/workflows.md](references/workflows.md) for turn-by-turn logic.
+- **Config**: Patterns and priority are defined in [config.yaml](config.yaml).
+- **Examples**: See [references/examples.md](references/examples.md) for concrete patterns.
+- **Handover**: See [references/handover-protocol.md](references/handover-protocol.md) for command flags.
+
+## Best Practices
+- **Concise Context**: Send only relevant snippets, not entire files, to the neighboring agent.
+- **Specific Tasks**: Ask for a "Security Audit" or "Refactoring Suggestions" rather than a general review.
+- **Fail-Safe**: If a neighboring agent is not found, proceed with a self-review but notify the user.

package/skills/orchestrating-agents/config.yaml

@@ -0,0 +1,45 @@
+# Orchestration Configuration
+# Version: 1.0.0
+
+# ----------------------------------------------------------------------------
+# Orchestration Workflows: Deep multi-turn agent interactions
+# ----------------------------------------------------------------------------
+orchestration_workflows:
+  collaborative-design:
+    patterns:
+      - "design.*feature"
+      - "architecture.*plan"
+      - "new.*component"
+    description: "Multi-turn design session: Proposal (Agent A) -> Critique (Agent B) -> Refinement (Agent A)"
+    turns: 3
+
+  adversarial-review:
+    patterns:
+      - "security.*audit"
+      - "break.*code"
+      - "find.*flaws"
+      - "red.*team"
+    description: "Skeptic review: Proposal (Agent A) -> Attack/Skepticism (Agent B) -> Defense/Fix (Agent A)"
+    turns: 3
+
+  troubleshoot-session:
+    patterns:
+      - "debug.*complex"
+      - "emergency"
+      - "out.*of.*trouble"
+      - "production.*error"
+    description: "Deep investigation: Hypothesis (Agent A) -> Verification (Agent B) -> Root Cause (Both)"
+    turns: 4
+
+# ----------------------------------------------------------------------------
+# Pattern Priority
+# ----------------------------------------------------------------------------
+priority:
+  - orchestration_workflows
+
+# ----------------------------------------------------------------------------
+# Auto-Selection Default
+# ----------------------------------------------------------------------------
+default:
+  workflow: collaborative-design
+  reason: "Standard multi-agent collaboration"