USP

Offers a local, curated collection of Claude Code and Codex skills with easy installation via `/plugin marketplace add` and dedicated scripts for Codex symlink management. Includes tools for AI-friendly CLI design, skill creation/review, a…

Use cases

• 01Installing and managing custom Claude Code skills locally.
• 02Integrating repo-local skills with Codex for AI-assisted development.
• 03Enhancing development workflows with AI-friendly CLI design principles.
• 04Automating terminal interactions and Git operations.
• 05Guiding AI in UI design and complex problem-solving.

Detected files (8)

• plugins/git-chain/SKILL.mdskill
  Show content (7117 bytes)

  ---
  name: git-chain
  description: Manage and rebase chains of dependent Git branches (stacked branches). Use when working with multiple dependent PRs, feature branches that build on each other, or maintaining clean branch hierarchies. Automates the tedious process of rebasing or merging entire branch chains.
  ---
  
  # Git Chain
  
  ## Overview
  
  `git chain` manages chains of dependent Git branches where each branch builds upon the previous one (stacked branches). Instead of manually rebasing each branch in sequence, git-chain tracks relationships and updates all branches with a single command.
  
  ```
                          I---J---K  feature-2
                         /
                E---F---G  feature-1
               /
  A---B---C---D  master
  ```
  
  When `master` is updated, git-chain rebases `feature-1` onto `master`, then `feature-2` onto `feature-1` automatically.
  
  ## When to Use This Skill
  
  Use git-chain when:
  - **Stacked PRs**: Working with multiple dependent pull requests that build on each other
  - **Feature chains**: Developing a large feature split into incremental branches
  - **Review feedback**: Updating base branches requires propagating changes to dependent branches
  - **Clean history**: Maintaining linear commit history across dependent branches
  - **Avoiding tedious rebasing**: Don't want to manually rebase 3+ branches in sequence
  
  ## Prerequisites
  
  **CRITICAL**: Before proceeding, verify that git-chain is installed:
  
  ```bash
  git chain --version
  ```
  
  **If git-chain is not installed:**
  - **DO NOT** attempt to install it automatically
  - **STOP** and inform the user that git-chain is required
  - **RECOMMEND** manual installation:
  
  ```bash
  # From source (requires Rust)
  git clone git@github.com:dashed/git-chain.git
  cd git-chain
  make install
  
  # Or with Cargo
  cargo install --path .
  ```
  
  **If git-chain is not available, exit gracefully and do not proceed with the workflow below.**
  
  ## Key Concepts
  
  - **Chain**: A named sequence of branches with dependency order
  - **Root Branch**: Foundation branch (typically `main` or `master`) - NOT part of the chain
  - **Branch Order**: The sequence in which branches depend on each other
  
  **Important**: A branch can belong to at most one chain.
  
  ## Basic Workflow
  
  ### Step 1: Set Up a Chain
  
  Create a chain with your stacked branches:
  
  ```bash
  git chain setup my-feature master feature-1 feature-2 feature-3
  ```
  
  This creates chain "my-feature" with `master` as root and branches in order: `feature-1` -> `feature-2` -> `feature-3`.
  
  ### Step 2: View the Chain
  
  ```bash
  git chain          # Show current chain (if on a chain branch)
  git chain list     # List all chains in the repository
  ```
  
  ### Step 3: Update the Chain
  
  When the root branch or any branch in the chain has new commits:
  
  **Option A: Rebase (rewrites history, clean linear commits)**
  ```bash
  git chain rebase
  ```
  
  **Option B: Merge (preserves history, creates merge commits)**
  ```bash
  git chain merge
  ```
  
  ## Common Patterns
  
  ### Pattern 1: Stacked PR Workflow
  
  **Scenario**: Working on a feature split into 3 PRs: auth, profiles, settings
  
  ```bash
  # Create branches
  git checkout -b auth main
  # ... make auth changes, commit ...
  git checkout -b profiles auth
  # ... make profile changes, commit ...
  git checkout -b settings profiles
  # ... make settings changes, commit ...
  
  # Set up the chain
  git chain setup user-feature main auth profiles settings
  
  # After main receives new commits, update all branches
  git chain rebase
  git chain push --force  # Update all PRs
  ```
  
  ### Pattern 2: Review Feedback on Base Branch
  
  **Scenario**: Reviewer requested changes on `auth` branch (first PR)
  
  ```bash
  git checkout auth
  # ... make changes, commit ...
  
  # Update dependent branches automatically
  git chain rebase
  ```
  
  ### Pattern 3: Adding a New Branch to Existing Chain
  
  **Scenario**: Need to add `notifications` branch between `profiles` and `settings`
  
  ```bash
  git checkout -b notifications profiles
  # ... make changes, commit ...
  
  # Add to chain with specific position
  git chain init user-feature main --after=profiles
  ```
  
  ## Core Commands Reference
  
  | Command | Description |
  |---------|-------------|
  | `git chain setup <name> <root> <b1> <b2>...` | Create chain with branches |
  | `git chain init <name> <root>` | Add current branch to chain |
  | `git chain` | Display current chain |
  | `git chain list` | List all chains |
  | `git chain rebase` | Rebase all branches (rewrites history) |
  | `git chain merge` | Merge all branches (preserves history) |
  | `git chain push` | Push all branches to remotes |
  | `git chain push --force` | Force push all branches |
  | `git chain first/last/next/prev` | Navigate between chain branches |
  | `git chain backup` | Create backup branches |
  | `git chain prune` | Remove branches merged to root |
  | `git chain remove` | Remove current branch from chain |
  | `git chain remove --chain` | Delete entire chain |
  
  ## Rebase vs Merge
  
  **Use Rebase When:**
  - Branches are private/not shared
  - You prefer clean, linear history
  - PRs haven't been reviewed yet
  
  **Use Merge When:**
  - Branches have open PRs with review comments
  - You need to preserve commit history
  - Collaborating with others on the same branches
  
  ## Advanced Usage
  
  For comprehensive coverage of all flags and advanced patterns, see:
  - [references/rebase-options.md](references/rebase-options.md) - All rebase flags and conflict handling
  - [references/merge-options.md](references/merge-options.md) - All merge flags and strategies
  - [references/chain-management.md](references/chain-management.md) - Moving, reorganizing, and removing chains
  
  **Key flags:**
  - `--step, -s`: Process one branch at a time (rebase)
  - `--ignore-root, -i`: Skip updating first branch from root
  - `--verbose, -v`: Detailed output (merge)
  - `--chain=<name>`: Operate on specific chain
  - `--no-ff`: Force merge commits even for fast-forwards
  - `--squashed-merge=<mode>`: Handle squash-merged branches (reset/skip/merge)
  
  ## Recovery
  
  If something goes wrong during rebase:
  
  ```bash
  # Abort in-progress rebase
  git rebase --abort
  
  # Restore from backup (if created with git chain backup)
  git checkout branch-name
  git reset --hard branch-name-backup
  
  # Or use reflog
  git reflog
  git reset --hard branch-name@{1}
  ```
  
  ## Handling Conflicts
  
  When conflicts occur during `git chain rebase`:
  
  1. Git-chain pauses at the conflicted commit
  2. Resolve conflicts manually in the marked files
  3. `git add <resolved-files>`
  4. `git rebase --continue`
  5. `git chain rebase` (continues with remaining branches)
  
  ## Troubleshooting
  
  **"Branch not part of any chain"**
  - Run `git chain list` to see available chains
  - Use `git chain init` to add the current branch to a chain
  
  **"Cannot find fork-point"**
  - Reflog may have been cleaned up
  - Use `--no-fork-point` flag to fall back to merge-base
  
  **Rebase conflicts on every update**
  - Consider using `git chain merge` instead to preserve history
  - Or use `--step` flag to handle each branch individually
  
  **Squash-merged branch causing issues**
  - git-chain detects squash merges; use `--squashed-merge=skip` to skip them
  - Or use `--squashed-merge=reset` (default) to reset branch to parent
  

• plugins/ai-friendly-cli/SKILL.mdskill
  Show content (9780 bytes)

  ---
  name: ai-friendly-cli
  description: Build and refactor CLIs for AI agent compatibility. Use when making command-line interfaces machine-readable, adding structured JSON output, hardening inputs against hallucinations, implementing safety rails like dry-run flags, adding schema introspection, or designing multi-surface architectures (CLI + MCP).
  ---
  
  # AI-Friendly CLI
  
  ## Overview
  
  Human DX optimizes for discoverability and forgiveness. Agent DX optimizes for predictability and defense-in-depth. These require fundamentally different design approaches.
  
  This skill provides 8 principles for building or refactoring command-line interfaces so that AI agents can invoke them reliably, safely, and efficiently. The core insight: agents hallucinate inputs, pay per token, and can't read interactive prompts. Your CLI must defend against all three.
  
  ## When to Use
  
  Use this skill when:
  
  - **Adding AI/agent support** to an existing CLI tool
  - **Building a new CLI** that agents will invoke
  - **Wrapping an API** as a CLI tool (REST, GraphQL, gRPC)
  - **Designing MCP servers** alongside CLI interfaces
  - **Hardening inputs** against hallucinated or malformed agent inputs
  - **Reducing token cost** by limiting response sizes
  - **Adding structured output** (JSON, NDJSON) to human-oriented CLIs
  
  ## The 8 Principles
  
  ### 1. Structured JSON I/O
  
  Support `--json` for structured input payloads and `--output json` for machine-readable output. When stdout is not a TTY, default to NDJSON.
  
  **Why**: Agents parse structured data. Tabular or prose output requires brittle regex parsing that breaks across versions.
  
  **Example** -- instead of 10 separate flags:
  ```bash
  # Human-friendly (many flags)
  cli create-issue --title "Bug" --assignee alice --priority high --label bug
  
  # Agent-friendly (single structured payload)
  cli create-issue --json '{"title":"Bug","assignee":"alice","priority":"high","labels":["bug"]}'
  ```
  
  Both should produce structured output:
  ```bash
  cli create-issue --json '{"title":"Bug"}' --output json
  # {"id":"ISS-42","title":"Bug","status":"open","url":"https://..."}
  ```
  
  ### 2. Schema Introspection
  
  Make the CLI self-documenting with machine-readable method signatures. Add a `schema` subcommand or `--describe` flag that returns parameters, types, and constraints as JSON.
  
  **Why**: Agents need to know what parameters exist, what types they accept, and what values are valid -- without parsing `--help` prose.
  
  **Example**:
  ```bash
  cli schema issues.create
  # {
  #   "method": "issues.create",
  #   "params": {
  #     "title": {"type": "string", "required": true},
  #     "assignee": {"type": "string", "enum": ["alice","bob"]},
  #     "priority": {"type": "string", "enum": ["low","medium","high"]}
  #   }
  # }
  ```
  
  The CLI becomes the canonical source of truth, eliminating stale documentation.
  
  ### 3. Context Window Discipline
  
  Agents pay per token. API responses can be massive. Support field masks and streaming pagination to keep responses lean.
  
  **Key patterns**:
  - `--fields "id,name,status"` -- return only specified fields
  - `--page-all` -- stream all pages as NDJSON instead of buffering entire arrays
  - `--limit N` -- cap result count
  
  **Example**:
  ```bash
  # Without field mask: 50 fields per issue, 100 issues = thousands of tokens
  cli issues list --output json
  
  # With field mask: 3 fields per issue = fraction of tokens
  cli issues list --output json --fields "id,title,status"
  ```
  
  ### 4. Input Hardening
  
  Agents hallucinate. The CLI is the last line of defense before bad data reaches your API or filesystem.
  
  **Validate and reject**:
  - **Path traversals**: `../../etc/passwd`, `../.ssh/id_rsa`
  - **Control characters**: bytes 0x00-0x1F in any string input
  - **Malformed resource IDs**: values containing `?`, `#`, `%`
  - **URL injection**: always percent-encode path segments; never use string interpolation
  
  **Example**:
  ```bash
  # Agent hallucinates a path traversal
  cli files get --path "../../.ssh/id_rsa"
  # {"error":"invalid_path","code":"PATH_TRAVERSAL","message":"path must not contain '..'"}
  
  # Agent hallucinates control characters
  cli issues create --json '{"title":"test\x00inject"}'
  # {"error":"invalid_input","code":"CONTROL_CHAR","message":"input contains control characters"}
  ```
  
  ### 5. Safety Rails
  
  Provide mechanisms for agents to validate operations before executing them, and for defending against prompt injection in response data.
  
  **Key patterns**:
  - `--dry-run` -- validate inputs and show what would happen, without executing
  - `--sanitize` -- strip or escape potentially dangerous content from responses (prompt injection defense)
  - Always confirm with the user before mutations
  
  **Example**:
  ```bash
  # Dry-run: validate and preview without side effects
  cli issues delete ISS-42 --dry-run
  # {"action":"delete","target":"ISS-42","status":"valid","would_delete":true}
  
  # Sanitize: defend against prompt injection in response data
  cli issues get ISS-42 --sanitize template
  # Strips sequences like "IGNORE ALL PREVIOUS INSTRUCTIONS" from response fields
  ```
  
  ### 6. Structured Errors
  
  Return JSON errors with codes and reasons on stdout. Print human-friendly hints on stderr. Agents parse stdout; humans read stderr. Never mix prose with JSON on the same stream.
  
  **Example**:
  ```bash
  cli issues get NONEXISTENT --output json
  # stdout: {"error":"not_found","code":"ISSUE_NOT_FOUND","message":"Issue NONEXISTENT does not exist"}
  # stderr: Hint: Run `cli issues list` to see available issues.
  # exit code: 1
  ```
  
  **Error JSON structure**:
  ```json
  {
    "error": "category_name",
    "code": "SPECIFIC_ERROR_CODE",
    "message": "Human-readable description",
    "details": {}
  }
  ```
  
  ### 7. Agent Documentation
  
  Ship documentation alongside the CLI that encodes invariants an agent cannot discover from `--help` alone.
  
  **Key files**:
  - `SKILL.md` -- Activation triggers and common workflows
  - `AGENTS.md` or `CONTEXT.md` -- Non-obvious rules, gotchas, required sequences
  - Schema introspection (Principle 2) for runtime discovery
  
  **What to document**:
  - "Always use `--dry-run` before any mutation"
  - "Always use `--fields` for list operations to control token cost"
  - "Never pass user-provided strings directly as `--json` without escaping"
  - Required ordering of operations (e.g., authenticate before query)
  - Rate limits and retry semantics
  
  ### 8. Multi-Surface Architecture
  
  One core binary, multiple interfaces: CLI for humans, MCP (JSON-RPC over stdio) for agents, environment variables for headless authentication.
  
  **Architecture**:
  ```
             +------------------+
             |   Core Library   |
             +------------------+
            /         |          \
        CLI       MCP Server    REST API
     (humans)    (agents)      (services)
  ```
  
  **Key patterns**:
  - CLI and MCP share the same validation, business logic, and error handling
  - CLI reads flags/args; MCP reads JSON-RPC params; both call the same core
  - Auth via `CLI_TOKEN` env var (headless) or interactive OAuth (human)
  - MCP enables richer agent integration (streaming, tool registration)
  
  ## Implementation Priority
  
  Start here, in order. Each step builds on the previous:
  
  1. **Add `--output json`** for machine-readable output on all commands
  2. **Validate all inputs** -- reject control characters, path traversals, embedded query params
  3. **Add `schema` or `--describe`** command for runtime introspection
  4. **Support `--fields`** to limit response size and token cost
  5. **Add `--dry-run`** for validation before any mutation
  6. **Ship `CONTEXT.md`** or skill files encoding non-obvious invariants
  7. **Expose MCP surface** for API-wrapping CLIs
  
  ## Quick Reference
  
  | Flag / Pattern | Purpose | Example |
  |----------------|---------|---------|
  | `--output json` | Machine-readable output | `cli list --output json` |
  | `--json '{...}'` | Structured input payload | `cli create --json '{"title":"Bug"}'` |
  | `--fields` | Field masks (limit response) | `cli list --fields "id,name"` |
  | `--dry-run` | Validate without executing | `cli delete --dry-run` |
  | `--page-all` | Stream all pages as NDJSON | `cli list --page-all` |
  | `schema` / `--describe` | Schema introspection | `cli schema method.name` |
  | `--sanitize` | Response sanitization | `cli get --sanitize template` |
  | `--limit N` | Cap result count | `cli list --limit 50` |
  
  ## Anti-Patterns
  
  Avoid these when building agent-friendly CLIs:
  
  - **Mixing prose with JSON on stdout** -- agents cannot reliably parse mixed output
  - **Trusting agent inputs** -- validate everything; agents hallucinate paths, IDs, and parameters
  - **String interpolation for URLs** -- use URL builders to prevent injection
  - **Auto-executing destructive operations** -- always require confirmation or `--dry-run` first
  - **Outputting secrets to stdout** -- tokens, keys, and passwords should never appear in structured output
  - **Creating alias-only helpers** -- wrappers must add real value (validation, structured output), not just alias existing commands
  - **Unbounded responses** -- always support field masks and pagination; agents pay per token
  - **Interactive prompts** -- agents cannot respond to interactive stdin; use flags or `--json` instead
  
  ## Advanced Reference
  
  For detailed patterns and implementation guidance, see:
  
  - [Output Patterns](references/output-patterns.md) -- JSON, NDJSON, field masks, dual-channel (stdout/stderr)
  - [Input Hardening](references/input-hardening.md) -- Path safety, URL encoding, control character validation
  - [Safety Patterns](references/safety-patterns.md) -- Dry-run implementation, sanitization, confirmation flows
  - [Architecture](references/architecture.md) -- Multi-surface design, schema introspection, MCP integration
  
  ## Attribution
  
  - Blog: "Rewrite your CLI for AI Agents" by Justin Poehnelt
  - Reference implementation: Google Workspace CLI (gws)
  

• plugins/chrome-cdp/SKILL.mdskill
  Show content (3964 bytes)

  ---
  name: chrome-cdp
  description: Interact with local Chrome browser session via Chrome DevTools Protocol. Use when asked to inspect, debug, or interact with a page open in Chrome, take screenshots of browser tabs, read accessibility trees, evaluate JavaScript, click elements, navigate pages, or automate browser interactions in a live Chrome session.
  ---
  
  # Chrome CDP
  
  Lightweight Chrome DevTools Protocol CLI. Connects directly via WebSocket — no Puppeteer, works with 100+ tabs, instant connection. Uses a persistent per-tab daemon so Chrome's "Allow debugging" modal fires only once.
  
  ## Prerequisites
  
  - Chrome with remote debugging enabled: open `chrome://inspect/#remote-debugging` and toggle the switch
  - Python 3.10+ with `websockets` library
  
  ## Commands
  
  All commands use `python -m chrome_cdp`. The `<target>` is a **unique** targetId prefix from `list`; copy the full prefix shown in the `list` output (for example `6BE827FA`). The CLI rejects ambiguous prefixes.
  
  ### List open pages
  
  ```bash
  python -m chrome_cdp list
  ```
  
  ### Take a screenshot
  
  ```bash
  python -m chrome_cdp shot <target> [file]    # default: /tmp/screenshot.png
  ```
  
  Captures the **viewport only**. Scroll first with `eval` if you need content below the fold. Output includes the page's DPR and coordinate conversion hint (see [references/coordinate-system.md](references/coordinate-system.md)).
  
  ### Accessibility tree snapshot
  
  ```bash
  python -m chrome_cdp snap <target>
  ```
  
  Prefer `snap` over `html` for understanding page structure — it's compact and semantic.
  
  ### Evaluate JavaScript
  
  ```bash
  python -m chrome_cdp eval <target> <expr>
  ```
  
  > **Watch out:** avoid index-based selection (`querySelectorAll(...)[i]`) across multiple `eval` calls when the DOM can change between them (e.g. after clicking Ignore, card indices shift). Collect all data in one `eval` or use stable selectors.
  
  ### Other commands
  
  ```bash
  python -m chrome_cdp html    <target> [selector]   # full page or element HTML
  python -m chrome_cdp nav     <target> <url>         # navigate and wait for load
  python -m chrome_cdp net     <target>               # resource timing entries
  python -m chrome_cdp click   <target> <selector>    # click element by CSS selector
  python -m chrome_cdp clickxy <target> <x> <y>       # click at CSS pixel coords
  python -m chrome_cdp type    <target> <text>         # Input.insertText at current focus
  python -m chrome_cdp loadall <target> <selector> [ms]  # click "load more" until gone
  python -m chrome_cdp evalraw <target> <method> [json]  # raw CDP command passthrough
  python -m chrome_cdp stop    [target]               # stop daemon(s)
  ```
  
  ## Coordinates
  
  `shot` saves an image at native resolution: image pixels = CSS pixels x DPR. CDP Input events (`clickxy` etc.) take **CSS pixels**.
  
  ```
  CSS px = screenshot image px / DPR
  ```
  
  `shot` prints the DPR for the current page. Typical Retina (DPR=2): divide screenshot coords by 2.
  
  For the full coordinate system reference including DPR detection, viewer scaling, and worked examples, see [references/coordinate-system.md](references/coordinate-system.md).
  
  ## Tips
  
  - Prefer `snap` over `html` for page structure — it's compact and semantic.
  - Use `type` (not eval) to enter text in cross-origin iframes — use `click`/`clickxy` to focus first, then `type`.
  - Chrome shows an "Allow debugging" modal once per tab on first access. A background daemon keeps the session alive so subsequent commands need no further approval. Daemons auto-exit after 20 minutes of inactivity.
  - Use `evalraw` to send arbitrary CDP methods not covered by the built-in commands (e.g. `DOM.getDocument`, `Network.enable`).
  
  ## Advanced Usage
  
  For detailed protocol documentation, see:
  - [references/coordinate-system.md](references/coordinate-system.md) — DPR, CSS pixels, screenshot coordinate mapping
  - [references/daemon-ipc.md](references/daemon-ipc.md) — Unix socket protocol, NDJSON format, request/response schema
  

• plugins/conventional-commits/SKILL.mdskill
  Show content (4576 bytes)

  ---
  name: conventional-commits
  description: "Format git commit messages following Conventional Commits 1.0.0 specification. Use when the user asks to commit changes, create a git commit, or mentions committing code. Ensures consistent, semantic commit messages that support automated changelog generation and semantic versioning."
  license: MIT
  ---
  
  # Conventional Commits
  
  Format all git commit messages according to the [Conventional Commits 1.0.0](https://www.conventionalcommits.org/) specification.
  
  ## Commit Message Format
  
  ```
  <type>[optional scope]: <description>
  
  [optional body]
  
  [optional footer(s)]
  ```
  
  ## Type Reference
  
  | Type | When to Use | SemVer |
  |------|-------------|--------|
  | `feat` | New feature | MINOR |
  | `fix` | Bug fix | PATCH |
  | `docs` | Documentation only | - |
  | `style` | Formatting, whitespace (no code change) | - |
  | `refactor` | Code restructuring (no feature/fix) | - |
  | `perf` | Performance improvement | - |
  | `test` | Adding/fixing tests | - |
  | `build` | Build system, dependencies | - |
  | `ci` | CI/CD configuration | - |
  | `chore` | Maintenance, tooling | - |
  | `revert` | Reverting previous commit | - |
  
  ## Decision Framework
  
  When determining commit type, ask:
  
  - Does it add new functionality? → `feat`
  - Does it fix broken functionality? → `fix`
  - Does it only affect documentation? → `docs`
  - Does it improve performance? → `perf`
  - Does it restructure code without changing behavior? → `refactor`
  - Does it only change code style/formatting? → `style`
  - Does it add/modify tests? → `test`
  - Does it change build system or dependencies? → `build`
  - Does it change CI/CD configuration? → `ci`
  - Is it maintenance or tooling? → `chore`
  
  ## Message Best Practices
  
  ### Description (first line)
  - Keep under 50 characters
  - Use imperative mood ("add" not "added")
  - Don't capitalize first letter
  - No period at end
  
  ### Scope
  - Use clear, consistent names: `feat(auth):`, `fix(api):`, `docs(readme):`
  
  ### Body
  - Include when change requires explanation
  - Explain why the change was made
  - Describe what problem it solves
  - Wrap at 72 characters per line
  
  ### Footers
  - `Fixes #123` - Reference issues
  - `Co-authored-by: Name <email>` - Credit contributors
  - `BREAKING CHANGE: description` - Breaking changes
  - `Refs: #456, #789` - Related issues
  
  ## Breaking Changes
  
  Indicate breaking changes using either method:
  
  ```
  feat!: remove deprecated API endpoint
  
  feat(api)!: change authentication flow
  
  fix: update validation logic
  
  BREAKING CHANGE: validation now rejects empty strings
  ```
  
  ## Command Execution
  
  **Critical**: Use single quotes to avoid shell escaping issues with `!`:
  
  ```bash
  # Correct - single quotes
  git commit -m 'feat!: add new authentication flow'
  
  # Incorrect - backslash escaping (DO NOT USE)
  git commit -m "feat\!: add new authentication flow"
  ```
  
  For multi-line messages, use HEREDOC:
  
  ```bash
  git commit -m "$(cat <<'EOF'
  feat(auth): add OAuth2 support
  
  Implement OAuth2 authentication flow with support for
  Google and GitHub providers.
  
  BREAKING CHANGE: removes legacy session-based auth
  EOF
  )"
  ```
  
  ## Workflow
  
  1. Check for staged changes: `git diff --cached --stat`
  2. If nothing staged: stage with `git add` first
  3. Review changes: `git diff --cached`
  4. Check recent style: `git log --oneline -5`
  5. Determine type using decision framework
  6. Write message following best practices
  7. Execute commit with single quotes
  8. Verify: `git log -1`
  
  ## Quality Checks
  
  Before committing, verify:
  
  - [ ] Message accurately describes the changes
  - [ ] Type correctly categorizes the change
  - [ ] Scope (if used) is meaningful and consistent
  - [ ] Breaking changes are properly marked with `!` suffix or `BREAKING CHANGE:` footer
  - [ ] Description is clear and under 50 characters
  - [ ] Body wraps at 72 characters (if present)
  
  ## Examples
  
  **Simple fix:**
  ```
  fix: prevent null pointer in user lookup
  ```
  
  **Feature with scope:**
  ```
  feat(api): add rate limiting to endpoints
  ```
  
  **With body:**
  ```
  refactor: extract validation into separate module
  
  Move validation logic from controllers to dedicated
  validator classes for better testability and reuse.
  ```
  
  **Breaking change:**
  ```
  feat!: upgrade to v2 API format
  
  BREAKING CHANGE: response structure changed from
  {data: [...]} to {items: [...], meta: {...}}
  ```
  
  **With issue reference:**
  ```
  fix(auth): resolve token refresh race condition
  
  Fixes #234
  ```
  
  ## Full Specification
  
  For the complete Conventional Commits 1.0.0 specification including all rules and FAQ, see [references/full-spec.md](references/full-spec.md).
  

• plugins/design-principles/SKILL.mdskill
  Show content (2924 bytes)

  ---
  name: design-principles
  description: "Guide AI-assisted UI generation toward enterprise-grade, intentional design. Use when building user interfaces, creating dashboards, designing enterprise software or SaaS applications, generating frontend code with styling, or when the user asks for design help. Enforces principles inspired by Linear, Notion, Stripe, and Vercel."
  ---
  
  # Design Principles
  
  This skill guides AI-assisted UI generation toward enterprise-grade, intentional design rather than producing generic interfaces. It enforces principles inspired by products like Linear, Notion, Stripe, and Vercel.
  
  ## When to Use
  
  Invoke this skill when:
  
  - Building user interfaces or frontend components
  - Creating dashboards or admin panels
  - Designing enterprise software or SaaS applications
  - Generating styled frontend code
  - User asks for design help or UI improvements
  - Working on any project that needs professional, polished styling
  
  ## Key Requirement
  
  **Commit to a design direction before coding.** Choose one personality:
  
  | Direction | Character | Use Case |
  |-----------|-----------|----------|
  | Precision & Density | Tight, monochrome, technical | Developer tools |
  | Warmth & Approachability | Generous spacing, soft shadows | Consumer SaaS |
  | Sophistication & Trust | Cool tones, layered depth | Enterprise finance |
  | Boldness & Clarity | High contrast, dramatic space | Modern dashboards |
  | Utility & Function | Muted palette, functional density | GitHub-style tools |
  | Data & Analysis | Chart-optimized, numbers-first | Analytics platforms |
  
  ## Core Craft Principles
  
  **The 4px grid** governs all spacing (4px → 8px → 12px → 16px → 24px → 32px).
  
  **Symmetrical padding** is mandatory: TLBR values must match unless content creates natural visual balance.
  
  **Depth strategy must be intentional and consistent.** Choose borders-only (flat, technical), subtle single shadows, layered shadows (premium), or surface color shifts—then commit completely.
  
  **Typography hierarchy:** Headlines at 600 weight with tight letter-spacing; body at 400–500; scales from 11px to 32px. Monospace exclusively for data.
  
  **Card layouts should vary internally while maintaining consistent surface treatment.** Border weight, shadow depth, corner radius, and padding remain uniform.
  
  ## Critical Details
  
  - Use Phosphor Icons; avoid native form elements
  - Animation: 150–250ms with cubic-bezier easing (no bounce)
  - Color communicates meaning only (status, action, error, success)
  - Dark mode requires border emphasis over shadows
  - Include navigation context: sidebars, breadcrumbs, or active states
  
  ## The Standard
  
  *"Every interface should look designed by a team that obsesses over 1-pixel differences"*—polished, intentional, never defaulted.
  
  ## Attribution
  
  This skill is based on [claude-design-skill](https://github.com/Dammyjay93/claude-design-skill) by Dammyjay93, licensed under MIT.
  

• plugins/fzf/SKILL.mdskill
  Show content (12409 bytes)

  ---
  name: fzf
  description: Command-line fuzzy finder for interactive filtering of any list. Use when interactively selecting files, searching command history (CTRL-R), creating selection interfaces in scripts, building interactive menus, or integrating fuzzy search with tools like ripgrep, fd, and git. Triggers on mentions of fzf, fuzzy finder, ** completion, interactive filtering, or shell keybindings CTRL-T/CTRL-R/ALT-C.
  ---
  
  # fzf - Command-Line Fuzzy Finder
  
  ## Overview
  
  fzf is a general-purpose command-line fuzzy finder. It reads a list of items from STDIN, allows interactive selection using fuzzy matching, and outputs the selected item(s) to STDOUT. Think of it as an interactive grep.
  
  **Key characteristics:**
  - **Fast**: Processes millions of items instantly
  - **Portable**: Single binary, works everywhere
  - **Versatile**: Customizable via event-action binding mechanism
  - **Integrated**: Built-in shell integrations for bash, zsh, and fish
  
  ## When to Use This Skill
  
  Use fzf when:
  - **Selecting files interactively**: `vim $(fzf)` or fuzzy completion with `**<TAB>`
  - **Searching command history**: CTRL-R for fuzzy history search
  - **Navigating directories**: ALT-C to cd into selected directory
  - **Building interactive scripts**: Create selection menus for any list
  - **Filtering output**: Pipe any command output through fzf
  - **Integrating with other tools**: ripgrep, fd, git, etc.
  
  ## Prerequisites
  
  **CRITICAL**: Before proceeding, you MUST verify that fzf is installed:
  
  ```bash
  fzf --version
  ```
  
  **If fzf is not installed:**
  - **DO NOT** attempt to install it automatically
  - **STOP** and inform the user that fzf is required
  - **RECOMMEND** manual installation with the following instructions:
  
  ```bash
  # macOS
  brew install fzf
  
  # Debian/Ubuntu
  sudo apt install fzf
  
  # Arch Linux
  sudo pacman -S fzf
  
  # From source
  git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
  ~/.fzf/install
  
  # Other systems: see https://github.com/junegunn/fzf#installation
  ```
  
  **If fzf is not available, exit gracefully and do not proceed with the workflow below.**
  
  ## Shell Integration
  
  fzf provides shell integration that enables powerful keybindings (CTRL-T, CTRL-R, ALT-C) and fuzzy completion (`**<TAB>`). These features require the user to configure their shell.
  
  **Note:** Shell integration setup is the user's responsibility. If keybindings don't work, **RECOMMEND** the user add the appropriate line to their shell config:
  
  ```bash
  # Bash (~/.bashrc)
  eval "$(fzf --bash)"
  
  # Zsh (~/.zshrc)
  source <(fzf --zsh)
  
  # Fish (~/.config/fish/config.fish)
  fzf --fish | source
  ```
  
  ### Key Bindings (requires shell integration)
  
  | Key | Function | Description |
  |-----|----------|-------------|
  | `CTRL-T` | File selection | Paste selected files/directories onto command line |
  | `CTRL-R` | History search | Fuzzy search command history |
  | `ALT-C` | Directory jump | cd into selected directory |
  
  **CTRL-R extras:**
  - Press `CTRL-R` again to toggle sort by relevance
  - Press `ALT-R` to toggle raw mode (see surrounding items)
  - Press `CTRL-/` or `ALT-/` to toggle line wrapping
  
  ### Fuzzy Completion (`**<TAB>`)
  
  Trigger fuzzy completion with `**` followed by TAB:
  
  ```bash
  # Files under current directory
  vim **<TAB>
  
  # Files under specific directory
  vim ../fzf**<TAB>
  
  # Directories only
  cd **<TAB>
  
  # Process IDs (for kill)
  kill -9 **<TAB>
  
  # SSH hostnames
  ssh **<TAB>
  
  # Environment variables
  export **<TAB>
  ```
  
  ## Search Syntax
  
  fzf uses extended-search mode by default. Multiple search terms are separated by spaces.
  
  | Token | Match Type | Description |
  |-------|------------|-------------|
  | `sbtrkt` | Fuzzy match | Items matching `sbtrkt` |
  | `'wild` | Exact match | Items containing `wild` exactly |
  | `'wild'` | Exact boundary | Items with `wild` at word boundaries |
  | `^music` | Prefix match | Items starting with `music` |
  | `.mp3$` | Suffix match | Items ending with `.mp3` |
  | `!fire` | Inverse match | Items NOT containing `fire` |
  | `!^music` | Inverse prefix | Items NOT starting with `music` |
  | `!.mp3$` | Inverse suffix | Items NOT ending with `.mp3` |
  
  **OR operator**: Use `|` to match any of several patterns:
  ```bash
  # Files starting with 'core' and ending with go, rb, or py
  ^core go$ | rb$ | py$
  ```
  
  **Escape spaces**: Use `\ ` to match literal space characters.
  
  ## Basic Usage
  
  ### Simple Selection
  
  ```bash
  # Select a file and open in vim
  vim $(fzf)
  
  # Safer with xargs (handles spaces, cancellation)
  fzf --print0 | xargs -0 -o vim
  
  # Using become() action (best approach)
  fzf --bind 'enter:become(vim {})'
  ```
  
  ### Multi-Select
  
  ```bash
  # Enable multi-select with -m
  fzf -m
  
  # Select with TAB, deselect with Shift-TAB
  # Selected items printed on separate lines
  ```
  
  ### Preview Window
  
  ```bash
  # Basic preview
  fzf --preview 'cat {}'
  
  # With syntax highlighting (requires bat)
  fzf --preview 'bat --color=always {}'
  
  # Customize preview window position/size
  fzf --preview 'cat {}' --preview-window=right,50%
  fzf --preview 'cat {}' --preview-window=up,40%,border-bottom
  ```
  
  ## Display Modes
  
  ### Height Mode
  
  ```bash
  # Use 40% of terminal height
  fzf --height 40%
  
  # Adaptive height (shrinks for small lists)
  seq 5 | fzf --height ~100%
  
  # With layout options
  fzf --height 40% --layout reverse --border
  ```
  
  ### tmux Mode
  
  ```bash
  # Open in tmux popup (requires tmux 3.3+)
  fzf --tmux center         # Center, 50% width/height
  fzf --tmux 80%            # Center, 80% width/height
  fzf --tmux left,40%       # Left side, 40% width
  fzf --tmux bottom,30%     # Bottom, 30% height
  ```
  
  ## Essential Options
  
  ### Layout and Appearance
  
  ```bash
  --height=HEIGHT[%]     # Non-fullscreen mode
  --layout=reverse       # Display from top (default: bottom)
  --border[=STYLE]       # rounded, sharp, bold, double, block
  --margin=MARGIN        # Margin around finder
  --padding=PADDING      # Padding inside border
  --info=STYLE           # default, inline, hidden
  ```
  
  ### Search Behavior
  
  ```bash
  -e, --exact            # Exact match (disable fuzzy)
  -i                     # Case-insensitive
  +i                     # Case-sensitive
  --scheme=SCHEME        # default, path, history
  --algo=TYPE            # v2 (quality), v1 (performance)
  ```
  
  ### Input/Output
  
  ```bash
  -m, --multi            # Enable multi-select
  --read0                # Read NUL-delimited input
  --print0               # Print NUL-delimited output
  --ansi                 # Enable ANSI color processing
  ```
  
  ### Field Processing
  
  ```bash
  --delimiter=STR        # Field delimiter (default: AWK-style)
  --nth=N[,..]           # Limit search to specific fields
  --with-nth=N[,..]      # Transform display of each line
  ```
  
  ## Event Bindings
  
  Customize behavior with `--bind`:
  
  ```bash
  # Basic syntax
  fzf --bind 'KEY:ACTION'
  fzf --bind 'EVENT:ACTION'
  fzf --bind 'KEY:ACTION1+ACTION2'  # Chain actions
  
  # Examples
  fzf --bind 'ctrl-a:select-all'
  fzf --bind 'ctrl-d:deselect-all'
  fzf --bind 'ctrl-/:toggle-preview'
  fzf --bind 'enter:become(vim {})'
  ```
  
  ### Key Actions (Selection)
  
  | Action | Description |
  |--------|-------------|
  | `accept` | Accept current selection |
  | `abort` | Abort and exit |
  | `toggle` | Toggle selection of current item |
  | `select-all` | Select all matches |
  | `deselect-all` | Deselect all |
  | `toggle-all` | Toggle all selections |
  
  ### Useful Actions
  
  | Action | Description |
  |--------|-------------|
  | `reload(cmd)` | Reload list from command |
  | `become(cmd)` | Replace fzf with command |
  | `execute(cmd)` | Run command, return to fzf |
  | `execute-silent(cmd)` | Run command silently |
  | `preview(cmd)` | Change preview command |
  | `toggle-preview` | Show/hide preview |
  | `change-prompt(str)` | Change prompt string |
  
  ### Events
  
  | Event | Triggered When |
  |-------|----------------|
  | `start` | fzf starts |
  | `load` | Input loading completes |
  | `change` | Query string changes |
  | `focus` | Focused item changes |
  | `result` | Result list updates |
  
  For complete action reference, see [references/actions.md](references/actions.md).
  
  ## Environment Variables
  
  ### Core Configuration
  
  ```bash
  # Default command when input is TTY
  export FZF_DEFAULT_COMMAND='fd --type f --hidden --follow --exclude .git'
  
  # Default options (applied to all fzf invocations)
  export FZF_DEFAULT_OPTS='--height 40% --layout reverse --border'
  
  # Options file (alternative to FZF_DEFAULT_OPTS)
  export FZF_DEFAULT_OPTS_FILE=~/.fzfrc
  ```
  
  ### Shell Integration Variables
  
  ```bash
  # CTRL-T options
  export FZF_CTRL_T_COMMAND="fd --type f"
  export FZF_CTRL_T_OPTS="--preview 'bat --color=always {}'"
  
  # CTRL-R options
  export FZF_CTRL_R_OPTS="--bind 'ctrl-y:execute-silent(echo -n {2..} | pbcopy)+abort'"
  
  # ALT-C options
  export FZF_ALT_C_COMMAND="fd --type d"
  export FZF_ALT_C_OPTS="--preview 'tree -C {}'"
  ```
  
  ### Completion Customization
  
  ```bash
  # Change trigger sequence (default: **)
  export FZF_COMPLETION_TRIGGER='~~'
  
  # Completion options
  export FZF_COMPLETION_OPTS='--border --info=inline'
  ```
  
  ## Common Patterns
  
  ### Find and Edit Files
  
  ```bash
  # Using fd for better performance
  fd --type f | fzf --preview 'bat --color=always {}' | xargs -o vim
  
  # Or with become()
  fd --type f | fzf --preview 'bat --color=always {}' --bind 'enter:become(vim {})'
  ```
  
  ### Search File Contents (with ripgrep)
  
  ```bash
  # Basic ripgrep integration
  rg --line-number . | fzf --delimiter : --preview 'bat --color=always {1} --highlight-line {2}'
  
  # Open result in vim at line
  rg --line-number . | fzf --delimiter : --bind 'enter:become(vim {1} +{2})'
  ```
  
  ### Git Integration
  
  ```bash
  # Select git branch
  git branch | fzf | xargs git checkout
  
  # Select commit
  git log --oneline | fzf --preview 'git show {1}' | cut -d' ' -f1
  
  # Stage files interactively
  git status -s | fzf -m | awk '{print $2}' | xargs git add
  ```
  
  ### Dynamic List Reloading
  
  ```bash
  # Reload process list with CTRL-R
  ps -ef | fzf --bind 'ctrl-r:reload(ps -ef)' --header 'Press CTRL-R to reload'
  
  # Toggle between files and directories
  fd | fzf --bind 'ctrl-d:reload(fd --type d)' --bind 'ctrl-f:reload(fd --type f)'
  ```
  
  ### Interactive ripgrep Launcher
  
  ```bash
  # fzf as ripgrep frontend (search updates on typing)
  RG_PREFIX="rg --column --line-number --no-heading --color=always"
  fzf --ansi --disabled \
      --bind "start:reload:$RG_PREFIX ''" \
      --bind "change:reload:$RG_PREFIX {q} || true" \
      --bind 'enter:become(vim {1} +{2})' \
      --delimiter :
  ```
  
  ## Placeholders
  
  Use in `--preview`, `--bind`, etc.:
  
  | Placeholder | Description |
  |-------------|-------------|
  | `{}` | Current selection (quoted) |
  | `{+}` | All selected items (space-separated) |
  | `{q}` | Current query string |
  | `{n}` | Zero-based index of current item |
  | `{1}`, `{2}`, etc. | Nth field (with --delimiter) |
  | `{-1}` | Last field |
  | `{1..3}` | Fields 1 through 3 |
  | `{2..}` | Fields 2 to end |
  
  **Flags:**
  - `{+}` - All selected items
  - `{f}` - Write to temp file (for large lists)
  - `{r}` - Raw (unquoted) output
  
  ## Advanced Topics
  
  For detailed documentation on advanced features, see:
  
  - [references/actions.md](references/actions.md) - Complete list of bindable actions
  - [references/options.md](references/options.md) - Full options reference
  - [references/integrations.md](references/integrations.md) - ripgrep, fd, git, bat integrations
  
  ## Troubleshooting
  
  **"Command not found: fzf"**
  - fzf is not installed. See Prerequisites section for manual installation instructions
  - Do NOT attempt automatic installation
  
  **Shell keybindings not working (CTRL-T, CTRL-R, ALT-C):**
  - Shell integration must be configured by the user
  - RECOMMEND adding the appropriate line to shell config (see Shell Integration section)
  - For bash, must be sourced after any PS1 modifications
  
  **Performance issues:**
  - Avoid `--ansi` in `FZF_DEFAULT_OPTS` (slows initial scan)
  - Use `--nth` sparingly (requires tokenization)
  - Prefer string `--delimiter` over regex
  
  **Preview not showing:**
  - Check preview command syntax
  - Use `{}` placeholder for current selection
  - Test preview command manually first
  
  **CTRL-R not finding old commands:**
  - fzf searches shell history, not history file
  - Increase `HISTSIZE` and `HISTFILESIZE`
  
  ## Resources
  
  - **Man page**: `man fzf` or `fzf --man`
  - **Wiki examples**: https://github.com/junegunn/fzf/wiki/examples
  - **Advanced examples**: https://github.com/junegunn/fzf/blob/master/ADVANCED.md
  - **Theme playground**: https://vitormv.github.io/fzf-themes/
  - **fzf-git.sh**: https://github.com/junegunn/fzf-git.sh (git keybindings)
  

• plugins/git-absorb/SKILL.mdskill
  Show content (7404 bytes)

  ---
  name: git-absorb
  description: Automatically fold uncommitted changes into appropriate commits on a feature branch. Use when applying review feedback, fixing bugs in feature branches, or maintaining atomic commit history without manual interactive rebasing. Particularly useful for making corrections to recent commits without creating messy "fixes" commits.
  ---
  
  # Git Absorb
  
  ## Overview
  
  `git absorb` automatically identifies which commits should contain your staged changes and creates fixup commits that can be autosquashed. This eliminates the need to manually find commit SHAs or run interactive rebases when applying review feedback or fixing bugs in feature branches.
  
  ## When to Use This Skill
  
  Use git-absorb when:
  - **Applying review feedback**: Reviewer pointed out bugs or improvements across multiple commits
  - **Fixing bugs**: Discovered issues in your feature branch that belong in specific earlier commits
  - **Maintaining atomic commits**: Want to keep commits focused without creating "fixes" or "oops" commits
  - **Avoiding manual rebasing**: Don't want to manually identify which commits need which changes
  
  ## Prerequisites
  
  **CRITICAL**: Before proceeding, you MUST verify that git-absorb is installed:
  
  ```bash
  git absorb --version
  ```
  
  **If git-absorb is not installed:**
  - **DO NOT** attempt to install it automatically
  - **STOP** and inform the user that git-absorb is required
  - **RECOMMEND** manual installation with the following instructions:
  
  ```bash
  # macOS
  brew install git-absorb
  
  # Linux (Debian/Ubuntu)
  apt install git-absorb
  
  # Arch Linux
  pacman -S git-absorb
  
  # Cargo (all platforms)
  cargo install git-absorb
  
  # Other systems: see https://github.com/tummychow/git-absorb
  ```
  
  **If git-absorb is not available, exit gracefully and do not proceed with the workflow below.**
  
  ### Important Default Behaviors
  
  Before using git-absorb, understand these key defaults:
  
  **Author Filtering**: By default, git-absorb **only modifies commits you authored**. It will not absorb changes into commits made by teammates.
  - To absorb into any author's commits, use `git absorb --force-author`
  - Or configure globally: `git config absorb.forceAuthor true`
  
  **Stack Size Limit**: By default, git-absorb searches only the **last 10 commits**. If you're working on a larger feature branch, you may need to:
  - Use `--base <branch>` to specify a range (e.g., `--base main`)
  - Or increase the limit in `.gitconfig` (see Configuration section below)
  
  **Staged Changes Only**: git-absorb only considers changes in the git index (staging area). Unstaged changes are ignored.
  
  ## Basic Workflow
  
  **ONLY proceed with this workflow if git-absorb is confirmed to be installed.**
  
  ### Step 1: Make Your Changes
  
  Make fixes or improvements to files in your working directory.
  
  ### Step 2: Stage the Changes
  
  ```bash
  git add <files-you-fixed>
  ```
  
  **Important**: Only stage changes you want absorbed. git-absorb only considers staged changes.
  
  ### Step 3: Run git absorb
  
  **Option A: Automatic (recommended for trust)**
  ```bash
  git absorb --and-rebase
  ```
  
  This creates fixup commits AND automatically rebases them into the appropriate commits.
  
  **Option B: Manual review**
  ```bash
  git absorb
  git log  # Review the generated fixup commits
  git rebase -i --autosquash <base-branch>
  ```
  
  Use this when you want to inspect the fixup commits before integrating them.
  
  ## Common Patterns
  
  ### Pattern 1: Review Feedback
  
  **Scenario**: PR reviewer found bugs in commits A, B, and C
  
  ```bash
  # 1. Make all the fixes
  vim file1.py file2.py file3.py
  
  # 2. Stage all fixes
  git add file1.py file2.py file3.py
  
  # 3. Let git-absorb figure out which fix goes where
  git absorb --and-rebase
  ```
  
  git-absorb analyzes each change and assigns it to the appropriate commit.
  
  ### Pattern 2: Bug Fix in Feature Branch
  
  **Scenario**: Found a bug in an earlier commit while developing
  
  ```bash
  # 1. Fix the bug
  vim src/module.py
  
  # 2. Stage and absorb
  git add src/module.py
  git absorb --and-rebase
  ```
  
  The fix is automatically folded into the commit that introduced the bug.
  
  ### Pattern 3: Multiple Small Fixes
  
  **Scenario**: Several typos, formatting issues across multiple commits
  
  ```bash
  # Fix everything first
  vim file1.py file2.py README.md
  
  # Stage and absorb in one go
  git add -A
  git absorb --and-rebase
  ```
  
  ## Advanced Usage
  
  For comprehensive coverage of all flags and advanced patterns, see [references/advanced-usage.md](references/advanced-usage.md).
  
  **Key flags:**
  - `--base <commit>`: Specify range (e.g., `--base main`)
  - `--dry-run`: Preview without making changes
  - `--force`: Skip safety checks
  - `--one-fixup-per-commit`: Generate one fixup per target commit
  - `--verbose`: See detailed output
  
  **Example:**
  ```bash
  git absorb --base main --dry-run --verbose
  ```
  
  ## Configuration
  
  For complete configuration reference with all options, see [references/configuration.md](references/configuration.md).
  
  **Most important configuration:**
  
  If you see "WARN stack limit reached, limit: 10", increase the stack size:
  
  ```bash
  git config absorb.maxStack 50  # Local
  git config --global absorb.maxStack 50  # Global
  ```
  
  By default, git-absorb only searches the last 10 commits. For larger feature branches, increase this to 50 or higher.
  
  **Other useful configs:**
  - `oneFixupPerCommit`: One fixup per commit instead of per hunk
  - `autoStageIfNothingStaged`: Auto-stage all changes if nothing staged
  - `forceAuthor`: Allow absorbing into teammates' commits
  
  See [references/configuration.md](references/configuration.md) for details and all 7 configuration options.
  
  ## Recovery
  
  If something goes wrong or you're not satisfied:
  
  ```bash
  git reset --soft PRE_ABSORB_HEAD
  ```
  
  This restores the state before running git-absorb. You can also find the commit in `git reflog`.
  
  ## How It Works
  
  git-absorb uses commutative patch theory:
  1. For each staged hunk, check if it commutes with the last commit
  2. If not, that's the parent commit for this change
  3. If it commutes with all commits in range, leave it staged (warning shown)
  4. Create fixup commits for absorbed changes
  
  This ensures changes are assigned to the correct commits based on line modification history.
  
  ## Safety Considerations
  
  - **Always review**: Use manual mode first until comfortable with automatic mode
  - **Local only**: Only use on local branches, never on shared/pushed commits
  - **Backup**: git-absorb is safe, but `git reflog` is your friend
  - **Test after**: Run tests after absorbing to verify nothing broke
  
  ## Troubleshooting
  
  **"WARN stack limit reached, limit: 10"**
  - git-absorb only searches the last 10 commits by default
  - Increase the stack size: `git config absorb.maxStack 50`
  - Or use `--base <branch>` to specify the range (e.g., `--base main`)
  - See the Configuration section above for details
  
  **"Can't find appropriate commit for these changes"**
  - The changes may be too new (modify lines not in recent commits)
  - Try increasing the range with `--base <branch>`
  - Try increasing stack size: `git config absorb.maxStack 50`
  - Changes may need to be in a new commit
  
  **"Command not found: git-absorb"**
  - Not installed. See Prerequisites section above for manual installation instructions
  - Do NOT attempt automatic installation
  
  **"Conflicts during rebase"**
  - Some changes couldn't be absorbed cleanly
  - Resolve conflicts manually or use `git rebase --abort`
  - Consider breaking changes into smaller pieces
  

• .claude-plugin/marketplace.jsonmarketplace
  Show content (16539 bytes)

  {
    "name": "alberto-marketplace",
    "owner": {
      "name": "Alberto Leal",
      "email": "mail4alberto@gmail.com"
    },
    "metadata": {
      "description": "Personal marketplace for custom skills and plugins",
      "version": "0.10.0"
    },
    "plugins": [
      {
        "name": "skill-creator",
        "version": "2.0.0",
        "source": "./plugins/skill-creator",
        "description": "Create new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.",
        "author": {
          "name": "Anthropic"
        },
        "repository": "https://github.com/anthropics/skills/tree/main/skill-creator",
        "license": "Apache-2.0",
        "keywords": ["skills", "development", "creation", "tooling"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "git-absorb",
        "version": "1.1.0",
        "source": "./plugins/git-absorb",
        "description": "Automatically fold uncommitted changes into appropriate commits. Use for applying review feedback and maintaining atomic commit history.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/git-absorb",
        "license": "MIT",
        "keywords": ["git", "workflow", "commits", "rebase", "fixup"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "tmux",
        "version": "1.5.0",
        "source": "./plugins/tmux",
        "description": "Remote control tmux sessions for interactive CLIs (python, gdb, etc.) by sending keystrokes and scraping pane output. Use when debugging applications, running interactive REPLs (Python, gdb, ipdb, psql, mysql, node), automating terminal workflows, or when user mentions tmux, debugging, or interactive shells.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/tmux",
        "license": "Vibecoded",
        "keywords": [
          "tmux",
          "terminal",
          "multiplexer",
          "interactive",
          "debugging",
          "repl"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "skill-reviewer",
        "version": "1.1.0",
        "source": "./plugins/skill-reviewer",
        "description": "Review and ensure skills maintain high quality standards. Use when creating new skills, updating existing skills, or auditing skill quality. Checks for progressive disclosure, mental model shift, appropriate scope, and documentation clarity.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/skill-reviewer",
        "license": "MIT",
        "keywords": [
          "skills",
          "quality",
          "review",
          "audit",
          "documentation",
          "best-practices"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "ultrathink",
        "version": "1.0.0",
        "source": "./plugins/ultrathink",
        "description": "Invoke deep sequential thinking for complex problem-solving. Use when the user says 'use ultrathink', 'ultrathink', or when tackling problems that require careful step-by-step reasoning, planning, hypothesis generation, or multi-step analysis.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/ultrathink",
        "license": "MIT",
        "keywords": [
          "thinking",
          "reasoning",
          "sequential",
          "planning",
          "analysis",
          "problem-solving"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "conventional-commits",
        "version": "1.0.0",
        "source": "./plugins/conventional-commits",
        "description": "Format git commit messages following Conventional Commits 1.0.0 specification. Use when the user asks to commit changes, create a git commit, or mentions committing code. Ensures consistent, semantic commit messages that support automated changelog generation and semantic versioning.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/conventional-commits",
        "license": "MIT",
        "keywords": [
          "git",
          "commits",
          "conventional-commits",
          "changelog",
          "semver",
          "versioning"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "git-chain",
        "version": "1.0.0",
        "source": "./plugins/git-chain",
        "description": "Manage and rebase chains of dependent Git branches (stacked branches). Use when working with multiple dependent PRs, feature branches that build on each other, or maintaining clean branch hierarchies. Automates rebasing or merging entire branch chains.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/git-chain",
        "license": "MIT",
        "keywords": [
          "git",
          "workflow",
          "branches",
          "stacked",
          "rebase",
          "merge",
          "chain",
          "dependent"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "jj",
        "version": "1.1.0",
        "source": "./plugins/jj",
        "description": "Jujutsu (jj) version control system - a Git-compatible VCS with novel features. Use when working with jj repositories, managing stacked commits, needing automatic rebasing with first-class conflict handling, using revsets to select commits, or wanting enhanced Git workflows. Triggers on mentions of 'jj', 'jujutsu', change IDs, or operation log.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/jj",
        "license": "MIT",
        "keywords": [
          "jj",
          "jujutsu",
          "vcs",
          "version-control",
          "git",
          "revsets",
          "bookmarks",
          "conflicts"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "fzf",
        "version": "1.0.0",
        "source": "./plugins/fzf",
        "description": "Command-line fuzzy finder for interactive filtering. Use when searching files, command history (CTRL-R), creating interactive menus, or integrating with ripgrep, fd, and git. Triggers on fzf, fuzzy finder, ** completion, or CTRL-T/CTRL-R/ALT-C keybindings.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/fzf",
        "license": "MIT",
        "keywords": [
          "fzf",
          "fuzzy",
          "search",
          "filter",
          "interactive",
          "shell",
          "cli",
          "completion"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "playwright",
        "version": "1.0.0",
        "source": "./plugins/playwright",
        "description": "Browser automation with Playwright for Python. Use when testing websites, taking screenshots, filling forms, scraping web content, or automating browser interactions. Triggers on browser, web testing, screenshots, selenium, puppeteer, or playwright.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/playwright",
        "license": "MIT",
        "keywords": [
          "playwright",
          "browser",
          "automation",
          "testing",
          "screenshots",
          "web",
          "scraping",
          "python"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "zellij",
        "version": "1.0.0",
        "source": "./plugins/zellij",
        "description": "Terminal workspace and multiplexer for interactive CLI sessions. Use when managing terminal sessions, running interactive REPLs, debugging, automating terminal workflows, or when user mentions zellij, floating panes, or session layouts. Simpler alternative to tmux.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/zellij",
        "license": "MIT",
        "keywords": [
          "zellij",
          "terminal",
          "multiplexer",
          "workspace",
          "panes",
          "tabs",
          "layouts",
          "interactive",
          "sessions"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "design-principles",
        "version": "1.0.0",
        "source": "./plugins/design-principles",
        "description": "Guide AI-assisted UI generation toward enterprise-grade design. Use when building UIs, creating dashboards, designing SaaS applications, or generating styled frontend code. Enforces 4px grids, typography hierarchies, and consistent depth strategies.",
        "author": {
          "name": "Dammyjay93"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/design-principles",
        "license": "MIT",
        "keywords": [
          "ui",
          "design",
          "interface",
          "frontend",
          "dashboard",
          "styling",
          "enterprise",
          "saas"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "mermaid-cli",
        "version": "1.0.0",
        "source": "./plugins/mermaid-cli",
        "description": "Generate, validate, and fix diagrams from Mermaid markup using mmdc. Use when creating flowcharts, sequence diagrams, class diagrams, converting .mmd files to images/SVG/PDF, or validating and fixing Mermaid diagram syntax.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/mermaid-cli",
        "license": "MIT",
        "keywords": [
          "mermaid",
          "diagrams",
          "flowchart",
          "sequence-diagram",
          "svg",
          "png",
          "pdf",
          "visualization",
          "cli",
          "mmdc"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "walkthrough-to-obsidian",
        "version": "1.0.0",
        "source": "./plugins/walkthrough-to-obsidian",
        "description": "Convert game walkthroughs and guides from plain text into structured, interlinked Obsidian markdown pages. Use when the user wants to convert a walkthrough, FAQ, guide, or reference document into Obsidian vault pages. Triggers on mentions of converting walkthroughs, guides, or FAQs to Obsidian, or splitting a large text file into Obsidian pages.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/walkthrough-to-obsidian",
        "license": "MIT",
        "keywords": [
          "obsidian",
          "walkthrough",
          "guide",
          "conversion",
          "markdown",
          "wiki",
          "knowledge-base",
          "gaming"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "long-form-math",
        "version": "1.0.0",
        "source": "./plugins/long-form-math",
        "description": "Write mathematics in a long-form, understanding-focused style with detailed proofs and rich exposition. Use when explaining mathematical concepts, writing proofs, tutoring math, creating educational math content, or when the user asks for mathematical explanations. Inspired by Jay Cummings' Real Analysis and Chartrand's Mathematical Proofs.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/long-form-math",
        "license": "MIT",
        "keywords": [
          "mathematics",
          "proofs",
          "exposition",
          "long-form",
          "tutoring",
          "education",
          "real-analysis",
          "writing"
        ],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "linear",
        "version": "2.3.1",
        "source": "./plugins/linear",
        "description": "Managing Linear issues, projects, and teams. Use when working with Linear tasks, creating issues, updating status, querying projects, or managing team workflows.",
        "author": {
          "name": "Will Smith"
        },
        "repository": "https://github.com/wrsmith108/linear-claude-skill",
        "license": "MIT",
        "keywords": ["linear", "project-management", "issues", "teams"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "ai-friendly-cli",
        "version": "1.0.0",
        "source": "./plugins/ai-friendly-cli",
        "description": "Build and refactor CLIs for AI agent compatibility. Use when making CLI tools machine-readable with structured JSON output, input hardening, schema introspection, dry-run safety, and MCP surfaces.",
        "author": {
          "name": "Alberto Leal"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/ai-friendly-cli",
        "license": "MIT",
        "keywords": ["cli", "ai-agents", "llm", "machine-readable", "json-output", "input-validation", "mcp", "developer-experience"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "chrome-cdp",
        "version": "1.0.0",
        "source": "./plugins/chrome-cdp",
        "description": "Interact with local Chrome browser session via Chrome DevTools Protocol. Use when asked to inspect, debug, or interact with a page open in Chrome, take screenshots, read accessibility trees, evaluate JavaScript, click elements, or navigate pages.",
        "author": {
          "name": "Petr Baudis"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/chrome-cdp",
        "license": "MIT",
        "keywords": ["chrome", "cdp", "browser", "devtools", "debugging"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "react-best-practices",
        "version": "1.0.0",
        "source": "./plugins/react-best-practices",
        "description": "React and Next.js performance optimization guidelines from Vercel Engineering. Use when writing, reviewing, or refactoring React/Next.js code for optimal performance. 62 rules across 8 categories covering waterfalls, bundle size, server-side, re-renders, and rendering.",
        "author": {
          "name": "Vercel Engineering"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/react-best-practices",
        "license": "MIT",
        "keywords": ["react", "nextjs", "performance", "optimization", "vercel", "best-practices"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "gogcli",
        "version": "1.0.0",
        "source": "./plugins/gogcli",
        "description": "Drive Google Workspace from the terminal with the `gog` CLI (gogcli). Use when sending/searching Gmail, managing Calendar events, uploading to Drive, editing Docs/Sheets/Slides, posting to Chat, managing Tasks/Contacts, administering Workspace via DWD, or building agent workflows needing JSON output, OAuth/service-account auth, Pub/Sub watches, and a command sandbox. Covers Gmail, Calendar, Drive, Docs, Slides, Sheets, Chat, Tasks, Contacts, Classroom, Forms, Keep, Admin.",
        "author": {
          "name": "Peter Steinberger (steipete)"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/gogcli",
        "license": "MIT",
        "keywords": ["google", "gmail", "calendar", "drive", "sheets", "docs", "cli", "workspace", "automation"],
        "strict": false,
        "skills": ["./"]
      },
      {
        "name": "pup",
        "version": "1.0.0",
        "source": "./plugins/pup",
        "description": "Datadog CLI (pup) for observability, monitoring, logs, APM, security, and infrastructure. Use when querying Datadog metrics, searching logs, managing monitors, investigating incidents, or performing Datadog API operations.",
        "author": {
          "name": "Datadog"
        },
        "repository": "https://github.com/dashed/claude-marketplace/tree/master/plugins/pup",
        "license": "Apache-2.0",
        "keywords": ["datadog", "cli", "monitoring", "observability", "logs", "metrics", "apm", "security", "infrastructure", "incidents"],
        "strict": false,
        "skills": ["./"]
      }
    ]
  }
  

README

# 1. Add the marketplace
/plugin marketplace add /path/to/claude-marketplace

# 2. Install skills
/plugin  # Browse and install plugins → alberto-marketplace

# 3. Restart Claude Code to load new skills
/exit

./scripts/install_codex_skills.py

./scripts/manage_codex_skills.py
# or
make manage-codex-skills

# Preview changes without creating links
./scripts/install_codex_skills.py --dry-run

# Replace existing symlinks that point somewhere else
./scripts/install_codex_skills.py --force

# Install links into a personal Codex skills directory
./scripts/install_codex_skills.py --dest "$HOME/.agents/skills"

# List current Codex skill state
./scripts/manage_codex_skills.py --list

# Enable, disable, or uninstall individual skills
./scripts/manage_codex_skills.py --enable tmux
./scripts/manage_codex_skills.py --disable tmux
./scripts/manage_codex_skills.py --uninstall tmux

make test-codex-skills

# 1. Enable remote debugging in Chrome
#    Navigate to chrome://inspect/#remote-debugging and toggle the switch

# 2. Install the websockets dependency
uv pip install websockets

# 1. Install dependencies in the plugin cache directory
cd ~/.claude/plugins/cache/alberto-marketplace/linear/2.3.1
npm install

# 2. Create a Linear API key at https://linear.app/settings/api
# 3. Add to your shell profile (~/.zshrc or ~/.bashrc)
export LINEAR_API_KEY="lin_api_..."

# Install Chromium (recommended, ~200MB)
uv run --with playwright playwright install chromium

# Or install all browsers
uv run --with playwright playwright install

/plugin marketplace add /path/to/claude-marketplace

/plugin marketplace update alberto-marketplace

./scripts/install_codex_skills.py

./scripts/manage_codex_skills.py
# or
make manage-codex-skills

{
  "name": "your-skill-name",
  "source": "./plugins/your-skill-name",
  "description": "Brief description of what the skill does",
  "strict": false,
  "skills": ["./"]
}

# Claude Code personal (available everywhere)
cp -r plugins/your-skill ~/.claude/skills/

# Claude Code project (shared with team)
cp -r plugins/your-skill .claude/skills/

# Codex repo-local links
./scripts/install_codex_skills.py

# Codex personal links
./scripts/install_codex_skills.py --dest "$HOME/.agents/skills"

# Codex interactive manager
./scripts/manage_codex_skills.py

claude-marketplace/
├── .agents/
│   └── skills/              # Generated Codex symlinks
├── .claude-plugin/
│   └── marketplace.json      # Marketplace manifest
├── plugins/
│   └── skill-creator/        # Skills directory
│       ├── SKILL.md          # Skill definition
│       ├── scripts/          # Optional scripts
│       └── references/       # Optional documentation
├── scripts/
│   ├── install_codex_skills.py # Codex symlink installer
│   └── manage_codex_skills.py  # Codex interactive manager
├── CHANGELOG.md              # Version history
└── README.md                 # This file