brainclaw 1.8.0 → 1.9.1

package/dist/core/security-extract.js

@@ -0,0 +1,189 @@
+import fs from 'node:fs';
+export function collectPackages(opts) {
+    const seen = new Set();
+    const out = [];
+    const push = (spec) => {
+        const trimmed = spec.trim();
+        if (!trimmed)
+            return;
+        // Skip local paths and URLs — they aren't registry packages.
+        if (isLocalOrUrl(trimmed))
+            return;
+        if (seen.has(trimmed))
+            return;
+        seen.add(trimmed);
+        out.push(trimmed);
+    };
+    if (opts.packages) {
+        for (const item of opts.packages.split(','))
+            push(item);
+    }
+    if (opts.requirements) {
+        for (const item of parseRequirementsFile(opts.requirements))
+            push(item);
+    }
+    if (opts.lockfile) {
+        for (const item of parseLockfile(opts.lockfile))
+            push(item);
+    }
+    return out;
+}
+/**
+ * Return true for arguments that look like a filesystem path or URL
+ * rather than a registry package name. Mirrors the heuristic the
+ * wrapper scripts use when intercepting install commands.
+ */
+export function isLocalOrUrl(spec) {
+    if (!spec)
+        return false;
+    if (spec === '.' || spec === '..')
+        return true;
+    if (spec.startsWith('./') || spec.startsWith('../'))
+        return true;
+    if (spec.startsWith('/'))
+        return true; // absolute POSIX path
+    if (/^[A-Za-z]:[\\/]/.test(spec))
+        return true; // Windows drive path
+    if (/^[a-z]+:\/\//.test(spec))
+        return true; // http(s)/git/file URLs
+    if (spec.startsWith('git+') || spec.startsWith('git@'))
+        return true;
+    if (spec.endsWith('.tar.gz') || spec.endsWith('.tgz') || spec.endsWith('.whl'))
+        return true;
+    return false;
+}
+/**
+ * Parse a pip requirements.txt file. Supports the subset of syntax that
+ * actually shows up in install gates:
+ *   - one spec per line; "name", "name==version", "name~=version"
+ *   - comments (#) and blank lines
+ *   - continuation lines with trailing backslash
+ *   - line options (-r/--requirement, -e/--editable, -i/--index-url, etc.)
+ *     are skipped, with -r/--requirement recursively included.
+ */
+export function parseRequirementsFile(filePath) {
+    const raw = readFileOrThrow(filePath, 'requirements file');
+    const out = [];
+    const lines = unfoldContinuations(raw).split(/\r?\n/);
+    for (const line of lines) {
+        const stripped = line.replace(/\s*#.*$/, '').trim();
+        if (!stripped)
+            continue;
+        if (stripped.startsWith('-r ') || stripped.startsWith('--requirement ')) {
+            // Recursive include — keep it bounded but useful.
+            const nested = stripped.replace(/^(-r|--requirement)\s+/, '').trim();
+            if (nested) {
+                try {
+                    out.push(...parseRequirementsFile(resolveSibling(filePath, nested)));
+                }
+                catch { /* missing nested file is non-fatal */ }
+            }
+            continue;
+        }
+        if (stripped.startsWith('-'))
+            continue; // -e, -i, --index-url, etc.
+        // Drop env-marker portion: "pkg==1.0 ; python_version>'3.7'"
+        const noMarker = stripped.split(';')[0].trim();
+        if (!noMarker)
+            continue;
+        // Strip extras: "pkg[extra1,extra2]==1.0"
+        const noExtras = noMarker.replace(/\[[^\]]*\]/g, '');
+        // Keep only "name" or "name==version" forms; reject URL/path specs and
+        // ranges we cannot translate to an exact spec ("~=", ">=", "<=", "<", ">", "!=", "===").
+        const exact = noExtras.match(/^([A-Za-z0-9._-]+)\s*==\s*([^\s,;]+)\s*$/);
+        if (exact) {
+            out.push(`${exact[1]}==${exact[2]}`);
+            continue;
+        }
+        const bare = noExtras.match(/^([A-Za-z0-9._-]+)\s*$/);
+        if (bare) {
+            out.push(bare[1]);
+            continue;
+        }
+        // For range specs, keep the name (range resolution is outside our scope).
+        const nameOnly = noExtras.match(/^([A-Za-z0-9._-]+)/);
+        if (nameOnly) {
+            out.push(nameOnly[1]);
+        }
+    }
+    return out;
+}
+/**
+ * Parse a lockfile to extract top-level direct-dependency package names.
+ * Supports:
+ *   - npm package-lock.json (v1, v2, v3): uses `packages[""].dependencies`
+ *     and `packages[""].devDependencies` when present (v2+), else falls
+ *     back to top-level `dependencies` (v1).
+ *   - npm shrinkwrap.json: same shape as package-lock.
+ *
+ * Transitive deps are deliberately excluded; the gate is for what the
+ * operator is asking to install, not the full resolved graph.
+ */
+export function parseLockfile(filePath) {
+    const raw = readFileOrThrow(filePath, 'lockfile');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Failed to parse lockfile ${filePath}: ${err.message}`);
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return [];
+    const obj = parsed;
+    const out = [];
+    // npm package-lock v2+
+    const packages = obj['packages'];
+    if (packages && typeof packages === 'object') {
+        const root = packages[''];
+        if (root && typeof root === 'object') {
+            const deps = root['dependencies'];
+            const devDeps = root['devDependencies'];
+            collectLockDeps(deps, out);
+            collectLockDeps(devDeps, out);
+        }
+    }
+    // npm package-lock v1 fallback
+    if (out.length === 0) {
+        const deps = obj['dependencies'];
+        if (deps && typeof deps === 'object') {
+            for (const [name, meta] of Object.entries(deps)) {
+                const v = meta && typeof meta === 'object' ? meta['version'] : undefined;
+                out.push(typeof v === 'string' ? `${name}@${v}` : name);
+            }
+        }
+    }
+    return out;
+}
+function collectLockDeps(deps, out) {
+    if (!deps || typeof deps !== 'object')
+        return;
+    for (const [name, range] of Object.entries(deps)) {
+        if (typeof range === 'string' && /^\d/.test(range)) {
+            out.push(`${name}@${range}`);
+        }
+        else {
+            out.push(name);
+        }
+    }
+}
+function unfoldContinuations(raw) {
+    return raw.replace(/\\\r?\n/g, ' ');
+}
+function readFileOrThrow(p, label) {
+    try {
+        return fs.readFileSync(p, 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Could not read ${label} at ${p}: ${err.message}`);
+    }
+}
+function resolveSibling(parent, nested) {
+    // Tolerate both absolute and relative includes without pulling in `node:path`.
+    if (nested.startsWith('/') || /^[A-Za-z]:[\\/]/.test(nested))
+        return nested;
+    const sep = parent.includes('\\') ? '\\' : '/';
+    const dir = parent.replace(/[\\/][^\\/]*$/, '');
+    return dir + sep + nested;
+}
+//# sourceMappingURL=security-extract.js.map

package/dist/core/security-guard.js

@@ -1,149 +1,227 @@
 /**
  * Generates brainclaw-guard wrapper scripts (bash + PowerShell) that intercept
- * npm/pip install commands and check packages via brainclaw check-security.
+ * npm/pip/pnpm/yarn install commands and check packages via
+ * brainclaw check-security.
+ *
+ * Mode is enforced by the CLI's exit code, not the wrapper:
+ *   exit 0 — pass (silent)
+ *   exit 1 — warn (printed; install continues)
+ *   exit 2 — block (printed; install aborted)
+ * In advisory mode the CLI never emits exit 2, so the wrapper never aborts.
+ * The wrapper therefore stays mode-agnostic — flipping advisory↔enforced is
+ * a config change, no regeneration required.
  */
 export function generateBashGuard(brainclawBin) {
-    return `#!/usr/bin/env bash
-# brainclaw-guard — preinstall security gate
-# Generated by: brainclaw setup --security
-# Do not edit manually — regenerate with brainclaw setup --security
-
-BRAINCLAW_BIN="${brainclawBin}"
-ORIGINAL_CMD="\${BRAINCLAW_GUARD_ORIGINAL_CMD:-npm}"
-
-is_install_command() {
-  for arg in "$@"; do
-    case "$arg" in
-      install|add|i) return 0 ;;
-      -*)            continue  ;;
-      *)             break     ;;
-    esac
-  done
-  return 1
-}
-
-extract_packages() {
-  local packages=""
-  local skip_next=false
-  local past_command=false
-  for arg in "$@"; do
-    if [ "$skip_next" = true ]; then
-      skip_next=false
-      continue
-    fi
-    case "$arg" in
-      install|add|i)
-        past_command=true
-        continue
-        ;;
-      --save-dev|--save-peer|--save-optional|-D|-P|-O|-g|--global)
-        continue
-        ;;
-      --registry|--prefix)
-        skip_next=true
-        continue
-        ;;
-      -*)
-        continue
-        ;;
-      *)
-        if [ "$past_command" = true ]; then
-          if [ -n "$packages" ]; then
-            packages="$packages,$arg"
-          else
-            packages="$arg"
-          fi
-        fi
-        ;;
-    esac
-  done
-  echo "$packages"
-}
-
-# Main logic
-if is_install_command "$@"; then
-  packages=$(extract_packages "$@")
-  if [ -n "$packages" ]; then
-    ecosystem="npm"
-    if [ "$ORIGINAL_CMD" = "pip" ] || [ "$ORIGINAL_CMD" = "pip3" ]; then
-      ecosystem="pypi"
-    fi
-
-    result=$("$BRAINCLAW_BIN" check-security --packages "$packages" --ecosystem "$ecosystem" --json 2>/dev/null)
-    exit_code=$?
-
-    if [ $exit_code -eq 2 ]; then
-      echo "[brainclaw-guard] BLOCKED — supply chain risk detected" >&2
-      echo "[brainclaw-guard] Run: brainclaw check-security --packages \\"$packages\\" for details" >&2
-      exit 1
-    elif [ $exit_code -eq 1 ]; then
-      echo "[brainclaw-guard] WARNING — potential supply chain risk" >&2
-      echo "[brainclaw-guard] Run: brainclaw check-security --packages \\"$packages\\" for details" >&2
-    fi
-    # exit_code 0 = pass, continue silently
-  fi
-fi
-
-exec "$ORIGINAL_CMD" "$@"
+    return `#!/usr/bin/env bash
+# brainclaw-guard — preinstall security gate
+# Generated by: brainclaw setup-security
+# Do not edit manually — regenerate with brainclaw setup-security
+
+BRAINCLAW_BIN="${brainclawBin}"
+ORIGINAL_CMD="\${BRAINCLAW_GUARD_ORIGINAL_CMD:-npm}"
+
+is_install_command() {
+  for arg in "$@"; do
+    case "$arg" in
+      install|add|i)       return 0 ;;
+      -*)                  continue  ;;
+      *)                   break     ;;
+    esac
+  done
+  return 1
+}
+
+is_local_or_url() {
+  case "$1" in
+    .|..|./*|../*|/*|*:/*|git+*|git@*|*.tgz|*.tar.gz|*.whl) return 0 ;;
+  esac
+  case "$1" in
+    [A-Za-z]:[\\\\/]*) return 0 ;;
+  esac
+  return 1
+}
+
+extract_packages() {
+  local packages=""
+  local req_file=""
+  local skip_next=false
+  local past_command=false
+  for arg in "$@"; do
+    if [ "$skip_next" = true ]; then
+      # The flag's value lands here; capture it for -r/--requirement.
+      case "$prev_flag" in
+        -r|--requirement) req_file="$arg" ;;
+      esac
+      skip_next=false
+      prev_flag=""
+      continue
+    fi
+    case "$arg" in
+      install|add|i)
+        past_command=true
+        continue
+        ;;
+      --save-dev|--save-peer|--save-optional|--save-exact|--save-prod|-D|-P|-O|-E|-S|-g|--global|--no-save|--user|--upgrade|-U|--break-system-packages|--no-deps|--pre|--force-reinstall|--ignore-installed)
+        continue
+        ;;
+      --registry|--prefix|--tag|--registry-url|--cache|--index-url|--extra-index-url|--find-links|--proxy|--cert|--client-cert|--trusted-host|--target|--root|--python|--platform|--abi|--implementation)
+        prev_flag="$arg"
+        skip_next=true
+        continue
+        ;;
+      -r|--requirement|-e|--editable|-c|--constraint)
+        prev_flag="$arg"
+        skip_next=true
+        continue
+        ;;
+      -*)
+        continue
+        ;;
+      *)
+        if [ "$past_command" = true ]; then
+          if is_local_or_url "$arg"; then
+            continue
+          fi
+          if [ -n "$packages" ]; then
+            packages="$packages,$arg"
+          else
+            packages="$arg"
+          fi
+        fi
+        ;;
+    esac
+  done
+  printf '%s\\t%s' "$packages" "$req_file"
+}
+
+# Main logic
+if is_install_command "$@"; then
+  extracted=$(extract_packages "$@")
+  packages="\${extracted%%	*}"
+  req_file="\${extracted##*	}"
+
+  if [ -n "$packages" ] || [ -n "$req_file" ]; then
+    ecosystem="npm"
+    if [ "$ORIGINAL_CMD" = "pip" ] || [ "$ORIGINAL_CMD" = "pip3" ]; then
+      ecosystem="pypi"
+    fi
+
+    args=(check-security --ecosystem "$ecosystem" --json)
+    if [ -n "$packages" ]; then args+=(--packages "$packages"); fi
+    if [ -n "$req_file" ]; then args+=(--requirements "$req_file"); fi
+
+    "$BRAINCLAW_BIN" "\${args[@]}" >/dev/null 2>&1
+    exit_code=$?
+
+    if [ $exit_code -eq 2 ]; then
+      echo "[brainclaw-guard] BLOCKED — supply chain risk detected (enforced mode)" >&2
+      details_pkgs="\${packages:-$req_file}"
+      echo "[brainclaw-guard] Details: $BRAINCLAW_BIN check-security --ecosystem $ecosystem --packages \\"$details_pkgs\\"" >&2
+      exit 1
+    elif [ $exit_code -eq 1 ]; then
+      echo "[brainclaw-guard] WARNING — potential supply chain risk (advisory or warn-threshold verdict)" >&2
+      details_pkgs="\${packages:-$req_file}"
+      echo "[brainclaw-guard] Details: $BRAINCLAW_BIN check-security --ecosystem $ecosystem --packages \\"$details_pkgs\\"" >&2
+    fi
+    # exit_code 0 = pass, continue silently
+  fi
+fi
+
+exec "$ORIGINAL_CMD" "$@"
 `;
 }
 export function generatePowerShellGuard(brainclawBin) {
-    return `# brainclaw-guard — preinstall security gate (PowerShell)
-# Generated by: brainclaw setup --security
-# Do not edit manually — regenerate with brainclaw setup --security
-
-param([Parameter(ValueFromRemainingArguments)]$Args)
-
-$BrainclawBin = "${brainclawBin}"
-$OriginalCmd = if ($env:BRAINCLAW_GUARD_ORIGINAL_CMD) { $env:BRAINCLAW_GUARD_ORIGINAL_CMD } else { "npm" }
-
-function Is-InstallCommand($arguments) {
-    foreach ($arg in $arguments) {
-        if ($arg -match "^(install|add|i)$") { return $true }
-        if ($arg -notmatch "^-") { break }
-    }
-    return $false
-}
-
-function Extract-Packages($arguments) {
-    $packages = @()
-    $pastCommand = $false
-    $skipNext = $false
-    foreach ($arg in $arguments) {
-        if ($skipNext) { $skipNext = $false; continue }
-        if ($arg -match "^(install|add|i)$") { $pastCommand = $true; continue }
-        if ($arg -match "^--(registry|prefix)$") { $skipNext = $true; continue }
-        if ($arg -match "^-") { continue }
-        if ($pastCommand) { $packages += $arg }
-    }
-    return ($packages -join ",")
-}
-
-if (Is-InstallCommand $Args) {
-    $packages = Extract-Packages $Args
-    if ($packages) {
-        $ecosystem = "npm"
-        if ($OriginalCmd -match "^pip") { $ecosystem = "pypi" }
-
-        try {
-            & $BrainclawBin check-security --packages $packages --ecosystem $ecosystem --json 2>$null | Out-Null
-            $exitCode = $LASTEXITCODE
-        } catch {
-            $exitCode = 0
-        }
-
-        if ($exitCode -eq 2) {
-            Write-Error "[brainclaw-guard] BLOCKED - supply chain risk detected"
-            Write-Error "[brainclaw-guard] Run: brainclaw check-security --packages \`"$packages\`" for details"
-            exit 1
-        } elseif ($exitCode -eq 1) {
-            Write-Warning "[brainclaw-guard] WARNING - potential supply chain risk"
-            Write-Warning "[brainclaw-guard] Run: brainclaw check-security --packages \`"$packages\`" for details"
-        }
-    }
-}
-
-& $OriginalCmd @Args
+    return `# brainclaw-guard — preinstall security gate (PowerShell)
+# Generated by: brainclaw setup-security
+# Do not edit manually — regenerate with brainclaw setup-security
+
+param([Parameter(ValueFromRemainingArguments)]$Args)
+
+$BrainclawBin = "${brainclawBin}"
+$OriginalCmd = if ($env:BRAINCLAW_GUARD_ORIGINAL_CMD) { $env:BRAINCLAW_GUARD_ORIGINAL_CMD } else { "npm" }
+
+function Is-InstallCommand($arguments) {
+    foreach ($arg in $arguments) {
+        if ($arg -match "^(install|add|i)$") { return $true }
+        if ($arg -notmatch "^-") { break }
+    }
+    return $false
+}
+
+function Is-LocalOrUrl($arg) {
+    if ($arg -eq "." -or $arg -eq "..") { return $true }
+    if ($arg -match "^(\\./|\\.\\./|/)") { return $true }
+    if ($arg -match "^[A-Za-z]:[\\\\/]") { return $true }
+    if ($arg -match "^[a-z]+://") { return $true }
+    if ($arg -match "^(git\\+|git@)") { return $true }
+    if ($arg -match "\\.(tgz|tar\\.gz|whl)$") { return $true }
+    return $false
+}
+
+function Extract-Packages($arguments) {
+    $packages = @()
+    $reqFile = ""
+    $pastCommand = $false
+    $skipNext = $false
+    $prevFlag = ""
+    foreach ($arg in $arguments) {
+        if ($skipNext) {
+            if ($prevFlag -match "^(-r|--requirement)$") { $reqFile = $arg }
+            $skipNext = $false
+            $prevFlag = ""
+            continue
+        }
+        if ($arg -match "^(install|add|i)$") { $pastCommand = $true; continue }
+        if ($arg -match "^(--save-dev|--save-peer|--save-optional|--save-exact|--save-prod|-D|-P|-O|-E|-S|-g|--global|--no-save|--user|--upgrade|-U|--break-system-packages|--no-deps|--pre|--force-reinstall|--ignore-installed)$") { continue }
+        if ($arg -match "^(--registry|--prefix|--tag|--registry-url|--cache|--index-url|--extra-index-url|--find-links|--proxy|--cert|--client-cert|--trusted-host|--target|--root|--python|--platform|--abi|--implementation)$") {
+            $prevFlag = $arg; $skipNext = $true; continue
+        }
+        if ($arg -match "^(-r|--requirement|-e|--editable|-c|--constraint)$") {
+            $prevFlag = $arg; $skipNext = $true; continue
+        }
+        if ($arg -match "^-") { continue }
+        if ($pastCommand) {
+            if (Is-LocalOrUrl $arg) { continue }
+            $packages += $arg
+        }
+    }
+    return [PSCustomObject]@{ Packages = ($packages -join ","); RequirementsFile = $reqFile }
+}
+
+if (Is-InstallCommand $Args) {
+    $extracted = Extract-Packages $Args
+    $packages = $extracted.Packages
+    $reqFile = $extracted.RequirementsFile
+
+    if ($packages -or $reqFile) {
+        $ecosystem = "npm"
+        if ($OriginalCmd -match "^pip") { $ecosystem = "pypi" }
+
+        $cliArgs = @("check-security", "--ecosystem", $ecosystem, "--json")
+        if ($packages) { $cliArgs += @("--packages", $packages) }
+        if ($reqFile) { $cliArgs += @("--requirements", $reqFile) }
+
+        try {
+            & $BrainclawBin @cliArgs *> $null
+            $exitCode = $LASTEXITCODE
+        } catch {
+            $exitCode = 0
+        }
+
+        $detailsPkgs = if ($packages) { $packages } else { $reqFile }
+        if ($exitCode -eq 2) {
+            Write-Error "[brainclaw-guard] BLOCKED - supply chain risk detected (enforced mode)"
+            Write-Error "[brainclaw-guard] Details: $BrainclawBin check-security --ecosystem $ecosystem --packages \`"$detailsPkgs\`""
+            exit 1
+        } elseif ($exitCode -eq 1) {
+            Write-Warning "[brainclaw-guard] WARNING - potential supply chain risk (advisory or warn-threshold verdict)"
+            Write-Warning "[brainclaw-guard] Details: $BrainclawBin check-security --ecosystem $ecosystem --packages \`"$detailsPkgs\`""
+        }
+    }
+}
+
+& $OriginalCmd @Args
+exit $LASTEXITCODE
 `;
 }
 export function generatePipBashGuard(brainclawBin) {

package/dist/core/security-packages.js

@@ -0,0 +1,121 @@
+/**
+ * Canonical package matching for security allow/deny lists.
+ *
+ * Supports three entry forms:
+ *   "name"                 — bare name; matches any ecosystem
+ *   "ecosystem:name"       — ecosystem-scoped, any version
+ *   "ecosystem:name@version" — exact (ecosystem, name, version) pin
+ *
+ * Matching is exact on each component (no substring). Bare names match by
+ * package name only, which preserves backward compatibility with the MVP
+ * config while making the comparison precise instead of "purl.includes(d)".
+ */
+const ECOSYSTEMS = new Set(['npm', 'pypi']);
+/**
+ * Parse a package spec like "pkg", "pkg@1.0.0", "@scope/pkg",
+ * "@scope/pkg@1.0.0", or pip-style "pkg==1.0.0".
+ */
+export function parsePackageSpec(spec) {
+    const trimmed = spec.trim();
+    // pip-style "name==version"
+    const pipMatch = trimmed.match(/^([A-Za-z0-9._-]+)\s*==\s*([^\s,;]+)$/);
+    if (pipMatch) {
+        return { depname: pipMatch[1], version: pipMatch[2] };
+    }
+    // npm scoped: @scope/pkg or @scope/pkg@version
+    if (trimmed.startsWith('@')) {
+        const lastAt = trimmed.lastIndexOf('@');
+        if (lastAt > 0) {
+            return { depname: trimmed.slice(0, lastAt), version: trimmed.slice(lastAt + 1) || 'latest' };
+        }
+        return { depname: trimmed, version: 'latest' };
+    }
+    // pkg@version
+    if (trimmed.includes('@')) {
+        const idx = trimmed.indexOf('@');
+        return { depname: trimmed.slice(0, idx), version: trimmed.slice(idx + 1) || 'latest' };
+    }
+    return { depname: trimmed, version: 'latest' };
+}
+/**
+ * Parse an allow/deny list entry. Accepts:
+ *   "name"
+ *   "ecosystem:name"
+ *   "ecosystem:name@version"
+ * Whitespace tolerated. Unknown ecosystem prefixes are treated as bare
+ * names (so "lodash@1.0.0" still works as bare-name+version).
+ */
+export function parseListEntry(entry) {
+    const raw = entry;
+    const trimmed = entry.trim();
+    if (!trimmed) {
+        return { ecosystem: null, name: '', version: null, raw };
+    }
+    let ecosystem = null;
+    let remainder = trimmed;
+    // Only treat "<prefix>:" as ecosystem when <prefix> is a known ecosystem.
+    // This prevents misparsing of names that legitimately contain ":".
+    const colonIdx = trimmed.indexOf(':');
+    if (colonIdx > 0) {
+        const prefix = trimmed.slice(0, colonIdx).toLowerCase();
+        if (ECOSYSTEMS.has(prefix)) {
+            ecosystem = prefix;
+            remainder = trimmed.slice(colonIdx + 1);
+        }
+    }
+    // Now extract optional @version from remainder. Handle scoped names
+    // ("@scope/pkg") and pip "name==version" too.
+    const pipMatch = remainder.match(/^([A-Za-z0-9._-]+)\s*==\s*([^\s,;]+)$/);
+    if (pipMatch) {
+        return { ecosystem, name: pipMatch[1], version: pipMatch[2], raw };
+    }
+    if (remainder.startsWith('@')) {
+        const lastAt = remainder.lastIndexOf('@');
+        if (lastAt > 0) {
+            return {
+                ecosystem,
+                name: remainder.slice(0, lastAt),
+                version: remainder.slice(lastAt + 1) || null,
+                raw,
+            };
+        }
+        return { ecosystem, name: remainder, version: null, raw };
+    }
+    if (remainder.includes('@')) {
+        const idx = remainder.indexOf('@');
+        return {
+            ecosystem,
+            name: remainder.slice(0, idx),
+            version: remainder.slice(idx + 1) || null,
+            raw,
+        };
+    }
+    return { ecosystem, name: remainder, version: null, raw };
+}
+/**
+ * Returns true if (ecosystem, name, version) matches the parsed entry.
+ * Matching rules:
+ *  - entry.ecosystem null → any ecosystem
+ *  - entry.name must equal name exactly
+ *  - entry.version null → any version; otherwise exact equality with
+ *    "*" as a wildcard alias for "any version"
+ */
+export function matchesEntry(entry, ecosystem, name, version) {
+    if (entry.name === '')
+        return false;
+    if (entry.name !== name)
+        return false;
+    if (entry.ecosystem !== null && entry.ecosystem !== ecosystem)
+        return false;
+    if (entry.version !== null && entry.version !== '*' && entry.version !== version)
+        return false;
+    return true;
+}
+export function matchesAnyEntry(entries, ecosystem, name, version) {
+    for (const e of entries) {
+        if (matchesEntry(e, ecosystem, name, version))
+            return e;
+    }
+    return null;
+}
+//# sourceMappingURL=security-packages.js.map