osv-scanner-mcp 0.3.4 → 0.4.1

package/dist/tools/scanProject.js

@@ -0,0 +1,143 @@
+/**
+ * `scan_project`ツールのハンドラ: Java / JavaScript / Python / Goのlockfileをまとめてスキャンする。
+ *
+ * 誤要約対策(JAR実体スキャンと同じ原則): スキャンできなかった依存を示すcoverageを件数より前に置き、
+ * complete=falseの場合は「検出0件でも安全とは言えない」旨の警告を付ける。
+ */
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { parseOsvScanOutput } from "../osv/scanReport.js";
+import { sanitizeExternalText } from "../utils/externalText.js";
+import { detectProject } from "../utils/manifestDetector.js";
+import { normalizePypiName } from "../utils/requirementsFile.js";
+import { ScanSnapshot, snapshotManifests } from "../utils/scanSnapshot.js";
+import { dependencyResolution } from "./scanJavaProject.js";
+import { errorResult, jsonResult } from "./toolResult.js";
+const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml / requirements.txt)からの推移的依存の解決を省略しています。" +
+    "lockfile(package-lock.json / poetry.lock / go.mod / gradle.lockfile等)に記録された依存は対象ですが、" +
+    "pom.xml・requirements.txtに直接記載された依存の先にある推移的依存の脆弱性は含まれません。" +
+    "検出0件でも推移的依存の安全性は確認できていません";
+const INCOMPLETE_WARNING = "一部の依存はスキャンされていないか、版を推測してスキャンしています" +
+    "(lockfile_missing / unpinned_requirements / unscannable_requirements / skipped_filesを参照)。" +
+    "検出0件でも、それらの依存の安全性は確認できていません";
+/** coverageの各一覧の上限(巨大なrequirements.txtで応答を膨らませない) */
+const MAX_COVERAGE_ITEMS = 200;
+function capped(items) {
+    return { items: items.slice(0, MAX_COVERAGE_ITEMS), omitted: Math.max(0, items.length - MAX_COVERAGE_ITEMS) };
+}
+function buildCoverage(project) {
+    const rel = (file) => sanitizeExternalText(path.relative(project.projectDir, file));
+    const lockfileMissing = capped(project.lockfileMissing);
+    const unpinned = capped(project.requirementIssues);
+    const unscannable = capped(project.requirementReferences);
+    const skipped = capped(project.skippedFiles);
+    const complete = project.lockfileMissing.length === 0 &&
+        project.requirementIssues.length === 0 &&
+        project.requirementReferences.length === 0 &&
+        project.skippedFiles.length === 0;
+    const omitted = lockfileMissing.omitted + unpinned.omitted + unscannable.omitted + skipped.omitted;
+    return {
+        complete,
+        ...(complete ? {} : { warning: INCOMPLETE_WARNING }),
+        manifests: project.manifests.map((m) => ({ path: sanitizeExternalText(m.path), ecosystem: m.ecosystem, format: m.format })),
+        lockfile_missing: lockfileMissing.items.map((m) => ({
+            path: sanitizeExternalText(m.path),
+            ecosystem: m.ecosystem,
+            status: m.status,
+            hint: sanitizeExternalText(m.hint),
+        })),
+        unpinned_requirements: unpinned.items.map((issue) => ({
+            file: rel(issue.file),
+            line: issue.line,
+            name: sanitizeExternalText(issue.name),
+            specifier: sanitizeExternalText(issue.specifier),
+            kind: issue.kind,
+        })),
+        unscannable_requirements: unscannable.items.map((ref) => ({
+            file: rel(ref.file),
+            line: ref.line,
+            text: sanitizeExternalText(ref.text),
+            reason: ref.reason,
+        })),
+        skipped_files: skipped.items.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) })),
+        ...(omitted > 0 ? { omitted_items: omitted } : {}),
+    };
+}
+function ecosystemBreakdown(project, packages) {
+    const breakdown = {};
+    for (const manifest of project.manifests) {
+        breakdown[manifest.ecosystem] ??= { manifests: 0, vulnerable_package_count: 0, vulnerability_count: 0 };
+        breakdown[manifest.ecosystem].manifests++;
+    }
+    for (const pkg of packages) {
+        breakdown[pkg.ecosystem] ??= { manifests: 0, vulnerable_package_count: 0, vulnerability_count: 0 };
+        breakdown[pkg.ecosystem].vulnerable_package_count++;
+        breakdown[pkg.ecosystem].vulnerability_count += pkg.vulnerabilities.length;
+    }
+    return breakdown;
+}
+/** `>=X` / `~=X` の行は、osv-scannerが下限Xを使用中の版とみなしてスキャンしている */
+function markLowerBounds(project, packages) {
+    return packages.map((pkg) => pkg.ecosystem === "PyPI" &&
+        project.lowerBounds.some((lb) => lb.name === normalizePypiName(pkg.name) && lb.version === pkg.version)
+        ? { ...pkg, version_is_lower_bound: true }
+        : pkg);
+}
+/**
+ * requirements.txtは検証済みの正規化行だけを専用の一時ディレクトリに書いてスキャンする
+ * (元ファイルの取り込み指定をosv-scannerにたどらせない)。成功・失敗とも削除する。
+ */
+/**
+ * 元のファイルはosv-scannerに渡さず、スナップショット(scanSnapshot.ts)のコピーをスキャンする。
+ * lockfile・pom.xml(親POMの連鎖を含む)は安全に読んだ内容のコピー、requirements.txtは
+ * 検証済みの正規化行だけを書いたコピー。コピーできず外したファイルはskippedFilesに記録する。
+ */
+async function scanFromSnapshot(project, options) {
+    const snapshot = await ScanSnapshot.create();
+    try {
+        const { targets, skipped } = await snapshotManifests(snapshot, project.targets, {
+            projectDir: project.projectDir,
+            allowedRootReal: project.allowedRootReal,
+        });
+        if (skipped.length > 0) {
+            const skippedPaths = new Set(skipped.map((s) => s.path));
+            project.manifests = project.manifests.filter((m) => !skippedPaths.has(path.join(project.projectDir, m.path)));
+            project.skippedFiles.push(...skipped.map((s) => ({ path: path.relative(project.projectDir, s.path), reason: s.reason })));
+            if (project.manifests.length === 0) {
+                throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるlockfile・マニフェストがありません(${project.skippedFiles.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
+            }
+        }
+        for (const copy of project.requirementsCopies) {
+            if (copy.entries.length === 0)
+                continue;
+            targets.push({ path: await snapshot.writeGenerated(`${copy.entries.join("\n")}\n`), format: "requirements.txt" });
+        }
+        if (targets.length === 0)
+            return parseOsvScanOutput({ results: [] });
+        return await runOsvScan(targets, options);
+    }
+    finally {
+        await snapshot.cleanup();
+    }
+}
+export async function handleScanProject(args, options = {}) {
+    try {
+        const project = await detectProject(args.project_path, { allowedRoot: options.allowedRoot });
+        const noRemoteResolution = isRemoteResolutionDisabled(options);
+        const report = await scanFromSnapshot(project, { ...options, noRemoteResolution });
+        return jsonResult({
+            project_dir: project.projectDir,
+            dependency_resolution: dependencyResolution(noRemoteResolution, TRANSITIVE_OMITTED_WARNING),
+            coverage: buildCoverage(project),
+            ecosystem_breakdown: ecosystemBreakdown(project, report.packages),
+            vulnerable_package_count: report.vulnerable_package_count,
+            vulnerability_count: report.vulnerability_count,
+            severity_breakdown: report.severity_breakdown,
+            packages: markLowerBounds(project, report.packages),
+        });
+    }
+    catch (error) {
+        return errorResult(error);
+    }
+}

package/dist/tools/suggestFix.js

@@ -3,10 +3,10 @@
  * scan_java_projectと同じスキャンを実行し、脆弱なパッケージごとの
  * 推奨アップグレードバージョン(3段階Tier)を返す。
  */
-import { isRemoteResolutionDisabled, runOsvScan } from "../osv/runner.js";
+import { isRemoteResolutionDisabled } from "../osv/runner.js";
 import { suggestUpgrades } from "../osv/suggestFix.js";
 import { detectJavaProject } from "../utils/projectDetector.js";
-import { dependencyResolution, } from "./scanJavaProject.js";
+import { dependencyResolution, scanJavaManifests, skippedManifestsFields, } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleSuggestFix(args, options = {}) {
     try {
@@ -14,12 +14,13 @@ export async function handleSuggestFix(args, options = {}) {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const report = await runOsvScan(project.manifestPaths, { ...options, noRemoteResolution });
+        const { manifests, skipped, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
         const suggestions = suggestUpgrades(report.packages);
         const unfixedVulnerabilities = suggestions.reduce((sum, s) => sum + s.per_cve_detail.filter((d) => d.tier === "unfixed").length, 0);
         return jsonResult({
             project_dir: project.projectDir,
-            manifests: project.manifests,
+            manifests,
+            ...skippedManifestsFields(skipped),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             vulnerable_package_count: suggestions.length,
             unfixed_vulnerability_count: unfixedVulnerabilities,

package/dist/utils/manifestDetector.js

@@ -0,0 +1,252 @@
+/**
+ * `scan_project`用の検出: Java / JavaScript / Python / Goのlockfileを列挙する。
+ *
+ * - 検出したファイルだけをosv-scannerに渡す(ディレクトリは渡さない)。解析形式も明示する
+ * - パッケージマネージャー・ビルドは実行しない。lockfileが無いマニフェストはcoverageに記録する
+ * - requirements.txtは取り込み先を検証し、プロジェクト外を読む場合はスキャン対象から外す
+ *
+ * 検出・除外の根拠はdocs/DESIGN_TODO.md「対象エコシステム拡大 詳細設計メモ」を参照。
+ */
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
+import { readRegularFile } from "./safeRead.js";
+import { analyzeRequirementsFile, createRequirementsReadContext, } from "./requirementsFile.js";
+/** ファイル名→(エコシステム, 解析形式)。npm-shrinkwrap.jsonはpackage-lock.json形式で解析する */
+const LOCKFILES = new Map([
+    ["pom.xml", { ecosystem: "Maven", format: "pom.xml" }],
+    ["gradle.lockfile", { ecosystem: "Maven", format: "gradle.lockfile" }],
+    ["buildscript-gradle.lockfile", { ecosystem: "Maven", format: "buildscript-gradle.lockfile" }],
+    ["package-lock.json", { ecosystem: "npm", format: "package-lock.json" }],
+    ["npm-shrinkwrap.json", { ecosystem: "npm", format: "package-lock.json" }],
+    ["yarn.lock", { ecosystem: "npm", format: "yarn.lock" }],
+    ["pnpm-lock.yaml", { ecosystem: "npm", format: "pnpm-lock.yaml" }],
+    ["bun.lock", { ecosystem: "npm", format: "bun.lock" }],
+    ["poetry.lock", { ecosystem: "PyPI", format: "poetry.lock" }],
+    ["uv.lock", { ecosystem: "PyPI", format: "uv.lock" }],
+    ["Pipfile.lock", { ecosystem: "PyPI", format: "Pipfile.lock" }],
+    ["pdm.lock", { ecosystem: "PyPI", format: "pdm.lock" }],
+    ["go.mod", { ecosystem: "Go", format: "go.mod" }],
+]);
+/** requirements.txt / requirements-dev.txt / dev-requirements.txt 等 */
+const REQUIREMENTS_NAME = /^(?:[\w.]+[-_])?requirements(?:[-_][\w.]+)?\.txt$/;
+/** lockfileが無ければスキャンできないマニフェスト */
+const LOCK_MARKERS = new Map([
+    ["package.json", "npm"],
+    ["pyproject.toml", "pypi"],
+    ["Pipfile", "pypi"],
+    ["setup.py", "pypi"],
+    ["setup.cfg", "pypi"],
+    ["build.gradle", "gradle"],
+    ["build.gradle.kts", "gradle"],
+    ["settings.gradle", "gradle"],
+    ["settings.gradle.kts", "gradle"],
+]);
+const LOCK_GROUP_ECOSYSTEM = { npm: "npm", pypi: "PyPI", gradle: "Maven" };
+const LOCKFILE_HINTS = {
+    npm: "lockfileがありません。信頼できる環境で `npm install --package-lock-only --ignore-scripts`" +
+        "(yarn / pnpm / bunの場合は各ツールのlockfile生成)を実行してから再スキャンしてください",
+    pypi: "lockfile(poetry.lock / uv.lock / Pipfile.lock / pdm.lock)またはバージョンを固定したrequirements.txtがありません。" +
+        "信頼できる環境で生成してから再スキャンしてください(生成時にビルドスクリプトが実行される場合があります)",
+    gradle: "gradle.lockfileがありません。信頼できる環境で `./gradlew dependencies --write-locks` を実行してから再スキャンしてください" +
+        "(依存ロック未設定の場合は build.gradle に dependencyLocking { lockAllConfigurations() } の追加が必要です)",
+};
+const SKIPPED_DIRS = new Set([
+    ".git", "node_modules", "target", "build", ".idea", ".vscode",
+    ".venv", "venv", "site-packages", "__pycache__", ".tox", "vendor",
+]);
+function classifyFile(name) {
+    const lockfile = LOCKFILES.get(name);
+    if (lockfile)
+        return lockfile;
+    if (REQUIREMENTS_NAME.test(name))
+        return { ecosystem: "PyPI", format: "requirements.txt" };
+    return null;
+}
+function satisfiesGroup(manifest, group) {
+    if (group === "gradle")
+        return manifest.format === "gradle.lockfile" || manifest.format === "buildscript-gradle.lockfile";
+    return manifest.ecosystem === LOCK_GROUP_ECOSYSTEM[group];
+}
+/** dirがancestor自身またはその配下か(projectDirからの相対パス同士で判定) */
+function isSameOrDescendant(dir, ancestor) {
+    return ancestor === "." || dir === ancestor || dir.startsWith(`${ancestor}${path.sep}`);
+}
+/** workspaceの収録確認で読むlockfile1件の上限と、1回の検出での合計の上限 */
+const MAX_LOCKFILE_BYTES = 64 * 1024 * 1024;
+const MAX_LOCKFILE_TOTAL_BYTES = 256 * 1024 * 1024;
+/**
+ * workspaceの収録確認用に、package-lock.jsonの`packages`のキー一覧を1回だけ読む。
+ * package.jsonの数だけ同じlockfileを解析し直すと、巨大なlockfileで負荷が増大するため、
+ * lockfileごとに結果を使い回し、読む量の合計にも上限を設ける。
+ */
+export class LockfileKeyCache {
+    keys = new Map();
+    remaining;
+    constructor(maxTotalBytes = MAX_LOCKFILE_TOTAL_BYTES) {
+        this.remaining = maxTotalBytes;
+    }
+    /** 収録済みのキー。null=確認できない(v1形式・読めない・大きすぎる・上限超過) */
+    async get(lockAbs, projectDir) {
+        if (this.keys.has(lockAbs))
+            return this.keys.get(lockAbs);
+        let keys = null;
+        if (this.remaining > 0) {
+            const read = await readRegularFile(lockAbs, { maxBytes: Math.min(MAX_LOCKFILE_BYTES, this.remaining), boundary: projectDir });
+            if (read.ok) {
+                this.remaining -= read.bytes.length;
+                try {
+                    const packages = JSON.parse(read.bytes.toString("utf8")).packages;
+                    if (typeof packages === "object" && packages !== null)
+                        keys = new Set(Object.keys(packages));
+                }
+                catch {
+                    keys = null;
+                }
+            }
+        }
+        this.keys.set(lockAbs, keys);
+        return keys;
+    }
+}
+/**
+ * package-lock.json(v2以降)の`packages`に、memberDirのエントリがあるか。
+ * true=収録 / false=未収録 / null=確認できない
+ */
+async function npmLockfileRecords(cache, projectDir, lockfile, memberDir) {
+    const lockAbs = path.join(projectDir, lockfile.path);
+    const keys = await cache.get(lockAbs, projectDir);
+    if (keys === null)
+        return null;
+    const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
+    return keys.has(key);
+}
+/**
+ * lockfileの無いマーカー(package.json等)を判定する。
+ * - 同じディレクトリに同じエコシステムのlockfileがあれば充足
+ * - 上位のlockfileだけの場合は、収録を確認できたときだけ充足(npm workspacesのpackage-lock.json)。
+ *   workspace設定の無いルートのlockfileで、独立した子プロジェクトの欠落を隠さないため
+ */
+async function findLockfileMissing(projectDir, markers, manifests) {
+    const cache = new LockfileKeyCache();
+    const missing = [];
+    for (const marker of markers) {
+        const markerDir = path.dirname(marker.path);
+        const candidates = manifests.filter((m) => satisfiesGroup(m, marker.group) && isSameOrDescendant(markerDir, path.dirname(m.path)));
+        if (candidates.some((m) => path.dirname(m.path) === markerDir))
+            continue;
+        const base = { path: marker.path, ecosystem: LOCK_GROUP_ECOSYSTEM[marker.group] };
+        if (candidates.length === 0) {
+            missing.push({ ...base, status: "missing", hint: LOCKFILE_HINTS[marker.group] });
+            continue;
+        }
+        let confirmedAbsent = true;
+        let recorded = false;
+        for (const candidate of candidates) {
+            const result = candidate.format === "package-lock.json"
+                ? await npmLockfileRecords(cache, projectDir, candidate, markerDir)
+                : null;
+            if (result === true)
+                recorded = true;
+            if (result !== false)
+                confirmedAbsent = false;
+        }
+        if (recorded)
+            continue;
+        const lockfiles = candidates.map((m) => m.path).join(", ");
+        missing.push(confirmedAbsent
+            ? { ...base, status: "missing", hint: `上位のlockfile(${lockfiles})には収録されていません。${LOCKFILE_HINTS[marker.group]}` }
+            : {
+                ...base,
+                status: "unconfirmed",
+                hint: `上位のlockfile(${lockfiles})に収録されているか確認できません。workspaceのメンバーでない場合は、${LOCKFILE_HINTS[marker.group]}`,
+            });
+    }
+    return missing;
+}
+async function finalize(projectDir, manifests, markers, allowedRootReal) {
+    const result = {
+        projectDir,
+        allowedRootReal,
+        manifests: [],
+        targets: [],
+        requirementsCopies: [],
+        lockfileMissing: await findLockfileMissing(projectDir, markers, manifests),
+        requirementIssues: [],
+        requirementReferences: [],
+        lowerBounds: [],
+        skippedFiles: [],
+    };
+    const readContext = createRequirementsReadContext();
+    for (const manifest of manifests) {
+        const absolute = path.join(projectDir, manifest.path);
+        if (manifest.format === "requirements.txt") {
+            const analysis = await analyzeRequirementsFile(absolute, projectDir, readContext);
+            if (!analysis.ok) {
+                result.skippedFiles.push({ path: manifest.path, reason: analysis.reason });
+                continue;
+            }
+            result.requirementIssues.push(...analysis.issues);
+            result.requirementReferences.push(...analysis.references);
+            result.lowerBounds.push(...analysis.lowerBounds);
+            result.requirementsCopies.push({ path: manifest.path, entries: analysis.entries });
+        }
+        else {
+            result.targets.push({ path: absolute, format: manifest.format });
+        }
+        result.manifests.push(manifest);
+    }
+    if (result.manifests.length === 0) {
+        const details = [
+            ...result.lockfileMissing.map((m) => `${m.path}: ${m.hint}`),
+            ...result.skippedFiles.map((s) => `${s.path}: ${s.reason}`),
+        ];
+        throw new ScanToolError("no_manifest_found", `スキャンできるlockfile・マニフェストが見つかりません: ${projectDir}` +
+            (details.length > 0 ? `(${details.join(" / ")})` : ""));
+    }
+    return result;
+}
+/**
+ * 入力パスを検証し、プロジェクト内のlockfile・マニフェストを検出する。
+ * 対応ファイルの直接指定は、そのファイル1件だけを対象にする(親ディレクトリを探索しない)。
+ */
+export async function detectProject(inputPath, options = {}) {
+    if (typeof inputPath !== "string" || inputPath.trim() === "") {
+        throw new ScanToolError("project_not_found", "スキャン対象のパスが指定されていません");
+    }
+    const resolved = await resolveExistingPath(inputPath);
+    const stats = await stat(resolved);
+    const name = path.basename(resolved);
+    const direct = stats.isFile() ? classifyFile(name) : null;
+    let projectDir;
+    if (stats.isDirectory()) {
+        projectDir = resolved;
+    }
+    else if (stats.isFile() && (direct !== null || LOCK_MARKERS.has(name))) {
+        projectDir = path.dirname(resolved);
+    }
+    else {
+        throw new ScanToolError("project_not_found", `指定されたパスはディレクトリでも対応するlockfile・マニフェストでもありません: ${inputPath}`);
+    }
+    const allowedRootReal = options.allowedRoot !== undefined ? await resolveExistingPath(options.allowedRoot) : undefined;
+    if (allowedRootReal !== undefined)
+        assertInsideAllowedRoot(projectDir, allowedRootReal);
+    if (direct !== null) {
+        return finalize(projectDir, [{ path: name, ...direct }], [], allowedRootReal);
+    }
+    const manifests = [];
+    const markers = [];
+    await walkProjectFiles(projectDir, options, SKIPPED_DIRS, (relativePath, fileName) => {
+        const found = classifyFile(fileName);
+        if (found) {
+            manifests.push({ path: relativePath, ...found });
+            return true;
+        }
+        const group = LOCK_MARKERS.get(fileName);
+        if (group)
+            markers.push({ path: relativePath, group });
+        return false;
+    });
+    return finalize(projectDir, manifests, markers, allowedRootReal);
+}

package/dist/utils/manifestFormats.js

@@ -0,0 +1,23 @@
+/**
+ * osv-scannerに`--lockfile <形式>:<絶対パス>`で個別に渡せる解析形式(2.4.0で実機確認)。
+ * ここに無い形式はosv-scannerに渡さない。npm-shrinkwrap.jsonは"package-lock.json"形式で解析する。
+ */
+export const MANIFEST_FORMATS = [
+    "pom.xml",
+    "gradle.lockfile",
+    "buildscript-gradle.lockfile",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "poetry.lock",
+    "uv.lock",
+    "Pipfile.lock",
+    "pdm.lock",
+    "requirements.txt",
+    "go.mod",
+];
+const FORMAT_SET = new Set(MANIFEST_FORMATS);
+export function isManifestFormat(value) {
+    return FORMAT_SET.has(value);
+}

package/dist/utils/pomParent.js

@@ -0,0 +1,150 @@
+/**
+ * pom.xmlの親POM(`<parent><relativePath>`)の参照の解釈。連鎖のコピーと検証はscanSnapshot.tsが行う。
+ *
+ * osv-scanner v2.4.0の実機確認(2026-10-07):
+ * - `<relativePath>`の指す親POMを読み、その依存を結果に含める(`--no-resolve`でも同じ)。親の親もたどる
+ * - `<relativePath>`省略時はMavenの既定値`../pom.xml`を参照する。ディレクトリを指す場合はその中のpom.xml
+ * - `<relativePath/>`(空)はローカルを参照しない。親のGAVが一致しない場合も読まない
+ *
+ * スナップショット方式では、osv-scannerが読めるのはコピーしたファイルだけのため、ここでの解釈が
+ * osv-scannerとずれても範囲外は読まれない(最悪でも親が見つからない)。解釈できない場合の除外は、
+ * 親から引き継ぐ依存を黙って欠落させないためのもの。
+ */
+const DEFAULT_RELATIVE_PATH = "../pom.xml";
+const NAMED_ENTITIES = { lt: "<", gt: ">", amp: "&", apos: "'", quot: '"' };
+/** XMLの文字参照・定義済み実体参照を展開する。未知の実体はundefined */
+function decodeEntities(text) {
+    let unknown = false;
+    const decoded = text.replace(/&([^;\s&]*);?/g, (match, body) => {
+        if (!match.endsWith(";"))
+            unknown = true;
+        else if (/^#x[0-9a-fA-F]+$/.test(body))
+            return String.fromCodePoint(parseInt(body.slice(2), 16));
+        else if (/^#[0-9]+$/.test(body))
+            return String.fromCodePoint(parseInt(body.slice(1), 10));
+        else if (body in NAMED_ENTITIES)
+            return NAMED_ENTITIES[body];
+        else
+            unknown = true;
+        return match;
+    });
+    return unknown ? undefined : decoded;
+}
+/**
+ * 親POMのrelativePath。null=親なし / ""=ローカルを参照しない / undefined=解釈できない(除外する)
+ *
+ * osv-scannerのXMLデコーダー(Go)の挙動に合わせる(2026-10-07 実機確認):
+ * - 要素は名前空間・接頭辞に関係なくローカル名で照合する(`<m:parent>`も親として読む)。大文字小文字は区別する
+ * - ルート要素の直下の`parent`だけが対象(入れ子の`parent`は無視される)。複数あると後のものが有効になる
+ * - 実体参照・CDATAは展開され、relativePathの前後の空白は除かれる
+ * 正規表現で「最初の<parent>」を探すと、おとりの入れ子・重複・接頭辞で迂回されるため、先頭から順に読む。
+ * 判断を誤ると範囲外を読ませるので、複数のparent/relativePath、CDATA、DOCTYPE、閉じていないタグなど、
+ * Goと同じ解釈を保証できない構文は解釈できない(undefined)として扱う。
+ */
+export function parentRelativePath(source) {
+    // XML 1.0の行末処理: 解析前にCRLF・単独のCRをLFへ正規化する(Goのデコーダーも同じ)。
+    // 正規化しないと、検査側は"a\rb"を探して存在しないと判断し、osv-scannerは"a\nb"を読む
+    const xml = source.replace(/\r\n?/g, "\n");
+    const stack = [];
+    let parents = 0;
+    let relativePaths = 0;
+    let relativeText = null;
+    let capturing = false;
+    let pos = 0;
+    while (pos < xml.length) {
+        const lt = xml.indexOf("<", pos);
+        const textEnd = lt === -1 ? xml.length : lt;
+        if (capturing)
+            relativeText += xml.slice(pos, textEnd);
+        if (lt === -1)
+            break;
+        if (xml.startsWith("<!--", lt)) {
+            const end = xml.indexOf("-->", lt + 4);
+            if (end === -1)
+                return undefined;
+            pos = end + 3;
+            continue;
+        }
+        if (xml.startsWith("<!", lt))
+            return undefined; // CDATA・DOCTYPE・ENTITY宣言
+        if (xml.startsWith("<?", lt)) {
+            const end = xml.indexOf("?>", lt + 2);
+            if (end === -1)
+                return undefined;
+            pos = end + 2;
+            continue;
+        }
+        // タグの終わりを探す(属性値の引用符内の'>'は除く)
+        let i = lt + 1;
+        let quote = null;
+        for (; i < xml.length; i++) {
+            const c = xml[i];
+            if (quote !== null) {
+                if (c === quote)
+                    quote = null;
+            }
+            else if (c === '"' || c === "'")
+                quote = c;
+            else if (c === ">")
+                break;
+        }
+        if (i >= xml.length)
+            return undefined;
+        const raw = xml.slice(lt + 1, i);
+        pos = i + 1;
+        if (raw.startsWith("/")) {
+            const name = raw.slice(1).trim();
+            if (stack.pop() !== name)
+                return undefined; // 対応しない終了タグ
+            if (capturing && stack.length === 2)
+                capturing = false; // relativePathの終了
+            continue;
+        }
+        const qname = /^[^\s/]+/.exec(raw)?.[0];
+        if (qname === undefined)
+            return undefined;
+        const local = qname.slice(qname.lastIndexOf(":") + 1);
+        const selfClosing = raw.endsWith("/");
+        const depth = stack.length; // 0=ルート
+        if (capturing)
+            return undefined; // relativePathの中に要素がある
+        if (depth === 1 && local === "parent")
+            parents++;
+        if (depth === 2 && local === "relativePath" && stack[1].slice(stack[1].lastIndexOf(":") + 1) === "parent") {
+            relativePaths++;
+            relativeText = "";
+            capturing = !selfClosing;
+        }
+        if (!selfClosing)
+            stack.push(qname);
+    }
+    if (stack.length !== 0 || capturing)
+        return undefined; // 閉じていないタグ
+    if (parents === 0)
+        return null;
+    if (parents > 1 || relativePaths > 1)
+        return undefined;
+    if (relativePaths === 0)
+        return DEFAULT_RELATIVE_PATH;
+    const decoded = decodeEntities(relativeText);
+    // プロパティ参照(${...})は評価できない
+    if (decoded === undefined || decoded.includes("${"))
+        return undefined;
+    const trimmed = decoded.replace(/^[ \t\n]+|[ \t\n]+$/g, "");
+    // 制御文字・通常の空白以外の空白・書式文字は、文字の正規化や前後の空白の除去の細部
+    // (JSとGoで扱いが異なる)で参照先がずれうるため、解釈できないものとして除外する
+    if (/[\p{Cc}\p{Cf}\u0085]|(?! )\p{Z}/u.test(trimmed))
+        return undefined;
+    return trimmed;
+}
+/** UTF-8として厳密に読む。不正なバイト列・NULを含む場合はnull(Goと同じ解釈を保証できない) */
+export function decodePomBytes(bytes) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false }).decode(bytes);
+    }
+    catch {
+        return null;
+    }
+    return text.includes("\u0000") ? null : text;
+}