ship-safe-deep
Run a deep security audit with LLM-powered taint analysis — regex scan nominates findings, then an LLM verifies taint reachability and exploitability. Use when the user wants thorough, high-confidence results with fewer false positives.
git clone --depth 1 https://github.com/asamassekou10/ship-safe /tmp/ship-safe-deep && cp -r /tmp/ship-safe-deep/claude-code-plugin/skills/ship-safe-deep ~/.claude/skills/ship-safe-deepSKILL.md
# Ship Safe — Deep Analysis (LLM-Powered)
You are a senior security engineer running Ship Safe's deep analysis mode, which combines regex-based scanning with LLM-powered taint verification.
## Step 1: Check for LLM provider
Deep analysis requires either:
- An API key: `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`, or `GOOGLE_API_KEY`
- Ollama running locally (use `--local` flag)
Check if the user has a provider available:
```bash
echo "ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:+set}" "OPENAI_API_KEY=${OPENAI_API_KEY:+set}" "GOOGLE_API_KEY=${GOOGLE_API_KEY:+set}"
```
If no key is set, ask the user if they want to use `--local` (requires Ollama) or set an API key.
## Step 2: Run the deep audit
```bash
npx ship-safe@latest audit $ARGUMENTS --deep --json --no-ai 2>/dev/null
```
For local Ollama:
```bash
npx ship-safe@latest audit $ARGUMENTS --deep --local --json --no-ai 2>/dev/null
```
With budget control:
```bash
npx ship-safe@latest audit $ARGUMENTS --deep --budget 100 --json --no-ai 2>/dev/null
```
## Step 3: Interpret deep analysis results
Findings with `deepAnalysis` have LLM-verified taint information:
```json
{
"deepAnalysis": {
"tainted": true,
"sanitized": false,
"exploitability": "confirmed",
"reasoning": "User input from req.body flows to SQL query without parameterization"
}
}
```
Exploitability levels:
- **confirmed**: Clear, unsanitized path from user input to dangerous sink — fix immediately
- **likely**: Probable taint path but LLM could not fully trace it — investigate
- **unlikely**: Taint path exists but sanitization or context makes exploitation difficult
- **false_positive**: No real vulnerability — static value, test code, or properly sanitized
## Step 4: Present results
For each finding with deep analysis:
1. Show the exploitability verdict prominently
2. Include the LLM's reasoning
3. For "confirmed" findings, read the source file and offer a specific fix
4. For "false_positive" findings, note they can be baselined
Group findings by exploitability (confirmed first, then likely, then unlikely).
## Step 5: Cost summary
Show the deep analysis cost:
- Number of findings analyzed
- Approximate cost in cents
- Provider used
## Important Notes
- The `--deep` flag only analyzes critical and high severity findings (cost optimization)
- Default budget is 50 cents — use `--budget` to adjust
- Without an API key or `--local`, deep analysis is silently skipped and you get standard results
- The `--no-ai` flag is intentional — Claude Code is the AI layer; ship-safe's built-in classification is separate from deep taint analysisManage your security baseline — accept current findings as known debt, then only report new regressions on future scans. Use when the user wants to adopt security scanning incrementally or suppress existing findings.
Run Ship Safe in CI mode — compact output, exit codes, SARIF generation. Use when the user wants to set up CI/CD security gates or test their pipeline configuration.
Auto-fix security issues — remediate hardcoded secrets and common vulnerabilities (TLS bypass, debug mode, XSS, shell injection, Docker :latest). Use when the user wants to automatically fix security findings.
Install ship-safe as real-time Claude Code hooks — blocks secrets and dangerous commands before they land on disk. Use when the user wants automatic security scanning on every file write or bash command.
Run a multi-agent red team scan — 29 specialized security agents scan for 80+ attack classes including injection, auth bypass, SSRF, supply chain, Supabase RLS, MCP security, agentic AI, RAG poisoning, PII compliance, and more. Use when the user wants a deep security analysis beyond just secrets.
Quick scan for leaked secrets — API keys, passwords, tokens, database URLs. Use when the user wants to check for hardcoded secrets or exposed credentials.
Get your project's security health score (0-100, A-F grade). Use when the user wants a quick security check or asks "is my code safe to ship?
Run a full security audit on this project — 16 agents scan for secrets, injections, auth bypass, SSRF, supply chain, Supabase RLS, MCP security, agentic AI, RAG poisoning, PII compliance, and more. Use when the user wants a security audit, vulnerability scan, or asks if their code is safe to ship.