Skip to content
Back to search

gnawky-marketplace

MarketplaceWorks with Claude CodeGitHub

Gnawky is a local security scanner for Node.js projects. It combines proven open-source scanners, writes one report, and lets you choose per finding: fix, ignore (with a reason), or skip. It also…

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/andreiciungan--gnawky/badge.svg)](/listings/andreiciungan--gnawky)

HTML

<a href="/listings/andreiciungan--gnawky"><img src="/api/listings/andreiciungan--gnawky/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Gnawky needs Node 18 or newer and has no npm dependencies of its own.

npm install -g gnawky      # npm
yarn global add gnawky     # Yarn 1
npx gnawky                 # or try it once, without installing

Gnawky works the same whether you install it with npm or Yarn: it checks which one the scanned project uses.

**Windows:** run Gnawky inside [WSL](https://learn.microsoft.com/windows/wsl/install) (for example Ubuntu) for full support. Natively on Windows the dependency audit and gitleaks should work, but this hasn't been tested yet: semgrep may not be available, the tool installer offers nothing, and Claude triage is turned off.

**From source:** clone this repository and run `npm link` inside it.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 7 lines
  1. {
  2. "name": "gnawky-marketplace",
  3. "owner": { "name": "Andrei Ciungan" },
  4. "plugins": [
  5. { "name": "gnawky", "source": "./", "description": "Security scan for Node.js projects with guided fixes." }
  6. ]
  7. }
README.md · README · 248 lines
  1. <p align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png">
  4. <img src="assets/logo-light.png" alt="Gnawky: gnaws through your code, watches like a hawk" width="560">
  5. </picture>
  6. </p>
  7. # Gnawky
  8. Gnawky is a local security scanner for Node.js projects. It combines proven open-source scanners, writes one report, and lets you choose per finding: **fix**, **ignore (with a reason)**, or **skip**. It also ships as a Claude Code plugin that explains findings and proposes fixes.
  9. It can also stop risky packages before they reach your project: a [check before `npm install <pkg>` / `yarn add`](#checking-packages-before-you-install-them), pasted commands included, and a [pre-commit check](#pre-commit-dependency-check) that blocks commits adding vulnerable dependencies.
  10. **New to Gnawky?** The [presentation](https://webdevs.ro/gnawky/) walks through what it does, how to use it and why.
  11. ## What it checks
  12. | Scanner | Finds | Required? |
  13. |---|---|---|
  14. | `npm audit` / `yarn audit` | Known-vulnerable dependencies (`package-lock.json` or a Yarn 1 `yarn.lock`) | Yes (npm comes with Node; yarn projects need `yarn`) |
  15. | Next.js bundled React | React Server Components advisories in the copy of React that Next.js bundles, which `npm audit` can't see | Built in, only in Next.js projects (needs `node_modules` and Online mode) |
  16. | [gitleaks](https://github.com/gitleaks/gitleaks) | Secrets in files and git history | Optional, recommended |
  17. | [semgrep](https://semgrep.dev) | Risky code (injection, XSS, unsafe `eval`, etc.) | Optional, recommended |
  18. | Full audit (Claude + Cloudflare's security-audit skill) | Vulnerabilities in your own logic that pattern scanners miss | Optional, started from AI tools in the menu |
  19. Missing optional scanners are reported as "skipped", never silently ignored. While a scan runs, each scanner shows a live line with a running clock, and the summary lists how long each one took. Semgrep stops after 30 minutes with a clear message instead of hanging.
  20. **Next.js bundled React.** Next.js ships its own copy of React's server code, and it patches that copy without changing its version, so neither `npm audit` nor a version check can tell whether your Next.js has a React fix. Gnawky reports only what is certain: React Server Components advisories disclosed *after* your installed Next.js was released, which that release can't contain. It stays quiet for newer releases; once Next.js publishes its own advisory, `npm audit` reports it. Dates come from the GitHub API (60 requests an hour without a token, or set `GITHUB_TOKEN`) and are cached in `.gnawky/cache/`.
  21. ```bash
  22. brew install gitleaks semgrep # macOS
  23. pipx install semgrep # alternative for semgrep
  24. ```
  25. ## Install
  26. Gnawky needs Node 18 or newer and has no npm dependencies of its own.
  27. ```bash
  28. npm install -g gnawky # npm
  29. yarn global add gnawky # Yarn 1
  30. npx gnawky # or try it once, without installing
  31. ```
  32. Gnawky works the same whether you install it with npm or Yarn: it checks which one the scanned project uses.
  33. **Windows:** run Gnawky inside [WSL](https://learn.microsoft.com/windows/wsl/install) (for example Ubuntu) for full support. Natively on Windows the dependency audit and gitleaks should work, but this hasn't been tested yet: semgrep may not be available, the tool installer offers nothing, and Claude triage is turned off.
  34. **From source:** clone this repository and run `npm link` inside it.
  35. ## Usage
  36. Start Gnawky **inside the project you want to scan**:
  37. ```bash
  38. cd ~/code/my-app
  39. gnawky
  40. ```
  41. The first time you start Gnawky in a project, a short setup runs:
  42. 1. **Your project:** detects the stack (TypeScript, Express, React, Next.js, Docker, GitHub Actions, databases, auth libraries), checks for a lockfile and git, and warns if a `.env` file is not ignored by git. It only reads `package.json` and file names.
  43. 2. **Network access:** choose **Online** (recommended: the dependency audit sends your dependency list to the npm registry, semgrep downloads its rulesets, and the AI tools are available) or **Offline** (nothing leaves this computer, but only gitleaks runs unless you add a local semgrep rules file, and the AI tools are off). Saved per project; change it any time in Settings. Starting with `gnawky --offline` pre-selects Offline.
  44. 3. **Recommended tools:** shows which scanners fit the project and which are missing, and installs them with Homebrew (or pipx for semgrep) if you choose to. It also recommends the [package check](#checking-packages-before-you-install-them) and the [pre-commit check](#pre-commit-dependency-check) when they aren't on yet.
  45. 4. **First scan:** saves semgrep rules that match the stack (for example `p/expressjs`, `p/react`, `p/dockerfile`) and offers to run the first scan.
  46. You can run the setup again from Settings. After that you get an interactive menu (arrow keys + Enter, or number keys; `q`/Esc goes back):
  47. ```
  48. gnawky my-app /Users/you/code/my-app
  49. Last scan 27/09/2026 10:14: 1 high, 2 medium
  50. ──────────────────────────────────────────
  51. What would you like to do?
  52. ❯ 1. Scan again
  53. 2. Findings (3)
  54. 3. AI tools
  55. 4. View report
  56. 5. Settings
  57. 6. Tools & scanners
  58. Quit
  59. ```
  60. **Findings** and **AI tools** open a submenu. After an action you come back to the same submenu; `q`/Esc or "← Back" returns to the main menu.
  61. 1. **Scan again** (**Run security scan** before the first scan): runs every enabled scanner with a live progress line each, then writes the reports.
  62. 2. **Findings** (submenu):
  63. - **Review & fix**: go through findings one by one and choose fix, skip, or ignore. Nothing happens until you confirm the final plan.
  64. - **Grouped advisories**: dependency advisories that one change fixes are one item, so an old Next.js with 36 advisories is one decision instead of 36. They are grouped by the package the fix upgrades: a `postcss` advisory fixed by upgrading `next` sits in the `next` item ("Also covers: postcss (4)"). If only some advisories in an item can be fixed automatically, the item says so and the rest keep their manual fix. npm audit suggests one version per package even when it fixes only some of its advisories (for next 14.0.0 it suggests 14.2.35, which leaves 23 of 36 open), so Gnawky checks each advisory's vulnerable range against that version: the ones it doesn't fix are listed apart, with the version they need ("Fixing all of them needs a release of next after 15.5.27"). For packages installed by the upgraded one (postcss in next), npm's expectation can't be checked before the fix; the audit after the fix shows what was really fixed. Ignoring an item ignores each of its advisories, so a new advisory for that package still shows up. Browse findings and both reports group the same way; `findings.json` stays one entry per advisory. Claude's triage still judges each vulnerable package on its own, so an item that covers several packages shows Claude's take for each (for example `next`: fix now, `postcss`: likely false positive) and is ranked by the most urgent one.
  65. - **Verified fixes**: before applying dependency fixes, you can have Gnawky run your `test`, `build`, `lint` and `typecheck` scripts before and after the change (all at once, or one package at a time with automatic undo of any upgrade that breaks them). It also checks `npm ls` (or `yarn check --verify-tree`) for broken dependency trees, warns about packages that don't support your Node version, and compares the audit before and after. Then you keep the branch, undo everything, or ask Claude to investigate a failure.
  66. - **Fixed advisories log**: when you keep the branch, Gnawky saves the advisories the fix removed, with their GHSA and CVE IDs, to `.gnawky/fixes/<date>.json` and a `.md` table ready to paste into a PR or ticket. The list comes from the audit run after the fix; without one (offline, or the dependency scanner off) it lists what the applied changes target and says so. `npm audit` doesn't report CVE IDs, so for npm projects they're looked up from the GitHub advisory API (up to 40 per fix; set `GITHUB_TOKEN` for a higher rate limit).
  67. - **Review & fix in Claude's order**: the same review in triage order: fix now, then fix soon and low priority, then likely false positives, then findings Claude hasn't triaged. Shown once a triage exists.
  68. - **Browse findings**: open any finding for details and act on just that one. A grouped item lets you fix, ignore or ask Claude about all its advisories at once, or open a single one.
  69. - **Ignored findings**: see every ignore decision with its reason, and restore any of them.
  70. 3. **AI tools** (submenu, needs Claude Code; turned off in offline mode). The submenu says why an item is greyed out (offline mode, Claude Code not installed, no scan yet).
  71. - **Triage findings**: you tick which severities (critical, high, …) and sources (dependencies, code, secrets) to triage, and see how many Claude runs that takes before you start; up to 3 runs can go at the same time (faster, same tokens, heavier on rate limits). The choice is remembered per project. Claude reads your code (read-only: it can't edit files or run commands) and labels each finding as a real issue, likely false positive, or needs a human, with an urgency (fix now, fix soon, low priority) and a short reason. Advisories are grouped per package and secrets per file, so each package or file is checked once (one verdict per file: if its secrets differ, the most serious one counts and the reason names the real lines). Results are saved in `.gnawky/triage.json`, kept across re-scans, shown in Browse and Review & fix, and added to both reports. You can then review in Claude's order. They are suggestions: nothing is fixed or ignored automatically. `.env` files, keys and `.npmrc` are blocked; for files gitleaks flagged, Claude reads a temporary copy with the flagged lines hidden, and Gnawky re-scans each copy with gitleaks first and keeps the file blocked if anything is still found. Needs Claude Code; disabled in offline mode; not on Windows yet.
  72. - **Run a full security audit**: starts Claude Code with the bundled [security-audit skill](https://github.com/cloudflare/security-audit-skill) by Cloudflare, which audits the whole codebase for what scanners miss (broken access control, injection, data leaking between users, unsafe auth flows) and has a separate verifier check every candidate. You pick the size first: **Quick** (whole project, one pass), **Full** (whole project, the standard workflow, often 30+ minutes and a lot of tokens on a real project) or **Custom** (tick folders in a tree, open folders to pick subfolders, then choose the `quick` / `standard` / `deep` profile and an optional cap on sub-agents). A custom run is a scoped audit: the report marks everything else out of scope. The last custom choice is remembered per project. Reports go outside the project, to `~/security-audit-skill/<project>-<id>/run-N/` (`REPORT.md`, `findings.json`, `NEEDS-VALIDATION.md`). When you exit Claude, Gnawky imports the confirmed findings as a fourth source, `claude-audit`, also on every later scan, with severity, trace, conditions and the fix strategy; reproduction payloads stay in the skill's own report. Credentials files and files flagged for secrets are blocked for the session.
  73. - **Ask Claude for help**: starts Claude Code with the scan results, after a privacy notice (needs Claude Code; disabled in offline mode).
  74. 4. **View report**: shows the Markdown report and opens the HTML report in your browser.
  75. 5. **Settings**: minimum severity, offline mode, scanners on/off, semgrep rules, and whether semgrep skips test and mock files (`__mocks__`, `__tests__`, `fixtures`, `test(s)/`, `*.spec.*`, `*.test.*`; on by default, much faster on big projects; gitleaks still scans them for secrets). Saved per project in `.gnawky/config.json`.
  76. 6. **Tools & scanners**: shows which scanners are missing and installs them (Homebrew/pipx) if you want.
  77. Commands that work on the last scan in `.gnawky/` (the plugin's skill uses them; run them inside the project):
  78. ```bash
  79. gnawky scan [--json] # scan, then list the findings grouped like the app
  80. gnawky findings [--json] # the last scan's grouped findings, with Claude's verdicts
  81. gnawky report [--open] # rewrite both reports, optionally open the HTML one
  82. gnawky triage [--severity critical,high] [--sources dependencies,code,secrets] [--all] [--parallel 3]
  83. # shows what Claude triage would send; add --yes to run it
  84. gnawky ignore <id|GHSA|CVE|package>... --reason "why" # a package ignores its whole grouped item
  85. gnawky fix <package|id|GHSA|CVE>... | --all [--scripts test,build|all] [--one-at-a-time] [--pin caret|exact]
  86. # shows the fix plan; add --yes to apply it on a new branch
  87. gnawky fix --keep | --undo # keep the fix branch (and log the fixed advisories) or throw it away
  88. ```
  89. `gnawky fix` is the app's Review & fix without the menus: the same order, branch, disabled install scripts, script verification (only with `--scripts`, since it runs your project's code), audit afterwards and fixed-advisories log. After `--yes` the branch waits for `--keep` or `--undo`, like the app's results screen.
  90. Headless mode for CI and scripts:
  91. ```bash
  92. gnawky --no-ui # scan and write the reports
  93. gnawky --ci --min-severity high # exit 1 if findings remain, 2 if no scanner could run
  94. gnawky --json # machine-readable output (used by the Claude plugin)
  95. gnawky --offline # nothing leaves this computer
  96. ```
  97. Every scan writes three files to `.gnawky/`: `findings.json`, `security-report.md`, and `security-report.html`. The HTML report is a single self-contained file (no external scripts, styles or fonts, so it works offline). It has severity tiles, a scanner summary, and every finding with full details, plus filters by severity and tool and a text search. It supports dark mode and prints cleanly. In CI, keep it as a build artifact.
  98. Requires Node 18+ and a `package-lock.json` or a Yarn 1 (Classic) `yarn.lock`.
  99. ### Yarn projects
  100. Gnawky uses `yarn audit` and works out a fix for each vulnerable package, without extra registry calls:
  101. - **Direct dependency**: the version in `package.json` is raised to the first patched version (exact pins stay exact, `^`/`~` ranges keep their operator), then `yarn install`.
  102. - **Installed by other packages, patch fits their ranges**: the vulnerable `yarn.lock` entries are re-resolved (the yarn equivalent of `npm audit fix`).
  103. - **Installed by other packages, pinned to an old version**: a `"resolutions"` override in `package.json`, labeled as risky, and as breaking when it crosses a major version. Gnawky never forces healthy copies of a package onto another major version; in that case it suggests a path-specific resolution instead.
  104. Upgrades run before overrides, and an override is skipped when an earlier upgrade already removed the vulnerable versions. Yarn 2+ (Berry) and pnpm lockfiles are not supported yet.
  105. ### Forcing a version of a sub-dependency
  106. When a vulnerable package is only installed by other packages and they pin an old version, `npm audit fix` can't help. Gnawky then forces the lowest patched version: with `"resolutions"` in Yarn projects and `"overrides"` in npm projects (it looks up the published versions with `npm view`, from the registry your project uses). Like resolutions, an override is labeled risky, or breaking when it crosses a major version, and is never used when it would move healthy copies to another major version (Gnawky suggests a nested override instead).
  107. Before the plan runs, Gnawky asks how to write each forced version, and marks one choice as recommended:
  108. - **`^2.5.6` (range)**: later 2.x releases still arrive, including future security fixes. Recommended by default.
  109. - **`2.5.6` (exact)**: stays on that version until you change it. Pick this if a newer release is broken. Recommended when `package.json` already pins that package exactly, or when the project pins its dependencies exactly (`save-exact` in `.npmrc` / `.yarnrc`, or every dependency in `package.json` is an exact version).
  110. To force a version Gnawky didn't suggest (for example an older one, because the latest has a bug), edit the entry yourself: Gnawky keeps it, and recommends keeping it exact the next time it has to change it.
  111. ### Checking packages before you install them
  112. Turn on **Settings → Check packages before npm install / yarn add** and Gnawky checks every package you add, including commands pasted from the web. It adds a few shell functions to `~/.zshrc` (for bash: `~/.bash_profile` on macOS, `~/.bashrc` elsewhere), in a marked block that Settings removes again. It applies to every project on the computer, and Gnawky updates the block when a newer version changes it.
  113. When you run `npm install <pkg>` (or `npm i`, `npm add`, `yarn add`, `yarn workspace <name> add`), Gnawky first resolves the new packages in a temporary folder with `npm install --package-lock-only --ignore-scripts`: nothing is downloaded into your project and no install scripts run. Only packages that aren't already in your lockfile are checked:
  114. ```
  115. $ yarn add lodash@4.17.20 minimist@0.0.8
  116. ✖ 2 new packages checked, 3 problem(s) (3s)
  117. ✖ HIGH lodash@4.17.20: Command Injection in lodash https://github.com/advisories/GHSA-35jh-r3h4-6jhm
  118. ✖ CRITICAL minimist@0.0.8: Prototype Pollution in minimist https://github.com/advisories/GHSA-xvch-5gv4-984h
  119. • MEDIUM lodash@4.17.20: Regular Expression Denial of Service (ReDoS) in lodash …
  120. Recommended:
  121. lodash@4.18.1 latest, fixes these advisories
  122. minimist@1.2.8 latest, fixes these advisories, major update from 0.0.8, check its changelog
  123. → yarn add lodash@4.18.1 minimist@1.2.8
  124. gnawky: install anyway? [y/N]
  125. ```
  126. - **Recommends a safe version** for each flagged package (the version that fixes the advisories, and whether it's the latest), with the same command rewritten to use it. When there's no fixed version, it says so.
  127. - **Asks before installing** for high and critical advisories (including malware advisories), and for versions published in the last 2 days, before most malicious releases are caught. Install scripts and lower-severity advisories are shown without a question.
  128. - **Everything else runs unchanged**: `npm install`, `npm run …`, `yarn build`. Global installs aren't checked, and neither are git URLs, local paths or tarballs. Skip the check once with `GNAWKY_SKIP=1 npm install <pkg>`.
  129. - **Never blocks an install by breaking**: if the check can't run (no network, a resolution error, offline mode in that project), the command runs as usual with a note.
  130. - **Privacy**: advisories come from your configured registry (like `npm audit`). Publish dates come from [deps.dev](https://deps.dev), and only for packages resolved from the public npm registry, so private package names never leave your registry.
  131. - **Works with Node version managers**: nvm (also with lazy loading, where `npm` is a function that loads nvm first), fnm, Volta, asdf and corepack. When Gnawky isn't installed for the Node version in use (after `nvm use`), you get a one-time note and the command runs unchecked. If Gnawky itself can't start, the command runs as usual; Ctrl+C during the check stops it.
  132. - **Limits**: it only covers your own terminal (zsh and bash), not CI, IDE buttons or teammates. A malicious package published hours ago has no advisory yet; the 2-day check is the only signal for those.
  133. ### Pre-commit dependency check
  134. The package check only covers your own terminal. The pre-commit check is the next layer: turn it on in **Settings → Pre-commit dependency check** (setup recommends it too). When a commit changes `package-lock.json` or `yarn.lock`, Gnawky audits the dependencies in the commit, compares them with the last commit, and blocks the commit only if it **adds** high or critical findings:
  135. ```
  136. gnawky: package-lock.json changed, checking new dependencies…
  137. ✖ package-lock.json: 2 new finding(s), 2 lower-severity (1s)
  138. HIGH lodash: Command Injection in lodash https://github.com/advisories/GHSA-35jh-r3h4-6jhm
  139. Commit blocked: this commit adds 2 high/critical finding(s).
  140. Fix them (gnawky → Findings), ignore them with a reason in gnawky, or commit anyway with git commit --no-verify.
  141. ```
  142. - **Old findings never block**, so a project with known issues can still commit. Ignored findings (with a reason) don't block either.
  143. - **Where it goes**: with husky, in `.husky/pre-commit`, so the team gets it when you commit that file. With another `core.hooksPath`, in that folder. Otherwise in `.git/hooks/pre-commit`, for this clone only. For lefthook, Gnawky shows a snippet for `lefthook.yml`, because lefthook rewrites its hook scripts. An existing hook keeps working: Gnawky adds a marked block at the top and removes only that block again.
  144. - **Never blocks for its own problems**: in offline mode, without a network, if the audit fails, or for teammates who don't have gnawky installed, the commit goes through (with a note).
  145. - Run it by hand with `gnawky pre-commit` (`--min-severity critical` to block only critical findings).
  146. ## Safety model
  147. - **The scan is read-only.** Nothing changes unless you choose a fix in the app and confirm the plan.
  148. - **Fixes happen on a new git branch**, and only if your working tree is clean, so you can review with `git diff` and throw everything away in one command.
  149. - **No install scripts run during fixes** (`--ignore-scripts` for npm and yarn), and `npm audit fix --force` is never used. Semver-major upgrades are labeled as breaking and need their own approval. `npm rebuild` is only offered when a check fails, with its own warning.
  150. - **Your project's code only runs if you say so.** Verifying a fix runs your package.json scripts, which is opt-in every time and shows the exact commands. It never happens in headless or `--ci` mode.
  151. - **Secrets are never written to reports.** gitleaks runs with `--redact`, and code snippets are excluded.
  152. - **No shell.** External tools are launched with argument arrays, so file names or package data can't inject commands. Package specs are validated before `npm install`.
  153. - **Offline mode** (chosen during setup, in Settings, or `--offline`): npm/yarn audit is skipped (it sends your dependency list to the registry), semgrep only uses local rule files, and "Ask Claude" is disabled. Outside offline mode your source code is still never uploaded: only the dependency list goes to the registry, and semgrep downloads its rulesets with metrics turned off.
  154. - **"Ask Claude" shows a privacy notice first**: anything Claude reads is sent to Anthropic. Claude is told not to open `.env` files, keys, or files flagged as containing secrets; for a hard block, add deny rules in Claude Code's permission settings.
  155. - **Reports stay out of git**: `.gnawky/` ignores itself. `.gnawky-ignore.json` *is* meant to be committed so your team shares ignore decisions and their reasons.
  156. ## Claude Code plugin
  157. The repo is also a plugin (`.claude-plugin/plugin.json`) named `gnawky`, so you can talk to Gnawky in a Claude Code session:
  158. ```
  159. gnawky find any security issues
  160. gnawky generate the report
  161. gnawky triage the findings, high and critical only
  162. gnawky what's wrong with next?
  163. gnawky ignore the lodash advisories, we only use it in build scripts
  164. gnawky fix next
  165. ```
  166. - `gnawky` skill: picks up requests that mention Gnawky and runs the matching command below, then explains the results in grouped items, with Claude's verdicts where there are any. Before a triage it shows what will be sent and asks you; ignores need your reason. For fixes it shows Gnawky's plan, suggests an order (or splitting a risky major upgrade into its own branch), asks whether to verify with your scripts, and applies it with `gnawky fix` only after you agree; you then choose keep or undo. Claude doesn't install packages or edit the lockfile itself. Claude picks skills by their description, so a request without "gnawky" in it may not use it; the slash commands always do.
  167. - `/gnawky:scan`, `/gnawky:report`, `/gnawky:triage`, `/gnawky:fix`: the same as slash commands
  168. - `security-reviewer` agent: read-only triage of true vs. false positives, drafts minimal fix diffs
  169. - `security-audit` skill (`gnawky:security-audit`): Cloudflare's multi-phase audit skill, bundled unmodified under its MIT license. See `skills/security-audit/VENDORED.md` for the source commit and how to update it. Gnawky loads it with `--plugin-dir`, so the menu item works without installing the plugin.
  170. Install it locally through the included `marketplace.json`:
  171. ```
  172. /plugin marketplace add /path/to/gnawky
  173. /plugin install gnawky@gnawky-marketplace
  174. ```
  175. Check the current Claude Code plugin docs if the commands differ in your version: https://docs.claude.com/en/docs/claude-code/overview
  176. ## Roadmap ideas
  177. - Built-in Node-specific checks (e.g. `helmet` missing in Express, `cookie` without `httpOnly`/`secure`)
  178. - Apply semgrep autofixes with per-edit approval
  179. - SARIF output for GitHub code scanning
  180. - A GitHub Actions workflow that checks pull requests that change dependencies, plus a weekly run for new advisories (needs Gnawky published on npm)
  181. - Offer `ignore-scripts=true` in `.npmrc` / `.yarnrc`, listing the packages that would then need `npm rebuild`
  182. - Support for pnpm and Yarn 2+ lockfiles
  183. ## License
  184. [MIT](LICENSE) © 2026 Andrei Ciungan. The bundled security-audit skill in `skills/security-audit/` is by Cloudflare and keeps its own [MIT license](skills/security-audit/LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.