make create-pr, follow-up-on-pr, and http-toolkit-intercept language/framework agnostic

Addresses PR #24 review feedback from @factory-davidgu. Generalize the
three skills away from JS/TS (npm/turbo) and Bun/Node specifics:
- create-pr: describe verification categories and show examples across
  ecosystems (JS/TS, Python, Rust, Go, JVM, Ruby) instead of hard-coded
  npm/turbo commands.
- follow-up-on-pr: same generalization for the CI-check step.
- http-toolkit-intercept: replace Bun-centric guidance with a runtime
  proxy matrix covering Node, Bun, Deno, Python, Go, Ruby, JVM, .NET,
  PHP, Rust, curl/shell, and Docker.

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

Author: alvinsng

README.md

@@ -70,7 +70,7 @@ Inspect runtime behavior: HTTP interception, traffic capture, and wire-level deb
 
 **Skills:**
 
-- `http-toolkit-intercept` - Intercept and debug HTTP traffic from a Bun/Node CLI via HTTP Toolkit
+- `http-toolkit-intercept` - Intercept and debug HTTP traffic from any CLI, service, or script via HTTP Toolkit (language/runtime agnostic)
 
 ### code-review
 

plugins/code-review/skills/create-pr/SKILL.md

@@ -5,7 +5,7 @@ description: Create a pull request with Conventional Commits formatting, a templ
 
 # Create Pull Request
 
-Create a PR with proper conventions: local verification, Conventional Commits title, a templated body, and an optional linked ticket.
+Create a PR with proper conventions: local verification, Conventional Commits title, a templated body, and an optional linked ticket. This skill is language- and framework-agnostic — substitute your project's actual build, lint, test, and format commands where examples are shown.
 
 ## Prerequisites
 
@@ -25,51 +25,57 @@ git diff origin/<base-branch>..HEAD --stat
 ```
 
 Determine:
-- **What changed**: Which apps/packages were modified
+- **What changed**: Which modules, packages, services, or directories were modified
 - **Change type**: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`, `perf`, `ci`, `build`, `revert`
-- **Scope**: Primary workspace affected (use directory name or `monorepo` for cross-cutting changes)
-- **Is this a code change?**: If the PR modifies code (not only docs, markdown, or config-only changes), run the local verification checklist in step 2 before creating the PR.
+- **Scope**: Primary module/package/service affected (use directory name or `monorepo` / `repo` for cross-cutting changes)
+- **Is this a code change?**: If the PR modifies source code (not only docs, markdown, or config-only changes), run the local verification checklist in step 2 before creating the PR.
 
 ### 2. Local Verification (for code changes)
 
-**Skip this step** if the PR only touches documentation, markdown files, or other non-code files. For any change that touches `.ts`, `.tsx`, `.js`, `.jsx`, `.css`, or similar source files, run these checks locally before creating the PR.
+**Skip this step** if the PR only touches documentation, markdown files, or other non-code files. For any change that touches source files, run your project's verification commands locally before creating the PR.
 
-Use a filter flag (turbo `--filter`, nx `--projects`, pnpm `--filter`) to target only the affected workspaces when possible — it is faster than running the whole repo.
+Discover the commands by reading the repo root (e.g. `Makefile`, `package.json`, `pyproject.toml`, `Cargo.toml`, `go.mod`, `build.gradle`, `mix.exs`, `Gemfile`, `composer.json`, `justfile`, `Taskfile.yml`, `README.md`, or the CI workflow config). Use filter/target flags where available (e.g. `turbo --filter`, `nx --projects`, `pnpm --filter`, `bazel //path/...`, `cargo -p <crate>`, `pytest <path>`, `go test ./<pkg>/...`) to run only the affected portions — it is faster than running the whole repo.
 
-#### Typecheck
-```bash
-# Repo-wide
-npm run typecheck
-# Filtered to affected workspaces (preferred — faster)
-npm run typecheck -- --filter=<workspace1> --filter=<workspace2>
-```
+Common verification categories to run when applicable:
 
-#### Lint
-```bash
-# Autofix (preferred — fixes formatting + lint in one pass)
-npm run fix
-# Or filtered
-npm run fix -- --filter=<workspace>
-# Lint-only (no autofix)
-npm run lint
-```
+#### Typecheck / Compile
+Run the project's static type check or compile step if it has one.
+
+Examples across ecosystems (use whatever the repo defines):
+- TypeScript: `npm run typecheck`, `pnpm -r typecheck`, `tsc --noEmit`
+- Python (typed): `mypy .`, `pyright`, `ty check`
+- Rust: `cargo check`
+- Go: `go build ./...`, `go vet ./...`
+- Java/Kotlin: `./gradlew compileJava`, `./mvnw compile`
+
+#### Lint / Format
+Run the project's linter and formatter. Prefer an autofix target if one exists.
+
+Examples:
+- JS/TS: `npm run fix`, `npm run lint`, `eslint .`, `prettier --check .`
+- Python: `ruff check --fix .`, `ruff format .`, `black .`, `flake8`
+- Rust: `cargo clippy --all-targets`, `cargo fmt --check`
+- Go: `golangci-lint run`, `gofmt -l .`
+- Shell: `shellcheck`, `shfmt -d .`
 
 #### Tests
-```bash
-# Repo-wide (slow — runs all workspaces)
-npm run test
-# Filtered to affected workspaces (preferred)
-npm run test -- --filter=<workspace>
-```
+Run the unit/integration tests for affected packages.
 
-#### Additional checks (run when relevant)
-- **Knip** (unused exports): `npm run knip` — always run if you added/removed exports.
-- **Depcheck**: `npm run depcheck` — run if you changed dependencies.
-- **Lockfile**: If you modified any `package.json`, run `npm install` at repo root and commit any `package-lock.json` changes. CI fails if the lockfile is out of date.
-- **OpenAPI / codegen**: If your backend has an OpenAPI spec or generated client, regenerate and commit any changes.
-- **Stylelint**: `npm run stylelint` — run if you changed CSS/style files.
+Examples:
+- JS/TS: `npm run test -- --filter=<workspace>`, `pnpm -r test`, `vitest run <path>`, `jest <path>`
+- Python: `pytest <path>`, `tox -e <env>`, `python -m unittest`
+- Rust: `cargo test -p <crate>`
+- Go: `go test ./<pkg>/...`
+- Java/Kotlin: `./gradlew test`, `./mvnw test`
+- Ruby: `bundle exec rspec <path>`, `rake test`
 
-Substitute your package manager and check names if you do not use npm / turbo.
+#### Additional checks (run when relevant)
+- **Unused exports / dead code**: Run your project's dead-code check if it has one (e.g. `knip`, `ts-prune`, `vulture` for Python, `deadcode` / `unused` for Go, `cargo udeps` for Rust).
+- **Dependency hygiene**: Run your project's dependency check if it has one (e.g. `depcheck`, `pip check`, `cargo audit`, `bundle audit`).
+- **Lockfile in sync**: If you modified any dependency manifest (`package.json`, `requirements.txt`, `pyproject.toml`, `Cargo.toml`, `go.mod`, `Gemfile`, etc.), run the install command (`npm install`, `pnpm install`, `uv sync`, `poetry lock --no-update`, `cargo update -w`, `go mod tidy`, `bundle install`) and commit any lockfile changes. CI commonly fails if the lockfile is out of date.
+- **Generated code / codegen**: If the repo has an OpenAPI spec, protobuf, GraphQL schema, SQL migrations, or any other generated artifacts, regenerate and commit any changes.
+- **Style / asset linters**: Run stylesheet linters (`stylelint`, etc.) or asset linters if you changed those files.
+- **Security scans**: Run any security/secret scanners configured in the repo (`trivy`, `semgrep`, `gitleaks`, etc.).
 
 ### 3. Link to a Ticket (optional)
 
@@ -85,11 +91,12 @@ Most CI systems can be configured to require the ticket identifier in the PR bod
 Follow Conventional Commits: `type(scope): description`
 
 - `type`: `feat`, `fix`, `docs`, `refactor`, `test`, `chore`, `perf`, `ci`, `build`, `revert`
-- `scope`: Workspace name from your `apps/*` or `packages/*` directories, or `monorepo` / `repo` for cross-cutting changes. Multiple scopes can be comma-separated: `fix(a, b, c): ...`
+- `scope`: Name of the affected module/package/service/directory, or `monorepo` / `repo` for cross-cutting changes. Multiple scopes can be comma-separated: `fix(a, b, c): ...`
 
 Examples:
 - `feat(web): add dark mode toggle`
 - `fix(cli, daemon): load shell env at entrypoint`
+- `fix(api): handle nil response from upstream`
 - `chore(repo): bump dependencies`
 
 ### 5. Generate PR Body
@@ -137,25 +144,24 @@ Return the PR URL to the user.
 
 ## CI Checks Reference (template)
 
-These are typical checks that run on every PR. Map them to your repo's actual commands when adapting this skill.
+These are typical check categories that run on every PR. Map them to your repo's actual commands when adapting this skill.
 
 ### Always-run checks
-| Check | What it does | Local equivalent |
+| Category | What it does | How to find the local command |
 |---|---|---|
-| **Typecheck** | `npm run typecheck` | `npm run typecheck` (or `--filter=<workspace>`) |
-| **ESLint** | `npm run lint` | `npm run lint` or `npm run fix` |
-| **Prettier** | `npm exec prettier -- --check .` | `npm run format` (to fix) |
-| **Stylelint** | `npm run stylelint` | `npm run stylelint` |
-| **Depcheck** | `npm run depcheck` | `npm run depcheck` |
-| **Tests** | `turbo run test` (or equivalent) | `npm run test -- --filter=<workspace>` |
-| **Knip** | `npm run knip` | `npm run knip` |
-| **Lockfile** | Fails if `npm install` would modify `package-lock.json` | Run `npm install` and commit lockfile |
+| **Typecheck / compile** | Verifies the project compiles or passes static types | Check `package.json`, `Makefile`, `pyproject.toml`, `Cargo.toml`, `go.mod`, CI config |
+| **Lint** | Enforces code style / correctness rules | Check for `lint`, `check`, or equivalent scripts in the repo root |
+| **Format** | Enforces consistent formatting | Check for `format`, `fmt`, `prettier`, `black`, `gofmt`, `rustfmt`, etc. |
+| **Tests** | Runs unit and integration tests | Check for `test` script / target |
+| **Dead code / unused exports** | Flags unused code | Check for `knip`, `ts-prune`, `vulture`, `cargo udeps`, etc. |
+| **Dependency check** | Flags unused / vulnerable dependencies | Check for `depcheck`, `audit`, `cargo audit`, etc. |
+| **Lockfile in sync** | Fails if lockfile is stale relative to the manifest | Run your package manager's install command and commit the lockfile |
 | **PR Conventions** | Validates branch name, semantic title, ticket presence | Follow the formatting rules above |
 
 ### Conditional checks (run only when affected files change)
-- **OpenAPI validation**: Triggered by backend API/spec changes. Regenerate locally.
-- **Desktop/mobile build**: Triggered when those apps are affected.
-- **E2E tests**: Triggered when the consumer app is affected.
+- **API / schema validation**: Triggered by API or schema changes. Regenerate locally.
+- **Platform-specific builds**: Triggered when desktop/mobile/embedded targets are affected.
+- **E2E tests**: Triggered when the consumer app or top-level binary is affected.
 
 ### Typical PR conventions CI enforces
 - **Branch name**: Max length, allowed characters (e.g. `[A-Za-z0-9/-]`).
@@ -164,10 +170,10 @@ These are typical checks that run on every PR. Map them to your repo's actual co
 
 ## Common Mistakes to Avoid
 
-- **Wrong base branch**: Use the branch your org takes PRs into (e.g. `dev`, `main`, `develop`).
+- **Wrong base branch**: Use the branch your org takes PRs into (e.g. `dev`, `main`, `develop`, `trunk`).
 - **Missing scope**: PR title CI check often requires a valid scope.
 - **Missing ticket reference**: Description must reference your ticket ID for CI to pass (except `chore:`/`revert:`).
 - **Forgetting to push**: Branch must be on remote before `gh pr create`.
-- **Lockfile drift**: Always run `npm install` and commit `package-lock.json` after dependency changes.
-- **Skipping local checks on code PRs**: Typecheck, lint, and tests should be run locally before sending out code changes to catch issues early and avoid CI round-trips.
-- **Uncommitted OpenAPI spec / generated client**: After backend API changes, regenerate and commit.
+- **Lockfile drift**: Always run the install command and commit lockfile changes after dependency changes.
+- **Skipping local checks on code PRs**: Typecheck/compile, lint, and tests should be run locally before sending out code changes to catch issues early and avoid CI round-trips.
+- **Uncommitted generated artifacts**: After API/schema changes, regenerate and commit.

plugins/code-review/skills/follow-up-on-pr/SKILL.md

@@ -5,7 +5,7 @@ description: Follow up on an existing PR by rebasing on the base branch, address
 
 # Follow Up on PR
 
-Take over an existing PR, bring it up to date, address all feedback, and push it to a merge-ready state.
+Take over an existing PR, bring it up to date, address all feedback, and push it to a merge-ready state. This skill is language- and framework-agnostic — substitute your project's actual build, lint, test, and format commands where examples are shown.
 
 ## Inputs
 
@@ -61,21 +61,23 @@ Review comments were already fetched in step 1. For each unresolved comment:
 
 ### 5. Run Local CI Checks
 
-Run checks targeted to the affected packages. Use your package-manager's filter flag for speed (e.g. turbo `--filter`, nx `--projects`, pnpm `--filter`).
+Run the project's lint, format, typecheck/compile, and test commands for the affected areas. Discover them by reading the repo root (e.g. `Makefile`, `package.json`, `pyproject.toml`, `Cargo.toml`, `go.mod`, `build.gradle`, `mix.exs`, `Gemfile`, `composer.json`, `justfile`, `Taskfile.yml`, `README.md`, or the CI workflow config).
 
-```bash
-# Example with npm + turbo
-npm run fix -- --filter=<workspace1> --filter=<workspace2>
-npm run typecheck -- --filter=<workspace1> --filter=<workspace2>
-npm run test -- --filter=<workspace1> --filter=<workspace2>
-```
+Prefer filter / target flags to scope runs to the affected areas — it is faster than running the whole repo. Common patterns:
+
+- JS/TS monorepos: `npm run test -- --filter=<workspace>`, `pnpm -r --filter <pkg> test`, `nx test <project>`
+- Python: `pytest <path>`, `tox -e <env>`
+- Rust: `cargo test -p <crate>`, `cargo clippy -p <crate>`
+- Go: `go test ./<pkg>/...`, `golangci-lint run ./<pkg>/...`
+- Java/Kotlin: `./gradlew :<module>:test`, `./mvnw -pl <module> test`
+- Bazel: `bazel test //path/...`
 
-See the `create-pr` skill's "CI Checks Reference" section for a template of local commands matching common CI checks.
+See the `create-pr` skill's "CI Checks Reference" section for a broader template of local commands matching common CI checks.
 
 **Distinguishing pre-existing failures from PR issues:**
-Some CI failures exist on the base branch and are unrelated to the PR. If a failure occurs in a file not touched by the PR, verify it exists on the base branch too before spending time fixing it. Common pre-existing issues include module resolution errors for recently-added dependencies.
+Some CI failures exist on the base branch and are unrelated to the PR. If a failure occurs in a file not touched by the PR, verify it exists on the base branch too before spending time fixing it. Common pre-existing issues include module / package resolution errors for recently-added dependencies.
 
-**E2E tests:** If the PR changes user-facing behavior (UI flow, defaults, keyboard handling), E2E tests may break even if the code is correct. Read the failing test to understand what it expects, then update it to match the new behavior. Don't assume E2E failures are flaky — read them first.
+**E2E tests:** If the PR changes user-facing behavior (UI flow, defaults, keyboard handling, CLI output), E2E tests may break even if the code is correct. Read the failing test to understand what it expects, then update it to match the new behavior. Don't assume E2E failures are flaky — read them first.
 
 ### 6. Commit and Push
 
@@ -136,7 +138,7 @@ Use your org's PR template format. Update the testing section to reflect the add
 Before considering the task complete, confirm:
 - [ ] Branch is rebased on the latest base branch
 - [ ] All reviewer comments are addressed with code changes
-- [ ] Local lint, typecheck, and tests pass for affected packages
+- [ ] Local lint, typecheck/compile, and tests pass for affected packages
 - [ ] Changes are pushed to remote
 - [ ] All reviewer comments have replies explaining what was done
 - [ ] PR description is up to date

plugins/debugging/README.md

@@ -6,7 +6,7 @@ Tools for inspecting what code actually does at runtime: HTTP traffic, wire-leve
 
 ### `http-toolkit-intercept`
 
-Intercept and debug HTTP traffic from a Bun- or Node-based CLI using HTTP Toolkit. Pairs the outbound proxy log with a machine-readable CLI session log so you can verify LLM API calls, backend requests, auth flows, and wire-level behavior.
+Intercept and debug HTTP traffic from any CLI, service, or script using HTTP Toolkit. Works with any runtime (Node.js, Bun, Deno, Python, Go, Ruby, Java, .NET, Rust, shell, etc.) that respects a proxy. Pairs the outbound proxy log with a machine-readable session log so you can verify LLM API calls, backend requests, auth flows, and wire-level behavior.
 
 ## Install