osv-scanner-mcp 0.3.4 → 0.4.0

package/dist/utils/manifestDetector.js

@@ -0,0 +1,226 @@
+/**
+ * `scan_project`用の検出: Java / JavaScript / Python / Goのlockfileを列挙する。
+ *
+ * - 検出したファイルだけをosv-scannerに渡す(ディレクトリは渡さない)。解析形式も明示する
+ * - パッケージマネージャー・ビルドは実行しない。lockfileが無いマニフェストはcoverageに記録する
+ * - requirements.txtは取り込み先を検証し、プロジェクト外を読む場合はスキャン対象から外す
+ *
+ * 検出・除外の根拠はdocs/DESIGN_TODO.md「対象エコシステム拡大 詳細設計メモ」を参照。
+ */
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { ScanToolError } from "../errors.js";
+import { pomParentOutsideRoot } from "./pomParent.js";
+import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
+import { analyzeRequirementsFile, } 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の収録確認で読むlockfileの上限 */
+const MAX_LOCKFILE_BYTES = 64 * 1024 * 1024;
+/**
+ * package-lock.json(v2以降)の`packages`に、memberDirのエントリがあるか。
+ * true=収録 / false=未収録 / null=確認できない(v1形式・読めない・大きすぎる)
+ */
+async function npmLockfileRecords(projectDir, lockfile, memberDir) {
+    const lockAbs = path.join(projectDir, lockfile.path);
+    try {
+        if ((await stat(lockAbs)).size > MAX_LOCKFILE_BYTES)
+            return null;
+        const packages = JSON.parse(await readFile(lockAbs, "utf8")).packages;
+        if (typeof packages !== "object" || packages === null)
+            return null;
+        const key = path.relative(path.dirname(lockAbs), path.join(projectDir, memberDir)).split(path.sep).join("/");
+        return Object.hasOwn(packages, key);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * lockfileの無いマーカー(package.json等)を判定する。
+ * - 同じディレクトリに同じエコシステムのlockfileがあれば充足
+ * - 上位のlockfileだけの場合は、収録を確認できたときだけ充足(npm workspacesのpackage-lock.json)。
+ *   workspace設定の無いルートのlockfileで、独立した子プロジェクトの欠落を隠さないため
+ */
+async function findLockfileMissing(projectDir, markers, manifests) {
+    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(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,
+        manifests: [],
+        targets: [],
+        requirementsCopies: [],
+        lockfileMissing: await findLockfileMissing(projectDir, markers, manifests),
+        requirementIssues: [],
+        requirementReferences: [],
+        lowerBounds: [],
+        skippedFiles: [],
+    };
+    for (const manifest of manifests) {
+        const absolute = path.join(projectDir, manifest.path);
+        if (manifest.format === "requirements.txt") {
+            const analysis = await analyzeRequirementsFile(absolute, projectDir);
+            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 {
+            const outside = manifest.format === "pom.xml" ? await pomParentOutsideRoot(absolute, allowedRootReal) : null;
+            if (outside !== null) {
+                result.skippedFiles.push({ path: manifest.path, reason: outside });
+                continue;
+            }
+            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,206 @@
+/**
+ * pom.xmlの親POM(`<parent><relativePath>`)が、スキャン許可ルート(OSV_MCP_ALLOWED_ROOT)の外を
+ * 参照していないかを検証する。
+ *
+ * osv-scanner v2.4.0の実機確認(2026-10-07):
+ * - `<relativePath>`の指す親POMを読み、その依存を結果に含める(`--no-resolve`でも同じ)。親の親もたどる
+ * - `<relativePath>`省略時はMavenの既定値`../pom.xml`を参照する。ディレクトリを指す場合はその中のpom.xml
+ * - `<relativePath/>`(空)はローカルを参照しない。親のGAVが一致しない場合も読まない
+ *
+ * サブモジュールのスキャンで親POMを読むのは正当な動作のため、境界はプロジェクトディレクトリではなく
+ * 許可ルートとする(未設定時は任意のパスをスキャンできる状態のため検証しない)。GAVの一致は判定が
+ * 複雑(親から引き継がれる)なため確認せず、許可ルートの外に参照先のファイルがあれば安全側に除外する。
+ */
+import { readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import { isInsideDir } from "./projectWalk.js";
+const MAX_POM_BYTES = 10 * 1024 * 1024;
+const MAX_PARENT_DEPTH = 10;
+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と同じ解釈を保証できない) */
+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;
+}
+/** 参照先を実ファイルに解決する。存在しなければnull(osv-scannerもローカルからは読まない) */
+async function resolveParentFile(fromPom, relativePath) {
+    let candidate = path.resolve(path.dirname(fromPom), relativePath);
+    try {
+        if ((await stat(candidate)).isDirectory())
+            candidate = path.join(candidate, "pom.xml");
+        return await realpath(candidate);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 親POMの連鎖が許可ルートの外を参照していれば、除外理由を返す。問題なければnull。
+ * @param pomPath 検出済みのpom.xmlの絶対パス
+ * @param allowedRootReal 解決済みの許可ルート。未設定なら検証しない
+ */
+export async function pomParentOutsideRoot(pomPath, allowedRootReal) {
+    if (allowedRootReal === undefined)
+        return null;
+    let current = pomPath;
+    for (let depth = 0; depth < MAX_PARENT_DEPTH; depth++) {
+        let bytes;
+        try {
+            if ((await stat(current)).size > MAX_POM_BYTES)
+                return `親POMの確認でサイズ上限を超えるpom.xmlがあります(${path.basename(current)})`;
+            bytes = await readFile(current);
+        }
+        catch {
+            return null; // 読めないファイルはosv-scannerも読めない
+        }
+        const xml = decodePomBytes(bytes);
+        const relativePath = xml === null ? undefined : parentRelativePath(xml);
+        if (relativePath === null || relativePath === "")
+            return null;
+        if (relativePath === undefined) {
+            return ("親POMの指定を確実に解釈できないため(親要素の重複、CDATA・DOCTYPE、プロパティ参照、UTF-8以外の文字コード等)、" +
+                "許可ルート内か確認できずスキャン対象から外しました");
+        }
+        const parentFile = await resolveParentFile(current, relativePath);
+        if (parentFile === null)
+            return null;
+        if (!isInsideDir(allowedRootReal, parentFile)) {
+            return (`親POM(relativePath: ${relativePath})が許可ルート(OSV_MCP_ALLOWED_ROOT)の外を参照しているため、スキャン対象から外しました` +
+                "(親のGAVが一致しなければosv-scannerは読みませんが、境界の外のため確認せず除外します)");
+        }
+        current = parentFile;
+    }
+    return `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`;
+}

package/dist/utils/projectDetector.js

@@ -11,22 +11,23 @@
  * `project_path`はLLM・ユーザー由来の信頼できない入力として扱う:
  * - `realpath`で正規化し、シンボリックリンクを解決した実体パスで判定する
  * - `allowedRoot`指定時は、解決後のパスがその配下にあることを検証する(パストラバーサル対策)
- * - マニフェスト探索はエントリ数・件数・深さに上限を設け、シンボリックリンクのディレクトリは辿らない
+ * - 走査は上限付きで、シンボリックリンクのディレクトリは辿らない(projectWalk.ts)
  *
  * 検出したマニフェストが、そのままOSV-Scannerのスキャン範囲になる(ディレクトリは渡さない)。
- * そのため探索を深さで打ち切らず(Javaのソースツリーは深い)、上限に達した場合は
- * 結果を黙って欠落させずにエラーにする。
  */
-import { readdir, realpath, stat } from "node:fs/promises";
+import { stat } from "node:fs/promises";
 import path from "node:path";
 import { ScanToolError } from "../errors.js";
-const DEFAULT_MAX_DEPTH = 64;
-const DEFAULT_MAX_ENTRIES = 200_000;
-const DEFAULT_MAX_MANIFESTS = 1_000;
+import { pomParentOutsideRoot } from "./pomParent.js";
+import { assertInsideAllowedRoot, resolveExistingPath, walkProjectFiles, } from "./projectWalk.js";
 /** ビルド成果物・VCS等、マニフェスト探索でスキップするディレクトリ */
 const SKIPPED_DIRS = new Set([".git", "node_modules", "target", "build", ".idea", ".vscode"]);
-/** OSV-Scannerがスキャンできるマニフェスト(実機確認済み) */
-const MANIFEST_FILENAMES = new Set(["pom.xml", "gradle.lockfile", "buildscript-gradle.lockfile"]);
+/** OSV-Scannerがスキャンできるマニフェスト(実機確認済み)。ファイル名がそのまま解析形式になる */
+const MANIFEST_FILENAMES = new Set([
+    "pom.xml",
+    "gradle.lockfile",
+    "buildscript-gradle.lockfile",
+]);
 /** Gradleプロジェクトの存在を示すが、それ自体はスキャンできないビルドファイル */
 const GRADLE_BUILD_FILENAMES = new Set([
     "build.gradle",
@@ -38,62 +39,27 @@ const GRADLE_LOCKFILE_GUIDANCE = "Gradleプロジェクトを検出しました
     "本ツールはlockfile方式のみ対応しています(ビルド実行方式はbuild.gradleの任意コード実行を伴うため非対応)。" +
     "`./gradlew dependencies --write-locks` でlockfileを生成してから再実行してください" +
     "(依存ロックが未設定の場合は build.gradle に dependencyLocking { lockAllConfigurations() } の追加が必要です)";
-async function resolveExistingPath(inputPath) {
-    try {
-        return await realpath(path.resolve(inputPath));
-    }
-    catch {
-        throw new ScanToolError("project_not_found", `指定されたパスが存在しません: ${inputPath}`);
-    }
-}
-function assertInsideAllowedRoot(resolvedDir, allowedRootReal) {
-    const relative = path.relative(allowedRootReal, resolvedDir);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        throw new ScanToolError("path_outside_allowed_root", `指定されたパスは許可されたディレクトリ(${allowedRootReal})の外にあります`);
-    }
-}
-function searchLimitError(reason) {
-    return new ScanToolError("manifest_search_limit_exceeded", `マニフェスト探索が上限(${reason})に達したため、スキャンを中止しました。` +
-        "結果の欠落を避けるため途中までの結果は返しません。より狭いディレクトリ、またはpom.xml / gradle.lockfileを直接指定してください");
-}
-/** 上限付きでマニフェストを探索する。シンボリックリンクは辿らない。上限到達はエラー。 */
-async function findManifests(rootDir, limits) {
+/** 親POMが許可ルートの外を参照するpom.xmlを除外して結果を組み立てる。全件除外ならエラー */
+async function buildResult(projectDir, detected, allowedRootReal) {
     const manifests = [];
-    let gradleBuildFileFound = false;
-    let visited = 0;
-    let currentLevel = [rootDir];
-    for (let depth = 1; currentLevel.length > 0; depth++) {
-        if (depth > limits.maxDepth)
-            throw searchLimitError(`深さ${limits.maxDepth}`);
-        const nextLevel = [];
-        for (const dir of currentLevel) {
-            let entries;
-            try {
-                entries = await readdir(dir, { withFileTypes: true });
-            }
-            catch {
-                continue; // 読めないディレクトリはスキップ(権限不足等)
-            }
-            for (const entry of entries) {
-                if (++visited > limits.maxEntries)
-                    throw searchLimitError(`${limits.maxEntries}エントリ`);
-                if (entry.isFile() && MANIFEST_FILENAMES.has(entry.name)) {
-                    if (manifests.length >= limits.maxManifests)
-                        throw searchLimitError(`マニフェスト${limits.maxManifests}件`);
-                    manifests.push(path.relative(rootDir, path.join(dir, entry.name)));
-                }
-                else if (entry.isFile() && GRADLE_BUILD_FILENAMES.has(entry.name)) {
-                    gradleBuildFileFound = true;
-                }
-                else if (entry.isDirectory() && !SKIPPED_DIRS.has(entry.name)) {
-                    // isDirectory()はシンボリックリンクに対してfalseを返すため、リンクは自然に除外される
-                    nextLevel.push(path.join(dir, entry.name));
-                }
-            }
-        }
-        currentLevel = nextLevel;
+    const skipped = [];
+    for (const manifest of detected) {
+        const reason = path.basename(manifest) === "pom.xml"
+            ? await pomParentOutsideRoot(path.join(projectDir, manifest), allowedRootReal)
+            : null;
+        if (reason !== null)
+            skipped.push({ path: manifest, reason });
+        else
+            manifests.push(manifest);
+    }
+    if (manifests.length === 0) {
+        throw new ScanToolError("path_outside_allowed_root", `スキャンできるマニフェストがありません(${skipped.map((s) => `${s.path}: ${s.reason}`).join(" / ")})`);
     }
-    return { manifests, gradleBuildFileFound };
+    const targets = manifests.map((manifest) => ({
+        path: path.join(projectDir, manifest),
+        format: path.basename(manifest),
+    }));
+    return { projectDir, manifests, targets, skipped };
 }
 /**
  * 入力パスを検証し、スキャン対象のJavaプロジェクトとして解決する。
@@ -110,10 +76,10 @@ export async function detectJavaProject(inputPath, options = {}) {
     // 親ディレクトリを探索しないため、探索上限エラーの回避手段として使える
     if (stats.isFile() && MANIFEST_FILENAMES.has(path.basename(resolved))) {
         const projectDir = path.dirname(resolved);
-        if (options.allowedRoot !== undefined) {
-            assertInsideAllowedRoot(projectDir, await resolveExistingPath(options.allowedRoot));
-        }
-        return { projectDir, manifests: [path.basename(resolved)], manifestPaths: [resolved] };
+        const allowedRootReal = options.allowedRoot !== undefined ? await resolveExistingPath(options.allowedRoot) : undefined;
+        if (allowedRootReal !== undefined)
+            assertInsideAllowedRoot(projectDir, allowedRootReal);
+        return buildResult(projectDir, [path.basename(resolved)], allowedRootReal);
     }
     let projectDir;
     if (stats.isDirectory()) {
@@ -127,13 +93,19 @@ export async function detectJavaProject(inputPath, options = {}) {
     else {
         throw new ScanToolError("project_not_found", `指定されたパスはディレクトリでも対応マニフェスト(pom.xml / gradle.lockfile)でもありません: ${inputPath}`);
     }
-    if (options.allowedRoot !== undefined) {
-        assertInsideAllowedRoot(projectDir, await resolveExistingPath(options.allowedRoot));
-    }
-    const { manifests, gradleBuildFileFound } = await findManifests(projectDir, {
-        maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH,
-        maxEntries: options.maxEntries ?? DEFAULT_MAX_ENTRIES,
-        maxManifests: options.maxManifests ?? DEFAULT_MAX_MANIFESTS,
+    const allowedRootReal = options.allowedRoot !== undefined ? await resolveExistingPath(options.allowedRoot) : undefined;
+    if (allowedRootReal !== undefined)
+        assertInsideAllowedRoot(projectDir, allowedRootReal);
+    const manifests = [];
+    let gradleBuildFileFound = false;
+    await walkProjectFiles(projectDir, options, SKIPPED_DIRS, (relativePath, name) => {
+        if (MANIFEST_FILENAMES.has(name)) {
+            manifests.push(relativePath);
+            return true;
+        }
+        if (GRADLE_BUILD_FILENAMES.has(name))
+            gradleBuildFileFound = true;
+        return false;
     });
     if (manifests.length === 0) {
         if (gradleBuildFileFound) {
@@ -141,9 +113,5 @@ export async function detectJavaProject(inputPath, options = {}) {
         }
         throw new ScanToolError("no_manifest_found", `対応マニフェスト(pom.xml / gradle.lockfile)が見つかりません: ${projectDir}`);
     }
-    return {
-        projectDir,
-        manifests,
-        manifestPaths: manifests.map((manifest) => path.join(projectDir, manifest)),
-    };
+    return buildResult(projectDir, manifests, allowedRootReal);
 }