securevibe 0.1.0

package/LICENSE

@@ -0,0 +1,46 @@
+SecureVibe Beta License
+
+Copyright (c) 2026 Benedict Patrick. All rights reserved.
+
+SecureVibe is proprietary software. It is not open source. By installing or
+using SecureVibe you agree to these terms.
+
+1. License grant. During the public beta you may install and run SecureVibe
+   free of charge to analyze and protect code you own or are authorized to
+   test, for personal or commercial purposes, subject to the usage limits
+   built into the software.
+
+2. Usage limits and paid plans. The free beta includes a daily usage limit.
+   Limits, features, and pricing may change during and after the beta, and
+   continued use after the beta may require a paid subscription. You will
+   keep control of your code either way: analysis runs on your machine.
+
+3. Restrictions. You may not copy, modify, translate, or create derivative
+   works of the software; redistribute, sublicense, rent, sell, or host it
+   as a service for third parties; remove or bypass usage limits or notices;
+   or reverse engineer it except to the extent a law expressly permits.
+
+4. Ownership. The software, including all intellectual property rights in
+   it, remains the exclusive property of the copyright holder. Findings and
+   reports produced from your code are yours.
+
+5. Feedback. If you send feedback, you grant the copyright holder a
+   perpetual, irrevocable, royalty free right to use it without obligation.
+
+6. Honesty of results. SecureVibe reports what its analysis found. A clean
+   result, a passing gate, or an applied fix is not a guarantee that your
+   application is secure. Always review changes and run your own tests.
+
+7. No warranty. The software is provided "as is", without warranty of any
+   kind, express or implied, including merchantability, fitness for a
+   particular purpose, and noninfringement.
+
+8. Limitation of liability. To the maximum extent permitted by law, the
+   copyright holder is not liable for any indirect, incidental, special,
+   consequential, or exemplary damages, or any loss of data, profits, or
+   revenue, arising from the use of or inability to use the software.
+
+9. Termination. This license ends automatically if you breach it. On
+   termination you must stop using the software and delete all copies.
+
+10. Contact. Questions and commercial licensing: benedictroger2006@gmail.com

package/README.md

@@ -0,0 +1,152 @@
+# securevibe
+
+The local-first SecureVibe CLI — autonomous AI security engineer for AI generated apps.
+Analysis runs entirely on your machine (tree-sitter AST + taint), no upload required.
+
+## Quick start
+
+```bash
+npm install -g securevibe       # or: npx securevibe scan <path>
+
+securevibe scan <path>          # findings + security score
+securevibe ready <path>         # launch readiness scorecard + go/no-go verdict
+securevibe fix <path>           # preview fixes (dry run)
+securevibe fix <path> --apply   # apply + back up originals (asks per change)
+```
+
+From a clone of this repo instead: `pnpm install && pnpm build`, then
+`node packages/cli/dist/index.js scan <path>` (`pnpm demo` scans the bundled sample).
+
+The free beta includes a daily usage limit (50 analyses per day, reset at local
+midnight). The `--staged` commit guard is never limited. See [`LICENSE`](LICENSE).
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `securevibe scan [path]` | Full scan → findings + security score (default command) |
+| `securevibe init [path]` | **Wire SecureVibe in: pre-commit guard + GitHub Action + gitignore** (doc 12) |
+| `securevibe fix [path]` | **Autonomously fix findings, then re-scan to verify** (doc 05) |
+| `securevibe deps [path]` | Audit dependencies for known CVEs against the local OSV database (SCA) |
+| `securevibe db <update\|status>` | Manage the local OSV database — `update` is the only networked command |
+| `securevibe ready [path]` | Launch readiness scorecard: pass/fail gates + go/no-go verdict |
+| `securevibe ai-audit [path]` | Focus on the AI-agent attack surface (doc 04) |
+| `securevibe protect [path]` | Remediation-first view: the fix for every finding (doc 05) |
+| `securevibe attack-map [path]` | Exploit paths from reachable findings + choke point (doc 06) |
+| `securevibe score [path]` | Just the score + deployment-readiness verdict (doc 08) |
+
+Flags: `--json`, `--sarif` (GitHub code-scanning / CI interop), `--no-color`,
+`--ci` (exit `2` on BLOCK, `1` on WARN, `0` on SHIP — for build gates),
+`--staged` (scan only git-staged files — what the pre-commit guard uses).
+`fix` flags: `--apply` (write to disk; asks before each change), `--yes` (apply every
+verified fix without prompting — for CI/scripts), `--no-llm` (deterministic-only), `--json`.
+`init` flags: `--force` (replace an existing hook/workflow/config).
+
+## Always-on (doc 12)
+
+`securevibe init` makes the tool continuous so insecure code can't slip through:
+
+- a **git pre-commit hook** that runs `scan --staged --ci` and **rejects any commit that introduces
+  a blocking issue** — including a committed secret (verified: it aborts the commit, then lets the
+  clean version through);
+- a **GitHub Actions workflow** (`.github/workflows/securevibe.yml`) that scans every PR and uploads
+  SARIF to GitHub code scanning, gating the build on deployment-readiness;
+- gitignores `.env` / backups and drops a minimal `securevibe.config.json`.
+
+It is idempotent (existing files are left alone unless `--force`) and runs entirely locally —
+**no account, no upload, and your secrets / API keys are never stored or transmitted.**
+
+## The fix loop (doc 05)
+
+`securevibe fix` turns detection into remediation. For every finding it produces a
+concrete code change, then **re-runs the exact same detectors on the new content** and
+only keeps the change if it passes a verification gate:
+
+> the targeted finding is gone **AND** no new medium-or-worse issue was introduced **AND**
+> the file still parses.
+
+Anything that fails the gate is rolled back and surfaced as a manual instruction.
+
+- **Deterministic, offline (zero setup):** parameterize SQL (driver-aware placeholders),
+  lock wildcard CORS to an env-driven allowlist, pin weak JWT algorithms, and move
+  hardcoded secrets to env references / gitignore `.env`.
+- **Claude-powered (optional, set `ANTHROPIC_API_KEY`):** *targets* the logic-level classes a
+  rule can't safely rewrite — RCE/command-injection, AI tool-hijack / missing firewall, IDOR,
+  DOM XSS, and complex SQL. One rewrite per file; the result is kept **only if it passes the
+  verification gate**, otherwise it falls back to a precise manual instruction.
+
+**Honesty (read this):**
+- A "fixed" finding means *our detector no longer flags it* — not that the app is proven secure.
+  Taint is intra-file, so always review the diff and run your tests.
+- The AI-critical (`ai-tool-hijack`) clears only when the fix adds a guard our detector
+  *recognizes* (a tool allowlist + argument-schema validation — what the LLM prompt asks for).
+  The prompt-injection surface typically remains (input still reaches the model) and is reported
+  as a residual to address with input isolation.
+- The deterministic, offline fixers are verified end-to-end here. The **live Claude path is wired
+  and unit-tested (response parsing, gate behavior) but has not been exercised against a real API
+  key in this build** — set `ANTHROPIC_API_KEY` and review the diffs it proposes.
+- `fix` is **dry-run by default**; `--apply` backs up originals to `.securevibe-backup/<ts>/` first.
+- `fix --apply` is **interactive**: it shows each verified diff and asks `[y]es / [n]o / [a]ll / [q]uit`
+  before writing. A declined change is reported `skipped`, never `fixed`, and the after-score reflects
+  only what you approved. In a non-interactive shell (CI, piped) it refuses to write unless `--yes` is
+  given, so it never hangs and never writes unattended by surprise.
+
+## Dependency / CVE scanning (SCA)
+
+`securevibe deps` reads `package.json` and `requirements.txt`, matches each pinned version
+against a local copy of the [OSV](https://osv.dev) advisory database, and reports known CVEs.
+
+- **A separate dimension.** Dependency findings are reported on their own Dependencies line and
+  never enter the code sub-scores, so the three code baselines stay byte-identical. A `critical`
+  CVE still blocks deployment, and `securevibe fix` bumps the package to the lowest non vulnerable
+  version while preserving your range prefix (`^`, `~`, `==`, ...).
+- **Offline first.** A bundled seed (`data/osv-seed.json`) ships with the CLI, so `deps` works with
+  no network. `db update` is the **only networked command**: it streams the public OSV npm and PyPI
+  dumps into `~/.securevibe/db`. Nothing about your code or package list leaves the machine.
+- **Honest framing.** A clean result reads "no known advisories as of `<db date>`", not "secure" —
+  it means nothing matched the local database on that date, which is not a proof of safety.
+
+## What it detects
+
+**Classic (doc 03):** SQL injection, command/code execution (RCE), XSS,
+IDOR / broken access control, insecure CORS, weak JWT, hardcoded secrets
+(provider keys, connection-string passwords, `.env` assignments).
+
+**AI-application security (doc 04 — the differentiator):**
+- Prompt-injection surface (untrusted input → LLM)
+- **Prompt injection → tool execution** (model output drives an unvalidated fs/shell/DB/network sink)
+- Over-privileged AI tools
+- Missing AI execution firewall
+- RAG / indirect-injection exposure
+- Unauthenticated MCP servers
+
+Findings are tagged with CWE / OWASP (incl. **OWASP LLM Top 10**) / MITRE ATT&CK & ATLAS,
+and severity is **reachability-weighted** (taint-confirmed flows rank highest), per doc 03/08.
+
+## How it maps to the architecture
+
+| Source | Design doc |
+|---|---|
+| `src/engine/parser.ts` | tree-sitter parsing layer — doc 02 |
+| `src/engine/taint.ts` | intra-file taint — doc 03 |
+| `src/engine/detectors/classic.ts` | classic detectors — doc 03 |
+| `src/engine/detectors/aisecurity.ts` | AI-app security — doc 04 |
+| `src/engine/detectors/secrets.ts` | secret detection — doc 03 |
+| `src/engine/score.ts` | scoring + readiness — doc 08 |
+| `src/engine/fix/*` | autonomous fix loop (deterministic + LLM + verify) — doc 05 |
+| `src/ui/*` | report / protect / fix / attack-map / SARIF — docs 12/17 |
+
+This is the buildable MVP slice. The cloud orchestration, multi-agent remediation
+(auto-PRs), sandboxed attack simulation, and runtime protection live in the design docs
+(05/07/09/13) and are the commercial layer.
+
+## Notes & limitations (honest MVP scope)
+
+- Languages: JS / TS / TSX / Python (tree-sitter grammars). New grammars are additive.
+- Taint is intra-file (doc 03 calls cross-file/symbolic out as the scale-up); the IDOR
+  detector is a heuristic semantic check (confidence-scored accordingly).
+- `fix` verifies against our own (intra-file) detector — it confirms the finding is no
+  longer flagged, not that the app is provably secure. The deterministic fixers are
+  non-breaking by construction; the verification gate is the safety net for LLM rewrites.
+- `fix` applies changes locally + backs them up; it does **not** open PRs yet (that's
+  doc 05's cloud engine). Detection favors precision but is not exhaustive.

package/data/osv-seed.json

@@ -0,0 +1,39 @@
+{
+  "date": "2026-06-20",
+  "ecosystems": {
+    "npm": {
+      "lodash": [
+        {
+          "id": "GHSA-jf85-cpcp-j695",
+          "aliases": ["CVE-2019-10744"],
+          "severity": "critical",
+          "summary": "Prototype pollution in lodash before 4.17.12 via defaultsDeep allows modifying object prototype.",
+          "ranges": [{ "introduced": "0", "fixed": "4.17.12" }],
+          "url": "https://github.com/advisories/GHSA-jf85-cpcp-j695"
+        }
+      ],
+      "minimist": [
+        {
+          "id": "GHSA-vh95-rmgr-6w4m",
+          "aliases": ["CVE-2020-7598"],
+          "severity": "medium",
+          "summary": "Prototype pollution in minimist before 1.2.3.",
+          "ranges": [{ "introduced": "0", "fixed": "1.2.3" }],
+          "url": "https://github.com/advisories/GHSA-vh95-rmgr-6w4m"
+        }
+      ]
+    },
+    "PyPI": {
+      "jinja2": [
+        {
+          "id": "GHSA-h5c8-rqwp-cp95",
+          "aliases": ["CVE-2024-22195"],
+          "severity": "medium",
+          "summary": "Jinja2 before 3.1.3: HTML attribute injection via the xmlattr filter.",
+          "ranges": [{ "introduced": "0", "fixed": "3.1.3" }],
+          "url": "https://github.com/advisories/GHSA-h5c8-rqwp-cp95"
+        }
+      ]
+    }
+  }
+}

package/dist/engine/ast.js

@@ -0,0 +1,88 @@
+/** Depth-first visit of every *named* node. */
+export function walk(node, visit) {
+    visit(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            walk(child, visit);
+    }
+}
+/** Collect every named descendant whose type is in `types`. */
+export function descendantsOfType(root, types) {
+    const set = new Set(types);
+    const out = [];
+    walk(root, (n) => {
+        if (set.has(n.type))
+            out.push(n);
+    });
+    return out;
+}
+/** 1-based line/column for reporting. */
+export function loc(node) {
+    return { line: node.startPosition.row + 1, column: node.startPosition.column + 1 };
+}
+/**
+ * Resolve the callee text of a call node across JS and Python. Both grammars
+ * expose the called expression under the `function` field, so its `.text`
+ * yields the dotted name (e.g. `child_process.exec`, `db.query`,
+ * `openai.chat.completions.create`).
+ */
+export function calleeText(callNode) {
+    const fn = callNode.childForFieldName("function");
+    return fn ? fn.text : null;
+}
+/** The last dotted segment of a callee, e.g. `exec` from `child_process.exec`. */
+export function calleeLastSegment(callNode) {
+    const callee = calleeText(callNode);
+    if (!callee)
+        return null;
+    const parts = callee.split(".");
+    return parts[parts.length - 1] ?? null;
+}
+/** Raw text of the call's argument list (incl. parens / brackets). */
+export function argsText(callNode) {
+    const args = callNode.childForFieldName("arguments");
+    return args ? args.text : "";
+}
+/** True if this node is a function/method call in either grammar. */
+export function isCall(node) {
+    return node.type === "call_expression" || node.type === "call";
+}
+/** Extract a single source line (trimmed) for evidence display. */
+export function lineOf(code, line) {
+    const lines = code.split(/\r?\n/);
+    return (lines[line - 1] ?? "").trim();
+}
+/**
+ * True if the parse tree contains a syntax error. The fix loop uses this as a
+ * hard gate: a candidate rewrite that no longer parses cleanly is rejected and
+ * rolled back, so we never write code that breaks the build.
+ */
+export function hasError(root) {
+    if (root.hasError)
+        return true;
+    let bad = false;
+    walk(root, (n) => {
+        if (n.type === "ERROR" || n.isMissing)
+            bad = true;
+    });
+    return bad;
+}
+/**
+ * Return the source with comments blanked out (newlines preserved so line
+ * numbers are stable). Text-level heuristics must not match on comments —
+ * otherwise a `// no allowlist here` comment reads as "has an allowlist".
+ */
+export function codeWithoutComments(root, code) {
+    const comments = descendantsOfType(root, ["comment"]);
+    if (comments.length === 0)
+        return code;
+    const chars = code.split("");
+    for (const c of comments) {
+        for (let i = c.startIndex; i < c.endIndex && i < chars.length; i++) {
+            if (chars[i] !== "\n" && chars[i] !== "\r")
+                chars[i] = " ";
+        }
+    }
+    return chars.join("");
+}

package/dist/engine/deps/db.js

@@ -0,0 +1,88 @@
+// packages/cli/src/engine/deps/db.ts
+/**
+ * Local OSV database for the SCA slice. Offline-first: a bundled seed snapshot
+ * ships in the package so the first scan needs no network; `securevibe db update`
+ * writes refreshed per-ecosystem files to ~/.securevibe/db and they are merged on
+ * load. Memoized — loaded once per process.
+ */
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function ecosystemKey(e) {
+    return e; // "npm" | "PyPI" — kept as a function so call sites are explicit
+}
+export function userDbDir() {
+    return path.join(os.homedir(), ".securevibe", "db");
+}
+/** Resolve the bundled seed; identical relative depth under src/ and dist/. */
+function seedPath() {
+    return fileURLToPath(new URL("../../../data/osv-seed.json", import.meta.url));
+}
+export function lookup(db, ecosystem, name) {
+    const eco = db.ecosystems[ecosystem];
+    if (!eco)
+        return [];
+    return eco[name.toLowerCase()] ?? [];
+}
+let cached = null;
+export async function loadDepDb() {
+    if (cached)
+        return cached;
+    const db = { date: null, ecosystems: {} };
+    // 1) bundled seed
+    try {
+        const seed = JSON.parse(await fs.readFile(seedPath(), "utf8"));
+        mergeInto(db, seed);
+    }
+    catch {
+        /* seed missing → empty db; scans still run, deps simply unassessed */
+    }
+    // 2) user cache (db update output): ~/.securevibe/db/<eco>.json
+    try {
+        const entries = await fs.readdir(userDbDir());
+        for (const f of entries) {
+            if (!f.endsWith(".json"))
+                continue;
+            try {
+                const part = JSON.parse(await fs.readFile(path.join(userDbDir(), f), "utf8"));
+                mergeInto(db, part);
+            }
+            catch {
+                /* skip a corrupt cache file */
+            }
+        }
+    }
+    catch {
+        /* no user cache yet — fine, seed is enough */
+    }
+    cached = db;
+    return db;
+}
+/** Test seam: drop the memoized db (used by db.update tests). */
+export function _resetDbCache() {
+    cached = null;
+}
+/** Exported as a test seam: seed + `db update` cache overlap, so merge dedups by id. */
+export function mergeInto(db, part) {
+    if (part?.date && (!db.date || part.date > db.date))
+        db.date = part.date;
+    const ecos = part?.ecosystems ?? {};
+    for (const [eco, pkgs] of Object.entries(ecos)) {
+        db.ecosystems[eco] ??= {};
+        for (const [name, advisories] of Object.entries(pkgs)) {
+            const key = name.toLowerCase();
+            const existing = db.ecosystems[eco][key] ?? [];
+            // Dedup by advisory id: the seed and a fresh `db update` overlap (lodash,
+            // jinja2, minimist are in both), so a plain concat would double-count.
+            const seen = new Set(existing.map((a) => a.id));
+            const merged = existing.slice();
+            for (const a of advisories)
+                if (!seen.has(a.id)) {
+                    seen.add(a.id);
+                    merged.push(a);
+                }
+            db.ecosystems[eco][key] = merged;
+        }
+    }
+}

package/dist/engine/deps/detect.js

@@ -0,0 +1,63 @@
+// packages/cli/src/engine/deps/detect.ts
+/**
+ * Dependency (SCA) detection. Pure: a single manifest's content + the local OSV
+ * db -> Finding[]. Dependency findings carry category "dependency" so the code
+ * score (engine/score.ts) excludes them by construction; they are surfaced as a
+ * separate dimension instead. Honest framing: a clean result means "no known
+ * advisories as of <db date>", not "secure".
+ */
+import { createHash } from "node:crypto";
+import { SEVERITY_ORDER } from "../types.js";
+import { isManifest, parseManifest } from "./manifests.js";
+import { isVulnerable, minFixedVersion } from "./match.js";
+import { lookup } from "./db.js";
+export function detectDependencies(relPath, code, db) {
+    if (!isManifest(relPath))
+        return [];
+    const out = [];
+    for (const dep of parseManifest(relPath, code)) {
+        for (const adv of lookup(db, dep.ecosystem, dep.name)) {
+            if (!isVulnerable(dep.baseVersion, adv.ranges))
+                continue;
+            const fixed = minFixedVersion(dep.baseVersion, adv.ranges);
+            const cve = adv.aliases.find((a) => a.startsWith("CVE-")) ?? adv.id;
+            const title = `Vulnerable dependency: ${dep.name}@${dep.baseVersion} (${cve})`;
+            const fix = fixed
+                ? `Upgrade ${dep.name} to ${fixed} or later (review the diff and run your tests).`
+                : `No patched release is known for ${dep.name}. Consider replacing or removing it.`;
+            out.push({
+                id: stableId(relPath, "vulnerable-dependency", dep.line, title),
+                detector: "vulnerable-dependency",
+                title,
+                category: "dependency",
+                severity: adv.severity,
+                confidence: dep.rangePrefix === "" || dep.rangePrefix === "==" ? 0.95 : 0.8,
+                reachable: false,
+                cwe: "CWE-1395",
+                owasp: "A06:2021 Vulnerable and Outdated Components",
+                file: relPath,
+                line: dep.line,
+                column: 1,
+                evidence: `${dep.name}: ${dep.version}`,
+                why: `${adv.summary} (${cve}; advisory ${adv.id})`,
+                fix,
+            });
+        }
+    }
+    return out;
+}
+function stableId(relPath, detector, line, title) {
+    const key = `${relPath}:${detector}:${line}:${title}`;
+    return createHash("sha1").update(key).digest("hex").slice(0, 12);
+}
+export function buildDependencyReport(findings, dbDate) {
+    const deps = findings.filter((f) => f.detector === "vulnerable-dependency");
+    const bySeverity = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+    let worst = null;
+    for (const f of deps) {
+        bySeverity[f.severity]++;
+        if (worst === null || SEVERITY_ORDER[f.severity] > SEVERITY_ORDER[worst])
+            worst = f.severity;
+    }
+    return { dbDate, total: deps.length, bySeverity, worst };
+}

package/dist/engine/deps/manifests.js

@@ -0,0 +1,110 @@
+// packages/cli/src/engine/deps/manifests.ts
+/**
+ * Manifest discovery + parsing for the SCA slice. Direct dependencies only:
+ * package.json (npm) and requirements.txt (PyPI). Lockfiles / transitive deps
+ * are a later slice. We keep the raw spec, the range operator, the base version
+ * (lowest the spec admits, used for matching), dev flag, and 1-based line.
+ */
+import path from "node:path";
+export function isManifest(relPath) {
+    const base = path.basename(relPath).toLowerCase();
+    return base === "package.json" || base === "requirements.txt";
+}
+function ecosystemFor(relPath) {
+    const base = path.basename(relPath).toLowerCase();
+    if (base === "package.json")
+        return "npm";
+    if (base === "requirements.txt")
+        return "PyPI";
+    return null;
+}
+const PREFIX_RE = /^(>=|<=|==|~=|\^|~|>|<|=)?\s*(.*)$/;
+function splitSpec(spec) {
+    const m = spec.trim().match(PREFIX_RE);
+    if (!m)
+        return { prefix: "", base: spec.trim() };
+    const prefix = m[1] ?? "";
+    // base version = leading numeric.dotted token of the remainder
+    const base = (m[2].match(/[0-9][0-9A-Za-z.+-]*/) ?? [""])[0];
+    return { prefix, base };
+}
+export function parseManifest(relPath, code) {
+    const ecosystem = ecosystemFor(relPath);
+    if (!ecosystem)
+        return [];
+    if (ecosystem === "npm")
+        return parsePackageJson(code);
+    return parseRequirements(code);
+}
+function parsePackageJson(code) {
+    let json;
+    try {
+        json = JSON.parse(code);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    const lines = code.split(/\r?\n/);
+    const collect = (obj, isDev) => {
+        if (!obj || typeof obj !== "object")
+            return;
+        for (const [name, raw] of Object.entries(obj)) {
+            if (typeof raw !== "string")
+                continue;
+            const { prefix, base } = splitSpec(raw);
+            if (!base)
+                continue;
+            out.push({
+                ecosystem: "npm",
+                name,
+                version: raw,
+                baseVersion: base,
+                rangePrefix: prefix,
+                isDev,
+                line: lineOfKey(lines, name),
+            });
+        }
+    };
+    collect(json.dependencies, false);
+    collect(json.devDependencies, true);
+    return out;
+}
+/** First line that declares `"name":` — good enough for a single manifest. */
+function lineOfKey(lines, name) {
+    const needle = new RegExp(`"${escapeRe(name)}"\\s*:`);
+    for (let i = 0; i < lines.length; i++)
+        if (needle.test(lines[i]))
+            return i + 1;
+    return 1;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseRequirements(code) {
+    const out = [];
+    const lines = code.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].replace(/#.*$/, "").trim();
+        if (!line || line.startsWith("-"))
+            continue; // skip flags like -r, -e
+        const m = line.match(/^([A-Za-z0-9._-]+)\s*(>=|<=|==|~=|>|<)?\s*([0-9][0-9A-Za-z.+!-]*)?/);
+        if (!m || !m[1])
+            continue;
+        const name = m[1];
+        const prefix = m[2] ?? "";
+        const base = m[3] ?? "";
+        if (!base)
+            continue; // unpinned: nothing to match in this slice
+        out.push({
+            ecosystem: "PyPI",
+            name,
+            version: `${prefix}${base}`,
+            baseVersion: base,
+            rangePrefix: prefix,
+            isDev: false,
+            line: i + 1,
+        });
+    }
+    return out;
+}

package/dist/engine/deps/match.js

@@ -0,0 +1,51 @@
+function split(v) {
+    const clean = v.trim().replace(/^[vV=]+/, "");
+    const [core, ...rest] = clean.split(/[-+]/);
+    const release = core.split(".").map((p) => {
+        const n = parseInt(p, 10);
+        return Number.isNaN(n) ? 0 : n;
+    });
+    const pre = rest.length ? rest.join("-") : null;
+    return { release, pre };
+}
+export function compareVersions(a, b) {
+    const av = split(a);
+    const bv = split(b);
+    const len = Math.max(av.release.length, bv.release.length);
+    for (let i = 0; i < len; i++) {
+        const x = av.release[i] ?? 0;
+        const y = bv.release[i] ?? 0;
+        if (x !== y)
+            return x < y ? -1 : 1;
+    }
+    // Equal release: a prerelease is lower than no prerelease.
+    if (av.pre && !bv.pre)
+        return -1;
+    if (!av.pre && bv.pre)
+        return 1;
+    if (av.pre && bv.pre)
+        return av.pre < bv.pre ? -1 : av.pre > bv.pre ? 1 : 0;
+    return 0;
+}
+export function isVulnerable(version, ranges) {
+    return ranges.some((r) => {
+        const introduced = r.introduced && r.introduced !== "0" ? r.introduced : null;
+        if (introduced && compareVersions(version, introduced) < 0)
+            return false;
+        if (r.fixed && compareVersions(version, r.fixed) >= 0)
+            return false;
+        return true;
+    });
+}
+export function minFixedVersion(version, ranges) {
+    let best = null;
+    for (const r of ranges) {
+        if (!r.fixed)
+            continue;
+        if (compareVersions(r.fixed, version) <= 0)
+            continue; // not actually an upgrade
+        if (best === null || compareVersions(r.fixed, best) < 0)
+            best = r.fixed;
+    }
+    return best;
+}