osv-scanner-mcp 0.4.1 → 0.5.0

package/README.md

@@ -7,7 +7,7 @@
 
 Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップするMCPサーバーです。Claude等のMCPクライアントから「このプロジェクトの脆弱性をチェックして」と自然言語で依頼するだけで、依存ライブラリの既知の脆弱性(CVE / GHSA)を深刻度順のレポートで取得できます。
 
-> **ステータス**: [npmで公開中](https://www.npmjs.com/package/osv-scanner-mcp)(`npx -y osv-scanner-mcp`)。Java(Maven / Gradle)、JavaScript(npm / yarn / pnpm / bun)、Python(Poetry / uv / Pipenv / PDM / requirements.txt)、Go のlockfileに対応しています(修正版の推奨はJavaのみ)。MCPクライアントは Claude Code / Claude Desktop / Codex CLI / Antigravity / VS Code(GitHub Copilot)での利用手順を用意しています。
+> **ステータス**: [npmで公開中](https://www.npmjs.com/package/osv-scanner-mcp)(`npx -y osv-scanner-mcp`)。Java(Maven / Gradle)、JavaScript(npm / yarn / pnpm / bun)、Python(Poetry / uv / Pipenv / PDM / requirements.txt)、Go のlockfileに対応しています(修正版の推奨はJava・JavaScript・Go)。MCPクライアントは Claude Code / Claude Desktop / Codex CLI / Antigravity / VS Code(GitHub Copilot)での利用手順を用意しています。
 
 ## 特徴
 
@@ -16,7 +16,7 @@ Google製 [OSV-Scanner](https://github.com/google/osv-scanner) をラップす
 - **JAR/WAR実体スキャン**: `scan_java_artifact` ツールで、lockfileが無い・shaded/fat JARしか手元にないプロジェクトでもアーカイブ内メタデータから既知の脆弱性を検出します(ベストエフォート同定であることを明示するcoverage情報付き)
 - **SBOM入力スキャン**: `scan_sbom` ツールでCycloneDX/SPDXのJSON SBOMに記録された依存を検査します。SBOMの網羅性や実成果物との一致は未検証であることを明示します
 - **深刻度順のレポート**: パッケージごとに脆弱性をCVSSスコア順に整理し、5段階の深刻度ラベル(critical / high / medium / low / unknown)とサマリ集計付きで返します
-- **修正版の提示**: 各脆弱性の `fixed_versions` をMavenバージョン優先順位規則で正しくソートして含めます(`2.17.1-RELEASE` のようなsemver非対応の表記にも対応)
+- **修正版の提示**: 各脆弱性の `fixed_versions` を含めます。MavenはMavenバージョン優先順位規則(`2.17.1-RELEASE` のようなsemver非対応の表記にも対応)、npm・GoはSemantic Versioningの優先順位で正しくソートします
 - **セキュリティ第一の設計**: シェル非経由の実行・引数ホワイトリスト・パス正規化と境界チェック・タイムアウト/出力サイズ上限を実装段階から組み込んでいます
 
 ## 動作要件
@@ -142,7 +142,7 @@ osv-scanner v2.4.0 で接続先を実機確認した結果です(2026-10-07)。
 | 操作 | 接続先 | 送られる情報 |
 |---|---|---|
 | `pom.xml` のスキャン(`scan_project` / `scan_java_project` / `suggest_fix`) | `api.osv.dev`、**`api.deps.dev`** | パッケージの名前とバージョン。deps.dev には推移的依存の解決のため、`pom.xml` に宣言された依存(社内パッケージを含む)の名前とバージョンが送られます |
-| `requirements.txt` のスキャン(`scan_project`) | `api.osv.dev`、**`api.deps.dev`** | `pom.xml` と同じく、推移的依存の解決のため記載された依存の名前とバージョンが deps.dev に送られます。`--index-url` 等に書かれた取得先へは接続しません |
+| `requirements.txt` のスキャン(`scan_project` / `suggest_fix`) | `api.osv.dev`、**`api.deps.dev`** | `pom.xml` と同じく、推移的依存の解決のため記載された依存の名前とバージョンが deps.dev に送られます。`--index-url` 等に書かれた取得先へは接続しません |
 | lockfileのスキャン(`gradle.lockfile`、`package-lock.json` 等のnpm系、`poetry.lock` 等のPython系、`go.mod`) | `api.osv.dev` | パッケージの名前とバージョン(lockfileに全依存が記載済みのため、解決のための外部接続はしません) |
 | `scan_java_artifact` / `scan_sbom` | `api.osv.dev` | 同定できたパッケージの名前とバージョン |
 | `explain_vulnerability` | `api.osv.dev` | 指定した脆弱性ID |
@@ -208,11 +208,11 @@ api.osv.dev と deps.dev はどちらも Google が運営するサービスで
   - `lockfile_missing`: lockfileの無いマニフェスト(`package.json`、`pyproject.toml`、`Pipfile`、`setup.py`、`build.gradle` 等)。同じディレクトリに同じエコシステムのlockfileがあれば記録しません。上位のディレクトリのlockfileだけがある場合は、`package-lock.json`(v2以降)にそのディレクトリが収録されていることを確認できたときだけ記録しません(npm workspaces)。収録されていなければ `status: "missing"`、確認できない形式(yarn.lock、Python系等)なら `status: "unconfirmed"` として記録します。`hint` の手順でlockfileを生成してから再スキャンしてください(生成は信頼できる環境で)
   - `unpinned_requirements`: requirements.txtのうち、版を固定していない行。`kind` は `unpinned`(版の指定なし)・`range`(`>`、`<`、`!=`、`==1.*`、範囲の組み合わせ等)・`lower_bound`(`>=`、`~=`)。`unpinned` と `range` の行はOSV-Scannerがスキャンせず、`lower_bound` の行は下限の版を使用中の版とみなしてスキャンします(該当パッケージには `version_is_lower_bound: true` が付き、実際の版とは異なる可能性があります)
   - `unscannable_requirements`: スキャンされない行と理由。`-e`、`name @ URL`、パス指定、展開しなかった取り込み(プロジェクトディレクトリの外・存在しない・URL・上限超過)、制約ファイル(`-c`、適用しません)、解釈できないオプションや版の指定。解釈できない行は無視せず、ここに記録します
-  - `skipped_files`: スキャン対象から外したファイルと理由(requirements.txt自体が読めない・1MiBを超える場合、`pom.xml` の親POMが許可ルートの外を参照する場合。後者は[親POMの扱い](#親pomの扱い)を参照)
+  - `skipped_files`: スキャン対象から外したファイルと理由(requirements.txt自体が読めない・1MiBを超える場合、`pom.xml` の親POMが許可ルートの外を参照する場合)。親POMを読めず、親POMを含めずにスキャンした `pom.xml` もここに理由付きで示します([親POMの扱い](#親pomの扱い)を参照)
   - 各一覧は200件までで、超えた分の件数を `omitted_items` に返します
 - `ecosystem_breakdown` は、脆弱性0件のエコシステムも含めて「スキャンした」ことを示します
 - `dependency_groups` はOSV-Scannerが付けた依存グループ(例: `dev`)の生の値です。lockfileの形式によって欠落・不正確なため(pnpmでは付かず、pdmでは `optional` になる等)、参考情報として扱ってください
-- 修正版の推奨(`suggest_fix`)は現在Javaのみ対応です
+- 修正版の推奨(`suggest_fix`)はJava・JavaScript・Goに対応しています(Pythonは未対応)
 
 ### `scan_java_project`
 
@@ -234,6 +234,8 @@ OSV-Scannerは `pom.xml` の `<parent>` が参照する親POM(`<relativePath>`
 
 `OSV_MCP_ALLOWED_ROOT` を設定している場合、親POMの連鎖のどこかが**許可ルートの外**のファイルを参照する `pom.xml` は、スキャン対象から外します(許可ルート外のファイルの内容を結果や照会先に出さないため)。外したファイルは応答の `skipped_manifests`(`scan_project` では `coverage.skipped_files`)に理由付きで示し、`scope_warning` で「検出0件でも安全とは判断しない」旨を伝えます。全件が外れた場合や、該当する `pom.xml` を直接指定した場合は `path_outside_allowed_root` を返します。
 
+存在する親POMを読めない場合(10MiBを超える、名前付きパイプ等の通常のファイルでない、末尾がシンボリックリンク等)は、その `pom.xml` を親POMを含めずにスキャンし、親から継承する依存が欠ける可能性を応答の `incomplete_manifests`(`scan_project` では `coverage.skipped_files`、`coverage.complete` は `false`)に理由付きで示します。子の `pom.xml` に依存が無く `no_packages_found` になる場合も、エラーのメッセージに同じ理由を含めます。親POMが存在しない場合(ルートの `pom.xml` で既定の `../pom.xml` が無い等)は、元の配置でもOSV-Scannerは親を読まないため欠落として扱いません。
+
 - 許可ルート内の親POMは従来どおり読みます(サブモジュールのスキャンは許可ルート内なら引き続き使えます)
 - `<relativePath/>`(空)はローカルの親POMを参照しないため対象外です
 - 親POMの指定は、OSV-Scanner(Go)のXMLの解釈に合わせて読みます。要素は名前空間の接頭辞に関係なく要素名で照合し(`<m:parent>` も親として扱う)、ルート要素の直下の `parent` だけを対象にし、文字参照を展開します
@@ -275,7 +277,7 @@ OSV-Scannerは `pom.xml` の `<parent>` が参照する親POM(`<relativePath>`
 ```
 
 - `packages` は最も深刻な脆弱性を持つ順、各 `vulnerabilities` は深刻度順(unknownは末尾)
-- `fixed_versions` はMaven優先順位で昇順。複数のリリース系統(例: 2.12系バックポートと2.15系)が混在することがあります。空配列は「修正版が存在しない」ことを意味します
+- `fixed_versions` はOSVに記載された修正版です。MavenはMaven優先順位、npm・GoはSemantic Versioningの優先順位で昇順(SemVerとして解釈できない表記は末尾)、PyPI等はOSVの記載順のまま(並び順は保証しません)。複数のリリース系統(例: 2.12系バックポートと2.15系)が混在することがあります。プレリリース版(`5.0.0-beta.3`)やGoの疑似バージョン(`0.0.0-20180925071336-cf3bd585ca2a`)が含まれることもあります。空配列は「OSVに修正版の記載がない」ことを意味します。v0.4.1以前はMaven以外のパッケージで常に空配列を返していました
 - `severity_score` が取得できない脆弱性は `null` / `"unknown"` として扱います
 
 ### `scan_java_artifact`
@@ -331,23 +333,26 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 
 ### `suggest_fix`
 
-スキャンを実行し、脆弱なパッケージごとに**推奨アップグレードバージョン**を提案します。単純な最大バージョンではなく、現在のバージョンに最も近いリリース系統の修正版を3段階フォールバックで選定します:
+`scan_project` と同じ検出・スキャンを実行し、脆弱なパッケージごとに**推奨アップグレードバージョン**を提案します。推奨はJava(Maven / Gradle)・JavaScript(npm)・Goに対応し、Python(PyPI)は未対応です。単純な最大バージョンではなく、現在のバージョンに最も近いリリース系統の修正版を3段階フォールバックで選定します:
 
 | Tier | 意味 |
 |---|---|
-| `same_minor` | 現在と同じ major.minor 系統内の修正版(最小の変更で済む) |
+| `same_minor` | 現在と同じ系統内の修正版(最小の変更で済む) |
 | `major_internal` | 同一メジャー内の修正版(マイナーバージョンアップが必要) |
 | `cross_major` | メジャーアップグレードが必要(破壊的変更の可能性あり) |
 
-**入力**: `scan_java_project` と同じ(`project_path`)
+npm・Goの「同じ系統」は、npmの `^`(キャレット)が互換とみなす範囲です。1.0.0以上は Maven と同じく major.minor 単位ですが、0.x では同じ `0.minor` 内だけを同じ系統とし、マイナー更新(`0.3` → `0.4`)は `cross_major`、0.0.x ではどの更新も `cross_major` として扱います(SemVerでは0.xの更新は互換を保証しないため)。
+
+**入力**: `scan_project` と同じ(`project_path`)
 
 **出力(成功時)**
 
 ```json
 {
   "project_dir": "/path/to/project",
-  "manifests": ["pom.xml"],
+  "manifests": ["pom.xml", "web/package-lock.json"],
   "dependency_resolution": { "transitive_resolution": "enabled" },
+  "coverage": { "complete": true, "manifests": [ ... ], "lockfile_missing": [], "unpinned_requirements": [], "unscannable_requirements": [], "skipped_files": [] },
   "vulnerable_package_count": 4,
   "unfixed_vulnerability_count": 1,
   "suggestions": [
@@ -368,10 +373,13 @@ OSV-Scanner 2.4.0の `java/archive` プラグインを使用し、ネストJAR
 ```
 
 - `recommended_upgrade` は既知の修正版を候補に、修正対象の全CVEの影響範囲外と確認できたものを3段階Tier順・バージョン昇順で選びます。CVEごとの修正版の最大値を単純に採用せず、別系統で再び影響を受ける候補も除外します。全公開版の中での最小性や未検出の脆弱性がないことは保証しません。
-- MavenのOSV `ECOSYSTEM` 範囲(`introduced` / `fixed` / `last_affected` / 上限なし)を照合します。`versions` に明示された影響も確認します。範囲欠落・不正・未対応形式・`limit` による不完全な情報では安全と推定せず、候補を検証できなければ `recommended_upgrade: null`、`verification: "no_verified_candidate"` を返します。
+- OSVの影響範囲(`introduced` / `fixed` / `last_affected` / 上限なし)を照合します。MavenはMavenの優先順位で `ECOSYSTEM` 範囲を、npm・GoはSemantic Versioningの優先順位で `SEMVER` / `ECOSYSTEM` 範囲を使います。`versions` に明示された影響も確認します。範囲欠落・不正・未対応形式(`GIT` 等)・`limit` による不完全な情報や、SemVerとして解釈できない版(一部のGHSAに残る `19.03.9` のような表記)を含む場合は安全と推定せず、候補を検証できなければ `recommended_upgrade: null`、`verification: "no_verified_candidate"` を返します。
+- プレリリース版(`5.0.0-beta.3`、`15.6.0-canary.61`、Goの疑似バージョン)は、正式版の候補では全CVEを解消できない場合だけ推奨し、`recommended_is_prerelease: true` を付けます。同じTierのプレリリースより、上のTierの正式版を優先します。
 - 推奨時は `verification: "verified"`、CVEごとの `recommended_status` は `affected` / `not_affected` / `unknown` です。推奨保留時は `not_evaluated` になります。`per_cve_detail.fixed_in` は各CVE単独の候補であり、最終推奨先の判定は `recommended_status` を参照してください。
-- 現在より新しい修正版候補がないCVEは `tier: "unfixed"` として推奨の修正対象から除外します(情報欠落を含む場合があります)。除外したCVEも推奨先で判定し、その状態を表示します。全CVEがunfixedの場合も `recommended_upgrade` は `null` です。
-- 修正版の推奨はMavenのみ対応です。Maven以外のパッケージは `verification: "unsupported_ecosystem"`、CVEごとの `tier: "unsupported"` を返し、`unfixed` には数えません(修正版の有無は判定していないため。修正版は `explain_vulnerability` で確認できます)。
+- 現在より新しい修正版候補がないCVEは `tier: "unfixed"` として推奨の修正対象から除外します(情報欠落を含む場合があります)。除外したCVEも推奨先で判定し、その状態を表示します。全CVEがunfixedの場合も `recommended_upgrade` は `null` です。修正版の記載はあるがバージョンとして解釈できないCVE(SemVerでない `13.0` 等)は `tier: "unparseable_fix"` とし、修正版が無いとは扱わず修正対象に残すため、推奨は保留(`no_verified_candidate`)になります。
+- npm・Goの提案には更新方法の `update_hint` を付けます。推移的依存の場合、npmでは要求している直接依存の更新か、ルートの `package.json` の `overrides`(ルートのプロジェクトでのみ有効)で版を指定します。Goでは `go get <module>@<version>` で更新できます。Goのv2以上のメジャーは別のモジュールパス(`/v2` 等)としてOSV上も別パッケージになるため、新しいメジャー系列の修正版は候補に含まれません。現在の版が疑似バージョン(タグのないコミット)の場合は `upgrade_note` に示します。
+- Python(PyPI)など推奨に未対応のエコシステムは `verification: "unsupported_ecosystem"`、現在の版をバージョンとして解釈できない場合(npmのgit・ローカルパス依存等)は `verification: "unparseable_version"` を返し、どちらもCVEごとの `tier: "unsupported"` として `unfixed` には数えません(修正版の有無は判定していないため。修正版は `scan_project` の `fixed_versions` や `explain_vulnerability` で確認できます)。
+- 応答の `coverage` は `scan_project` と同じです。lockfileの無いマニフェストや外したファイルがあれば `complete: false` になり、それらの依存は提案に含まれません。v0.4.2以前の `skipped_manifests` / `scope_warning` は `coverage.skipped_files` / `coverage.warning` に統合しました。
 
 ### `explain_vulnerability`
 
@@ -456,7 +464,7 @@ npm run build             # dist/ へビルド
 - [x] Gradle対応(lockfile方式)
 - [x] `scan_java_artifact` ツール: JAR/WAR実体スキャン(lockfileが無い・shaded/fat JARのみのプロジェクト向け)
 - [x] `scan_project` ツール: Java / JavaScript / Python / Go のlockfileをまとめてスキャン
-- [ ] `suggest_fix` のJavaScript / Go対応(semver)
+- [x] `suggest_fix` のJavaScript / Go対応(semver)
 - [ ] `suggest_fix` のPython対応(PEP 440)、直接/推移的依存の区別
 
 ## ライセンス

package/dist/index.js

@@ -36,7 +36,7 @@ if (startupWarning !== null) {
 // NOTE: リリース時はpackage.jsonのversionと同じ値に更新すること
 const server = new McpServer({
     name: "osv-scanner-mcp",
-    version: "0.4.1",
+    version: "0.5.0",
 });
 server.registerTool("scan_project", {
     title: "プロジェクトの依存の脆弱性スキャン(Java / JavaScript / Python / Go)",
@@ -45,7 +45,7 @@ server.registerTool("scan_project", {
         "Python(poetry.lock / uv.lock / Pipfile.lock / pdm.lock / requirements.txt)、Go(go.mod)。" +
         "パッケージマネージャーやビルドは実行しない。" +
         "応答先頭のcoverageを必ず確認すること: lockfileが無いマニフェスト、バージョン未固定のrequirements行、スキャン対象から外したファイルを示す。" +
-        "coverage.complete=falseの場合は、検出0件でも安全とは判断しないこと。修正版の推奨(suggest_fix)は現在Javaのみ対応。",
+        "coverage.complete=falseの場合は、検出0件でも安全とは判断しないこと。修正版の推奨(suggest_fix)はJava・JavaScript・Goに対応(Pythonは未対応)。",
     inputSchema: {
         project_path: z
             .string()
@@ -68,18 +68,20 @@ server.registerTool("scan_java_project", {
 }, async ({ project_path }) => handleScanJavaProject({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("suggest_fix", {
     title: "脆弱性を解消する推奨アップグレードの提案",
-    description: "Java(Maven)プロジェクトをスキャンし、脆弱な依存パッケージごとに推奨アップグレードバージョンを提案する。" +
+    description: "scan_projectと同じ検出でプロジェクトをスキャンし、脆弱な依存パッケージごとに推奨アップグレードバージョンを提案する。" +
+        "推奨はJava(Maven / Gradle)・JavaScript(npm)・Goに対応し、Python(PyPI)はunsupported_ecosystemとして返す。" +
         "現在のバージョンに最も近いリリース系統の修正版を優先する3段階フォールバック" +
-        "(same_minor: 同一major.minor系統内 → major_internal: 同一メジャー内 → cross_major: メジャーアップグレード)で選定し、" +
-        "推奨バージョン・アップグレード距離(upgrade_tier)・CVEごとの修正版を返す。" +
-        "候補を全修正対象CVEの影響範囲と照合し、情報不足の場合は推奨を保留する。" +
-        "現在より新しい修正版候補のないCVEはunfixedとして別表示し、推奨先での判定も返す。Maven(pom.xml)とGradle(gradle.lockfile)に対応。" +
+        "(same_minor: 同一系統内 → major_internal: 同一メジャー内 → cross_major: メジャーアップグレード)で選定し、" +
+        "推奨バージョン・アップグレード距離(upgrade_tier)・CVEごとの修正版を返す。npm・Goでは0.x系のマイナー更新もcross_major(破壊的変更の可能性)。" +
+        "候補を全修正対象CVEの影響範囲と照合し、情報不足の場合は推奨を保留する。プレリリース版は正式版で解消できない場合だけ推奨し、recommended_is_prereleaseを付ける。" +
+        "現在より新しい修正版候補のないCVEはunfixedとして別表示し、推奨先での判定も返す。" +
+        "応答のcoverageを必ず確認すること(complete=falseなら提案に含まれない依存がある)。" +
         "dependency_resolution.warningがある場合は推移的依存の脆弱性が提案に含まれない。",
     inputSchema: {
         project_path: z
             .string()
             .min(1)
-            .describe("スキャン対象のプロジェクトディレクトリ、またはpom.xml/gradle.lockfileの絶対パス"),
+            .describe("スキャン対象のプロジェクトディレクトリ、または対応するlockfile・マニフェストの絶対パス"),
     },
 }, async ({ project_path }) => handleSuggestFix({ project_path }, { allowedRoot: allowedRootFromEnv() }));
 server.registerTool("explain_vulnerability", {

package/dist/osv/affectedVersions.js

@@ -1,8 +1,16 @@
-import { compareMavenVersions } from "../utils/mavenVersion.js";
 import { asArray, asRecord, asString } from "../utils/unknownJson.js";
-/** Preserve uncertainty: unsupported or malformed ranges cannot prove a candidate safe. */
+import { versionRangeTypes, versionSchemeFor } from "./versionScheme.js";
+/**
+ * Preserve uncertainty: unsupported or malformed ranges cannot prove a candidate safe.
+ * 比較・範囲の型はエコシステム別(versionScheme.ts)。比較器のないエコシステムは常に情報不足。
+ * 解釈できない版(SemVerでない値等)を含む範囲は判定に使わず、情報不足とする。
+ */
 export function extractAffectedVersions(details, ids, name, ecosystem) {
-    const evidence = { complete: ecosystem === "Maven", intervals: [], versions: [] };
+    const scheme = versionSchemeFor(ecosystem);
+    const rangeTypes = versionRangeTypes(ecosystem);
+    const evidence = { complete: scheme !== null, intervals: [], versions: [] };
+    const valid = (value) => scheme?.isValid(value) ?? false;
+    const compare = (a, b) => scheme?.compare(a, b) ?? 0;
     if (ids.length === 0 || ids.some(id => !details.some(d => d.id === id)))
         evidence.complete = false;
     for (const detail of details) {
@@ -20,7 +28,7 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
                 evidence.complete = false;
             for (const version of asArray(affected?.versions)) {
                 const value = asString(version);
-                if (!value)
+                if (!value || !valid(value))
                     evidence.complete = false;
                 else
                     evidence.versions.push(value);
@@ -31,7 +39,8 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
                 evidence.complete = false;
             for (const rawRange of ranges) {
                 const range = asRecord(rawRange);
-                if (range?.type !== "ECOSYSTEM") {
+                const type = asString(range?.type);
+                if (range === null || type === null || !rangeTypes.has(type)) {
                     evidence.complete = false;
                     continue;
                 }
@@ -39,6 +48,8 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
                 let start = null;
                 let previousEnd = null;
                 let previousInclusive = false;
+                /** この区間の境界に解釈できない版がある(区間を判定に使わない) */
+                let startInvalid = false;
                 if (events.length === 0)
                     evidence.complete = false;
                 for (const rawEvent of events) {
@@ -50,12 +61,16 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
                         evidence.complete = false;
                         continue;
                     }
+                    const invalid = !(kind === "introduced" && value === "0") && !valid(value);
+                    if (invalid)
+                        evidence.complete = false;
                     if (kind === "introduced") {
-                        if (start !== null || (previousEnd !== null && (value === "0" ||
-                            compareMavenVersions(value, previousEnd) < 0 ||
-                            (previousInclusive && compareMavenVersions(value, previousEnd) === 0))))
+                        if (start !== null || (!invalid && previousEnd !== null && (value === "0" ||
+                            compare(value, previousEnd) < 0 ||
+                            (previousInclusive && compare(value, previousEnd) === 0))))
                             evidence.complete = false;
                         start = value;
+                        startInvalid = invalid;
                     }
                     else {
                         if (start === null) {
@@ -63,19 +78,20 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
                             continue;
                         }
                         const inclusive = kind === "last_affected";
-                        if (start !== "0" && (compareMavenVersions(start, value) > 0 ||
-                            (!inclusive && compareMavenVersions(start, value) === 0)))
+                        if (!invalid && !startInvalid && start !== "0" && (compare(start, value) > 0 ||
+                            (!inclusive && compare(start, value) === 0)))
                             evidence.complete = false;
-                        evidence.intervals.push({ introduced: start, end: value, inclusive });
+                        if (!invalid && !startInvalid)
+                            evidence.intervals.push({ introduced: start, end: value, inclusive });
                         // limit bounds known affected versions, but is not evidence of a fix beyond it.
                         if (kind === "limit")
                             evidence.complete = false;
-                        previousEnd = value;
+                        previousEnd = invalid ? null : value;
                         previousInclusive = inclusive;
                         start = null;
                     }
                 }
-                if (start !== null)
+                if (start !== null && !startInvalid)
                     evidence.intervals.push({ introduced: start, end: null, inclusive: false });
             }
         }
@@ -86,12 +102,14 @@ export function extractAffectedVersions(details, ids, name, ecosystem) {
         evidence.complete = false;
     return evidence;
 }
-export function candidateStatus(evidence, version) {
-    if (!evidence)
+export function candidateStatus(evidence, version, ecosystem) {
+    const scheme = versionSchemeFor(ecosystem);
+    if (!evidence || scheme === null || !scheme.isValid(version))
         return "unknown";
-    if (evidence.versions.some(v => compareMavenVersions(v, version) === 0) || evidence.intervals.some(r => (r.introduced === "0" || compareMavenVersions(version, r.introduced) >= 0) &&
-        (r.end === null || compareMavenVersions(version, r.end) < 0 ||
-            (r.inclusive && compareMavenVersions(version, r.end) === 0))))
+    const compare = scheme.compare;
+    if (evidence.versions.some(v => compare(v, version) === 0) || evidence.intervals.some(r => (r.introduced === "0" || compare(version, r.introduced) >= 0) &&
+        (r.end === null || compare(version, r.end) < 0 ||
+            (r.inclusive && compare(version, r.end) === 0))))
         return "affected";
     return evidence.complete ? "not_affected" : "unknown";
 }

package/dist/osv/scanReport.js

@@ -12,9 +12,9 @@
  * OSV-Scannerの出力は外部由来データなので、形式が想定と異なっても例外を投げず
  * 読み取れた範囲でレポートを構築する(欠損フィールドはスキップ)。
  */
-import { compareMavenVersions } from "../utils/mavenVersion.js";
 import { asArray, asRecord, asString, asStrings } from "../utils/unknownJson.js";
 import { extractAffectedVersions } from "./affectedVersions.js";
+import { sortVersions, versionRangeTypes } from "./versionScheme.js";
 /** 外部由来のsummaryをLLMに渡す際の長さ上限(プロンプト肥大・DoS対策) */
 const MAX_SUMMARY_LENGTH = 500;
 const CVSS_CRITICAL = 9.0;
@@ -65,9 +65,12 @@ function extractSummary(vulnDetails) {
 /**
  * OSVエントリの`affected[].ranges[].events[].fixed`から修正版を収集する。
  * 1つのOSVエントリが複数パッケージをカバーしうるため、対象パッケージ名で絞り込む。
+ * 範囲の型はエコシステム別(versionScheme.ts)。GIT型のコミットハッシュは集めない。
+ * v0.4.1以前はMavenだけを集めていたため、npm・Go・PyPI等で常に空になっていた。
  */
 function extractFixedVersions(vulnDetails, packageName, ecosystem) {
     const versions = new Set();
+    const rangeTypes = versionRangeTypes(ecosystem);
     for (const detail of vulnDetails) {
         for (const affectedRaw of asArray(detail.affected)) {
             const affected = asRecord(affectedRaw);
@@ -77,7 +80,8 @@ function extractFixedVersions(vulnDetails, packageName, ecosystem) {
             if (affectedName !== packageName || asString(asRecord(affected.package)?.ecosystem) !== ecosystem)
                 continue;
             for (const rangeRaw of asArray(affected.ranges)) {
-                if (asRecord(rangeRaw)?.type !== "ECOSYSTEM" || ecosystem !== "Maven")
+                const type = asString(asRecord(rangeRaw)?.type);
+                if (type === null || !rangeTypes.has(type))
                     continue;
                 for (const eventRaw of asArray(asRecord(rangeRaw)?.events)) {
                     const fixed = asString(asRecord(eventRaw)?.fixed);
@@ -87,7 +91,7 @@ function extractFixedVersions(vulnDetails, packageName, ecosystem) {
             }
         }
     }
-    return [...versions].sort(compareMavenVersions);
+    return sortVersions(versions, ecosystem);
 }
 /**
  * OSV-Scannerの`--format json`出力を`scan_java_project`のレポートに変換する。

package/dist/osv/suggestFix.js

@@ -6,32 +6,47 @@
  * 最大バージョンではなく「現在のバージョンに最も近い系統の修正版」を優先して提案する。
  *
  * CVEごとの探索順:
- *   Tier 1 (same_minor):     現在と同じmajor.minor系統内の修正版(最小の変更で済む)
+ *   Tier 1 (same_minor):     現在と同じ系統内の修正版(最小の変更で済む)
  *   Tier 2 (major_internal): 同一メジャー内の最小の修正版(マイナーバージョンアップ)
  *   Tier 3 (cross_major):    全体最小の修正版(メジャーアップグレード、破壊的変更の可能性)
+ * 系統の判定はエコシステム別(versionScheme.ts)。npm・Goは0.xのマイナー更新もcross_major。
  *
  * パッケージ全体の候補を全修正対象CVEの影響範囲と照合して推奨する。
  * 判定不能な候補は推奨しない。
  * 現在より新しい修正版が存在しないCVEはunfixedとして明示し、推奨計算から除外する。
+ * プレリリース(canary版・Goの疑似バージョン等)は、正式版の候補で解消できない場合だけ推奨する。
  */
-import { compareMavenVersions, mavenVersionSeries } from "../utils/mavenVersion.js";
 import { candidateStatus } from "./affectedVersions.js";
-/** バージョン比較・影響範囲の検証が対応済みのエコシステム */
-const SUPPORTED_ECOSYSTEMS = new Set(["Maven"]);
+import { versionSchemeFor } from "./versionScheme.js";
+const TIER_ORDER = ["same_minor", "major_internal", "cross_major"];
+const UPDATE_HINTS = {
+    npm: "直接依存ならpackage.jsonの指定を更新します。推移的依存の場合は、それを要求している直接依存の更新か、" +
+        "ルートのpackage.jsonのoverrides(ルートのプロジェクトでのみ有効)で版を指定します",
+    Go: "go get <module>@<version>で更新します(推移的依存もgo.modのrequireに追加されて更新されます)。" +
+        "Goではv2以上のメジャーは別のモジュールパス(/v2等)として別パッケージ扱いのため、新しいメジャー系列の修正版はここに含まれません",
+};
+/** Goの疑似バージョン(タグのないコミット): 末尾がタイムスタンプ14桁-コミットハッシュ12桁 */
+const GO_PSEUDO_VERSION = /(?:^|[.-])\d{14}-[0-9a-f]{12}(?:\+|$)/;
+function hintFields(ecosystem) {
+    const hint = UPDATE_HINTS[ecosystem];
+    return hint === undefined ? {} : { update_hint: hint };
+}
 /**
- * 未対応エコシステムは推奨を出さず、CVEをunfixedにも数えない。
- * 修正版の抽出がMaven専用のため、そのまま処理すると修正版のある脆弱性を
- * 「修正版なし」と誤表示する(v0.3.3で確認した不具合)。
+ * 未対応エコシステム・解釈できない現在の版は推奨を出さず、CVEをunfixedにも数えない。
+ * 修正版の抽出がMaven専用だった頃、そのまま処理すると修正版のある脆弱性を
+ * 「修正版なし」と誤表示した(v0.3.3で確認した不具合)。
  */
-function unsupportedEcosystemSuggestion(pkg) {
+function notEvaluatedSuggestion(pkg, verification) {
     return {
         package: pkg.name,
         current_version: pkg.version,
         ecosystem: pkg.ecosystem,
         recommended_upgrade: null,
         upgrade_tier: null,
-        upgrade_note: `${pkg.ecosystem}の修正版推奨には未対応です(修正版の有無は判定していません)。` +
-            "各脆弱性の修正版はexplain_vulnerabilityで確認してください",
+        upgrade_note: (verification === "unsupported_ecosystem"
+            ? `${pkg.ecosystem}の修正版推奨には未対応です(修正版の有無は判定していません)。`
+            : `現在の版(${pkg.version})をバージョンとして解釈できないため、修正版の推奨を判定していません(git・ローカルパス等の依存の可能性があります)。`) +
+            "各脆弱性の修正版はfixed_versions(scan_project)またはexplain_vulnerabilityで確認してください",
         per_cve_detail: pkg.vulnerabilities.map((vuln) => ({
             id: vuln.id,
             cve: vuln.cve,
@@ -39,124 +54,99 @@ function unsupportedEcosystemSuggestion(pkg) {
             fixed_in: null,
             tier: "unsupported",
         })),
-        verification: "unsupported_ecosystem",
+        verification,
     };
 }
-function classifyTier(currentSeries, candidate) {
-    const candidateSeries = mavenVersionSeries(candidate);
-    if (currentSeries === null || candidateSeries === null)
-        return "cross_major";
-    if (currentSeries.major !== candidateSeries.major)
-        return "cross_major";
-    if (currentSeries.minor !== candidateSeries.minor)
-        return "major_internal";
-    return "same_minor";
-}
 /**
- * 1つのCVEに対する修正版をTierフォールバックで選ぶ。
- * 現在バージョンより新しい修正版が存在しなければnull(unfixed)。
+ * 現在より新しい候補を推奨の優先順に並べる: 正式版 → Tier順 → 版の昇順。
+ * (同じTierのプレリリースより、上のTierの正式版を優先する)
+ * 優先順位が等しい版(Goの`23.0.3`と`23.0.3+incompatible`)は、ビルドメタデータの有無が現在の版と同じものを先にする。
+ * `/vN`の無いモジュールパスでv2以上を使うには`+incompatible`付きの指定が必要なため。
  */
-function pickFixForCve(currentVersion, currentSeries, fixedVersions) {
-    // 現在以下の修正版は別ブランチ向けバックポート(現在も影響を受けたまま)なので除外
-    const candidates = fixedVersions
-        .filter((v) => compareMavenVersions(v, currentVersion) > 0)
-        .sort(compareMavenVersions);
-    if (candidates.length === 0)
-        return null;
-    if (currentSeries !== null) {
-        for (const tier of ["same_minor", "major_internal"]) {
-            const found = candidates.find((v) => classifyTier(currentSeries, v) === tier);
-            if (found !== undefined)
-                return { version: found, tier };
-        }
-    }
-    const version = candidates[0];
-    return { version, tier: classifyTier(currentSeries, version) };
+function rankCandidates(scheme, current, versions) {
+    const rank = (v) => (scheme.isPrerelease(v) ? TIER_ORDER.length : 0) + TIER_ORDER.indexOf(scheme.classify(current, v));
+    const buildMismatch = (v) => (v.includes("+") === current.includes("+") ? 0 : 1);
+    return [...new Set(versions)]
+        .filter((v) => scheme.isValid(v) && scheme.compare(v, current) > 0)
+        .sort((a, b) => rank(a) - rank(b) || scheme.compare(a, b) || buildMismatch(a) - buildMismatch(b));
 }
-function buildNote(currentSeries, recommended, tier, fixableCount, unfixedCount) {
+function buildNote(scheme, pkg, recommended, tier, fixableCount, unfixedCount) {
+    let note;
     if (recommended === null) {
-        return `全${unfixedCount}件のCVEに現在より新しい修正版候補がない(unfixed)。修正版情報の欠落を含む可能性があります`;
+        note = `全${unfixedCount}件のCVEに現在より新しい修正版候補がない(unfixed)。修正版情報の欠落を含む可能性があります`;
     }
-    const label = currentSeries !== null ? `${currentSeries.major}.${currentSeries.minor}` : null;
-    let note;
-    switch (tier) {
-        case "same_minor":
-            note = `現在の${label}系統内の候補${recommended}を推奨`;
-            break;
-        case "major_internal":
-            note = `同一メジャー(${currentSeries.major}.x)内の候補${recommended}を推奨`;
-            break;
-        default:
-            note =
-                label !== null
-                    ? `候補${recommended}へのメジャーアップグレードを推奨(破壊的変更の可能性あり)`
-                    : `現在バージョンの系統を判定できないため、検証済み候補${recommended}を提示`;
+    else {
+        const label = scheme.seriesLabel(pkg.version);
+        switch (tier) {
+            case "same_minor":
+                note = `現在の${label}系統内の候補${recommended}を推奨`;
+                break;
+            case "major_internal":
+                note = `同一メジャー(${label.split(".")[0]}.x)内の候補${recommended}を推奨`;
+                break;
+            default:
+                if (label === null)
+                    note = `現在バージョンの系統を判定できないため、検証済み候補${recommended}を提示`;
+                else if (label.startsWith("0.") && scheme.seriesLabel(recommended)?.startsWith("0.")) {
+                    note = `候補${recommended}への更新を推奨(0.x系のため、マイナー更新でも破壊的変更の可能性あり)`;
+                }
+                else
+                    note = `候補${recommended}へのメジャーアップグレードを推奨(破壊的変更の可能性あり)`;
+        }
+        note += `。取得済みの影響範囲に基づき修正対象${fixableCount}件のCVEの範囲外と確認しました。全公開版の最小性や未検出の脆弱性がないことは保証しません`;
+        if (scheme.isPrerelease(recommended)) {
+            note += "。正式版の候補では全件を解消できないため、プレリリース版を推奨しています。正式版の公開を確認してください";
+        }
+        if (unfixedCount > 0)
+            note += `。残り${unfixedCount}件は現在より新しい修正版候補がなく、修正対象から除外しています。recommended_statusを確認してください`;
+    }
+    if (pkg.ecosystem === "Go" && GO_PSEUDO_VERSION.test(pkg.version)) {
+        note += "。現在の版は疑似バージョン(タグのないコミット)です";
     }
-    note += `。取得済みの影響範囲に基づき修正対象${fixableCount}件のCVEの範囲外と確認しました。全公開版の最小性や未検出の脆弱性がないことは保証しません`;
-    if (unfixedCount > 0)
-        note += `。残り${unfixedCount}件は現在より新しい修正版候補がなく、修正対象から除外しています。recommended_statusを確認してください`;
     return note;
 }
 /** 1パッケージ分のアップグレード提案を組み立てる。 */
 export function suggestUpgradeForPackage(pkg) {
-    if (!SUPPORTED_ECOSYSTEMS.has(pkg.ecosystem))
-        return unsupportedEcosystemSuggestion(pkg);
-    const currentSeries = mavenVersionSeries(pkg.version);
-    const details = [];
-    let recommended = null;
-    let unfixedCount = 0;
-    for (const vuln of pkg.vulnerabilities) {
-        const pick = pickFixForCve(pkg.version, currentSeries, vuln.fixed_versions);
-        if (pick === null) {
-            unfixedCount++;
-            details.push({
-                id: vuln.id,
-                cve: vuln.cve,
-                severity: vuln.severity,
-                fixed_in: null,
-                tier: "unfixed",
-            });
-            continue;
-        }
-        details.push({
+    const scheme = versionSchemeFor(pkg.ecosystem);
+    if (scheme === null)
+        return notEvaluatedSuggestion(pkg, "unsupported_ecosystem");
+    if (!scheme.isValid(pkg.version))
+        return { ...notEvaluatedSuggestion(pkg, "unparseable_version"), ...hintFields(pkg.ecosystem) };
+    const details = pkg.vulnerabilities.map((vuln) => {
+        const fix = rankCandidates(scheme, pkg.version, vuln.fixed_versions)[0];
+        return {
             id: vuln.id,
             cve: vuln.cve,
             severity: vuln.severity,
-            fixed_in: pick.version,
-            tier: pick.tier,
-        });
-    }
+            fixed_in: fix ?? null,
+            tier: fix !== undefined ? scheme.classify(pkg.version, fix)
+                : vuln.fixed_versions.some((v) => !scheme.isValid(v)) ? "unparseable_fix" : "unfixed",
+        };
+    });
+    const unfixedCount = details.filter((d) => d.tier === "unfixed").length;
+    const unparseableCount = details.filter((d) => d.tier === "unparseable_fix").length;
     const fixableCount = details.length - unfixedCount;
-    const targets = pkg.vulnerabilities.filter((_, i) => details[i].fixed_in !== null);
-    const candidates = [...new Set(targets.flatMap(v => v.fixed_versions))]
-        .filter(v => compareMavenVersions(v, pkg.version) > 0)
-        .sort(compareMavenVersions);
-    const tierOrder = ["same_minor", "major_internal", "cross_major"];
-    recommended = null;
-    for (const tier of tierOrder) {
-        const candidate = candidates.find(v => classifyTier(currentSeries, v) === tier &&
-            targets.every(target => candidateStatus(target.affected_versions, v) === "not_affected"));
-        if (candidate !== undefined) {
-            recommended = candidate;
-            break;
-        }
-    }
+    // 解釈できない修正版のCVEも修正対象に残す。その影響範囲は情報不足のため、どの候補も検証できず推奨を保留する
+    const targets = pkg.vulnerabilities.filter((_, i) => details[i].tier !== "unfixed");
+    const candidates = rankCandidates(scheme, pkg.version, targets.flatMap((v) => v.fixed_versions));
+    const recommended = candidates.find((v) => targets.every((target) => candidateStatus(target.affected_versions, v, pkg.ecosystem) === "not_affected")) ?? null;
     for (let i = 0; i < details.length; i++) {
         details[i].recommended_status = recommended === null ? "not_evaluated" :
-            candidateStatus(pkg.vulnerabilities[i].affected_versions, recommended);
+            candidateStatus(pkg.vulnerabilities[i].affected_versions, recommended, pkg.ecosystem);
     }
-    // 推奨バージョン自体のTierは「現在バージョンとの系統関係」で再分類する
-    // (per-CVEのTierの寄せ集めではなく、実際に行うアップグレードの距離を表す)
-    const upgradeTier = recommended !== null ? classifyTier(currentSeries, recommended) : null;
+    const upgradeTier = recommended !== null ? scheme.classify(pkg.version, recommended) : null;
     return {
         package: pkg.name,
         current_version: pkg.version,
         ecosystem: pkg.ecosystem,
         recommended_upgrade: recommended,
         upgrade_tier: upgradeTier,
+        ...(recommended !== null && scheme.isPrerelease(recommended) ? { recommended_is_prerelease: true } : {}),
         upgrade_note: recommended === null && fixableCount > 0
-            ? "既知の修正版候補から、全修正対象CVEの影響範囲外と確認できる版が見つかりません。情報不足・未対応の範囲形式を含む場合も推奨を保留します。"
-            : buildNote(currentSeries, recommended, upgradeTier, fixableCount, unfixedCount),
+            ? "既知の修正版候補から、全修正対象CVEの影響範囲外と確認できる版が見つかりません。情報不足・未対応の範囲形式を含む場合も推奨を保留します。" +
+                (unparseableCount > 0 ? `${unparseableCount}件のCVEは修正版の記載をバージョンとして解釈できないため(tier: unparseable_fix)、推奨を保留しています。` : "")
+            : buildNote(scheme, pkg, recommended, upgradeTier, fixableCount, unfixedCount),
+        ...hintFields(pkg.ecosystem),
         per_cve_detail: details,
         verification: recommended === null ? "no_verified_candidate" : "verified",
     };

package/dist/osv/versionScheme.js

@@ -0,0 +1,96 @@
+/**
+ * エコシステムごとのバージョンの扱い(docs/DESIGN_TODO.md「suggest_fix npm/Go対応」)。
+ *
+ * - Maven: Mavenの優先順位(mavenVersion.ts)。範囲はECOSYSTEM型
+ * - npm・Go: SemVer 2.0.0の優先順位(semverVersion.ts)。範囲はSEMVER型とECOSYSTEM型
+ * - その他(PyPI等): 比較器なし。範囲はECOSYSTEM型
+ *
+ * GIT型の範囲(コミットハッシュ)はリリース版と無関係のため、どのエコシステムでも版として扱わない。
+ */
+import { compareMavenVersions, mavenVersionSeries } from "../utils/mavenVersion.js";
+import { compareParsedSemver, parseSemver } from "../utils/semverVersion.js";
+const SEMVER_ECOSYSTEMS = new Set(["npm", "Go"]);
+const MAVEN_SCHEME = {
+    isValid: () => true,
+    compare: compareMavenVersions,
+    isPrerelease: () => false,
+    classify(current, candidate) {
+        const a = mavenVersionSeries(current);
+        const b = mavenVersionSeries(candidate);
+        if (a === null || b === null || a.major !== b.major)
+            return "cross_major";
+        return a.minor === b.minor ? "same_minor" : "major_internal";
+    },
+    seriesLabel(version) {
+        const series = mavenVersionSeries(version);
+        return series === null ? null : `${series.major}.${series.minor}`;
+    },
+};
+/**
+ * npm・Go: npmの^(キャレット)が互換とみなす範囲を同じ系統とする。
+ * 1.0.0以上はmajor.minor、0.xは0.minor内だけが互換(マイナー更新は破壊的変更の可能性)、0.0.xはどの変更も非互換。
+ */
+const SEMVER_SCHEME = {
+    isValid: (version) => parseSemver(version) !== null,
+    compare(a, b) {
+        const x = parseSemver(a);
+        const y = parseSemver(b);
+        return x === null || y === null ? 0 : compareParsedSemver(x, y);
+    },
+    isPrerelease: (version) => (parseSemver(version)?.prerelease.length ?? 0) > 0,
+    classify(current, candidate) {
+        const a = parseSemver(current);
+        const b = parseSemver(candidate);
+        if (a === null || b === null || a.major !== b.major)
+            return "cross_major";
+        if (a.major === 0) {
+            if (a.minor !== b.minor)
+                return "cross_major";
+            if (a.minor === 0 && a.patch !== b.patch)
+                return "cross_major";
+            return "same_minor";
+        }
+        return a.minor === b.minor ? "same_minor" : "major_internal";
+    },
+    seriesLabel(version) {
+        const v = parseSemver(version);
+        if (v === null)
+            return null;
+        return v.major === 0 && v.minor === 0 ? `0.0.${v.patch}` : `${v.major}.${v.minor}`;
+    },
+};
+/** 修正版の推奨に対応するエコシステムの操作。未対応ならnull */
+export function versionSchemeFor(ecosystem) {
+    if (ecosystem === "Maven")
+        return MAVEN_SCHEME;
+    if (SEMVER_ECOSYSTEMS.has(ecosystem))
+        return SEMVER_SCHEME;
+    return null;
+}
+/** 修正版・影響範囲として読み取るOSVの範囲の型 */
+export function versionRangeTypes(ecosystem) {
+    if (ecosystem === "Maven")
+        return new Set(["ECOSYSTEM"]);
+    if (SEMVER_ECOSYSTEMS.has(ecosystem))
+        return new Set(["SEMVER", "ECOSYSTEM"]);
+    return new Set(["ECOSYSTEM"]);
+}
+/**
+ * 重複を除いた版の一覧を、エコシステムの優先順位で昇順に並べる。
+ * - npm・Go: SemVerとして解釈できない版は末尾に記載順のまま置く
+ * - 比較器のないエコシステム: 記載順のまま返す
+ */
+export function sortVersions(versions, ecosystem) {
+    const unique = [...new Set(versions)];
+    if (ecosystem === "Maven")
+        return unique.sort(compareMavenVersions);
+    if (!SEMVER_ECOSYSTEMS.has(ecosystem))
+        return unique;
+    const parsed = unique.flatMap((raw) => {
+        const version = parseSemver(raw);
+        return version === null ? [] : [{ raw, version }];
+    });
+    const unparsed = unique.filter((raw) => parseSemver(raw) === null);
+    parsed.sort((a, b) => compareParsedSemver(a.version, b.version) || (a.raw < b.raw ? -1 : a.raw > b.raw ? 1 : 0));
+    return [...parsed.map((p) => p.raw), ...unparsed];
+}

package/dist/tools/scanJavaArtifact.js

@@ -32,7 +32,7 @@ export async function handleScanJavaArtifact(args, options = {}) {
                 if (copy.ok)
                     originals.set(copy.path, artifact);
             }
-            const raw = originals.size > 0 ? await runOsvArtifactScan([...originals.keys()], options) : { results: [] };
+            const raw = originals.size > 0 ? await snapshot.guard(() => runOsvArtifactScan([...originals.keys()], options)) : { results: [] };
             return jsonResult(buildArtifactReport(restoreSourcePaths(raw, originals), artifactPaths));
         }
         finally {

package/dist/tools/scanJavaProject.js

@@ -21,20 +21,37 @@ export function dependencyResolution(noRemoteResolution, warning = TRANSITIVE_OM
         ? { transitive_resolution: "disabled", warning }
         : { transitive_resolution: "enabled" };
 }
-const SKIPPED_MANIFESTS_WARNING = "一部のマニフェストをスキャン対象から外しました(skipped_manifestsを参照)。" +
+const SKIPPED_MANIFESTS_WARNING = "一部のマニフェストをスキャン対象から外したか、親POMを含めずにスキャンしました(skipped_manifests / incomplete_manifestsを参照)。" +
     "それらの依存の脆弱性は結果に含まれないため、検出0件でも安全とは判断しないでください";
 /**
- * 親POMが許可ルートの外を参照するため外したマニフェスト。外したものが無ければ何も出力しない
- * (既存の出力を変えない)。件数より前に置き、検出0件を安全と誤読させない
+ * 外したマニフェスト(skipped)と、親POMを再現できずにスキャンしたマニフェスト(incomplete)。
+ * どちらも無ければ何も出力しない(既存の出力を変えない)。件数より前に置き、検出0件を安全と誤読させない
  */
-export function skippedManifestsFields(skipped) {
-    if (skipped.length === 0)
+export function skippedManifestsFields(skipped, incomplete = []) {
+    if (skipped.length === 0 && incomplete.length === 0)
         return {};
+    const list = (items) => items.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) }));
     return {
-        skipped_manifests: skipped.map((s) => ({ path: sanitizeExternalText(s.path), reason: sanitizeExternalText(s.reason) })),
+        ...(skipped.length > 0 ? { skipped_manifests: list(skipped) } : {}),
+        ...(incomplete.length > 0 ? { incomplete_manifests: list(incomplete) } : {}),
         scope_warning: SKIPPED_MANIFESTS_WARNING,
     };
 }
+/**
+ * スキャン対象を外した・親POMを含めずにスキャンしたマニフェストがある状態で「パッケージなし」になった場合、
+ * エラーにもその旨を含める(応答の一覧が出ないため、欠落を黙って「依存なし」と読ませない)。
+ */
+export async function withScopeNotes(notes, scan) {
+    try {
+        return await scan();
+    }
+    catch (error) {
+        if (!(error instanceof ScanToolError) || error.kind !== "no_packages_found" || notes.length === 0)
+            throw error;
+        throw new ScanToolError(error.kind, `${error.message}。ただし次のマニフェストはスキャン対象から外したか、親POMを含めずにスキャンしたため、` +
+            `検出0件でも安全とは判断しないでください: ${notes.map((n) => `${n.path}: ${n.reason}`).join(" / ")}`, error.detail);
+    }
+}
 /**
  * 検出したマニフェストをスナップショットへコピーし、コピーをスキャンする(元のファイルは渡さない)。
  * 応答に一時ディレクトリのパスを出さないよう、スキャナーのパスは元のファイルに戻す。
@@ -43,7 +60,7 @@ export function skippedManifestsFields(skipped) {
 export async function scanJavaManifests(project, options) {
     const snapshot = await ScanSnapshot.create();
     try {
-        const { targets, skipped } = await snapshotManifests(snapshot, project.targets, {
+        const { targets, skipped, incomplete } = await snapshotManifests(snapshot, project.targets, {
             projectDir: project.projectDir,
             allowedRootReal: project.allowedRootReal,
         });
@@ -56,10 +73,12 @@ export async function scanJavaManifests(project, options) {
             throw new ScanToolError(skipped.every((s) => s.kind === "outside_allowed_root") ? "path_outside_allowed_root" : "no_manifest_found", `スキャンできるマニフェストがありません(${details})`);
         }
         const originals = new Map(targets.map((copy, i) => [copy.path, scanned[i].path]));
-        const report = await runOsvScan(targets, options);
+        const incompleteRelative = incomplete.map((s) => ({ path: relative(s.path), reason: s.reason }));
+        const report = await withScopeNotes([...skippedRelative, ...incompleteRelative], () => snapshot.guard(() => runOsvScan(targets, options)));
         return {
             manifests: scanned.map((t) => relative(t.path)),
             skipped: skippedRelative,
+            incomplete: incompleteRelative,
             report: { ...report, source_files: report.source_files.map((file) => originals.get(file) ?? file) },
         };
     }
@@ -73,11 +92,11 @@ export async function handleScanJavaProject(args, options = {}) {
             allowedRoot: options.allowedRoot,
         });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const { manifests, skipped, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
+        const { manifests, skipped, incomplete, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
         return jsonResult({
             project_dir: project.projectDir,
             manifests,
-            ...skippedManifestsFields(skipped),
+            ...skippedManifestsFields(skipped, incomplete),
             dependency_resolution: dependencyResolution(noRemoteResolution),
             ...report,
         });

package/dist/tools/scanProject.js

@@ -12,9 +12,9 @@ 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 { dependencyResolution, withScopeNotes } from "./scanJavaProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
-const TRANSITIVE_OMITTED_WARNING = "OSV_MCP_NO_REMOTE_RESOLUTIONの設定により、マニフェスト(pom.xml / requirements.txt)からの推移的依存の解決を省略しています。" +
+export 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件でも推移的依存の安全性は確認できていません";
@@ -26,7 +26,7 @@ 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) {
+export function buildCoverage(project) {
     const rel = (file) => sanitizeExternalText(path.relative(project.projectDir, file));
     const lockfileMissing = capped(project.lockfileMissing);
     const unpinned = capped(project.requirementIssues);
@@ -84,22 +84,21 @@ function markLowerBounds(project, packages) {
         ? { ...pkg, version_is_lower_bound: true }
         : pkg);
 }
-/**
- * requirements.txtは検証済みの正規化行だけを専用の一時ディレクトリに書いてスキャンする
- * (元ファイルの取り込み指定をosv-scannerにたどらせない)。成功・失敗とも削除する。
- */
 /**
  * 元のファイルはosv-scannerに渡さず、スナップショット(scanSnapshot.ts)のコピーをスキャンする。
  * lockfile・pom.xml(親POMの連鎖を含む)は安全に読んだ内容のコピー、requirements.txtは
  * 検証済みの正規化行だけを書いたコピー。コピーできず外したファイルはskippedFilesに記録する。
+ * スナップショットは成功・失敗とも削除する。suggest_fixも同じスキャンを使う。
  */
-async function scanFromSnapshot(project, options) {
+export async function scanFromSnapshot(project, options) {
     const snapshot = await ScanSnapshot.create();
     try {
-        const { targets, skipped } = await snapshotManifests(snapshot, project.targets, {
+        const { targets, skipped, incomplete } = await snapshotManifests(snapshot, project.targets, {
             projectDir: project.projectDir,
             allowedRootReal: project.allowedRootReal,
         });
+        // 親POMを再現できずにスキャンしたpom.xmlも、欠落の可能性としてcoverageに出す(complete=falseになる)
+        project.skippedFiles.push(...incomplete.map((s) => ({ path: path.relative(project.projectDir, s.path), reason: s.reason })));
         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)));
@@ -115,7 +114,7 @@ async function scanFromSnapshot(project, options) {
         }
         if (targets.length === 0)
             return parseOsvScanOutput({ results: [] });
-        return await runOsvScan(targets, options);
+        return await withScopeNotes(project.skippedFiles, () => snapshot.guard(() => runOsvScan(targets, options)));
     }
     finally {
         await snapshot.cleanup();

package/dist/tools/suggestFix.js

@@ -1,27 +1,28 @@
 /**
  * `suggest_fix`ツールのハンドラ。
- * scan_java_projectと同じスキャンを実行し、脆弱なパッケージごとの
- * 推奨アップグレードバージョン(3段階Tier)を返す。
+ * scan_projectと同じ検出・スキャンを実行し、脆弱なパッケージごとの
+ * 推奨アップグレードバージョン(3段階Tier)を返す。推奨はMaven・npm・Goに対応し、
+ * それ以外(PyPI等)はunsupported_ecosystemとして返す。
  */
 import { isRemoteResolutionDisabled } from "../osv/runner.js";
 import { suggestUpgrades } from "../osv/suggestFix.js";
-import { detectJavaProject } from "../utils/projectDetector.js";
-import { dependencyResolution, scanJavaManifests, skippedManifestsFields, } from "./scanJavaProject.js";
+import { sanitizeExternalText } from "../utils/externalText.js";
+import { detectProject } from "../utils/manifestDetector.js";
+import { dependencyResolution, } from "./scanJavaProject.js";
+import { buildCoverage, scanFromSnapshot, TRANSITIVE_OMITTED_WARNING } from "./scanProject.js";
 import { errorResult, jsonResult } from "./toolResult.js";
 export async function handleSuggestFix(args, options = {}) {
     try {
-        const project = await detectJavaProject(args.project_path, {
-            allowedRoot: options.allowedRoot,
-        });
+        const project = await detectProject(args.project_path, { allowedRoot: options.allowedRoot });
         const noRemoteResolution = isRemoteResolutionDisabled(options);
-        const { manifests, skipped, report } = await scanJavaManifests(project, { ...options, noRemoteResolution });
+        const report = await scanFromSnapshot(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,
-            ...skippedManifestsFields(skipped),
-            dependency_resolution: dependencyResolution(noRemoteResolution),
+            manifests: project.manifests.map((m) => sanitizeExternalText(m.path)),
+            dependency_resolution: dependencyResolution(noRemoteResolution, TRANSITIVE_OMITTED_WARNING),
+            coverage: buildCoverage(project),
             vulnerable_package_count: suggestions.length,
             unfixed_vulnerability_count: unfixedVulnerabilities,
             suggestions,

package/dist/utils/safeRead.js

@@ -80,7 +80,13 @@ export async function copyRegularFile(filePath, dest, options) {
                         result = "too_large";
                         break;
                     }
-                    await target.write(chunk, 0, bytesRead);
+                    // writeは要求より少ないバイト数で戻りうるため、チャンクを書き切るまで繰り返す
+                    for (let written = 0; written < bytesRead;) {
+                        const { bytesWritten } = await target.write(chunk, written, bytesRead - written);
+                        if (bytesWritten <= 0)
+                            throw new Error("short write");
+                        written += bytesWritten;
+                    }
                 }
             }
             finally {

package/dist/utils/scanSnapshot.js

@@ -25,6 +25,8 @@ export class ScanSnapshot {
     maxTotalBytes;
     copied = new Map();
     parentCache = new Map();
+    /** 再現した配置のルートごとのディレクトリ → 元のルート("/"等) */
+    mirroredRoots = new Map();
     used = 0;
     generated = 0;
     constructor(dir, maxTotalBytes) {
@@ -42,7 +44,30 @@ export class ScanSnapshot {
     /** 元の絶対パスに対応する、スナップショット内のパス */
     mirror(absolute) {
         const { root } = path.parse(absolute);
-        return path.join(this.treeRoot, root.replace(/[^A-Za-z0-9]/g, "_"), path.relative(root, absolute));
+        const mirroredRoot = path.join(this.treeRoot, root.replace(/[^A-Za-z0-9]/g, "_"));
+        this.mirroredRoots.set(mirroredRoot, root);
+        return path.join(mirroredRoot, path.relative(root, absolute));
+    }
+    /**
+     * スキャナーのメッセージ(stderr等)に含まれるコピーのパスを元のパスに戻す。
+     * 生成したコピー(requirements.txt)など元のファイルが無いものは一時ディレクトリと分かる表記にする
+     */
+    restorePaths(text) {
+        let restored = text;
+        for (const [mirroredRoot, root] of this.mirroredRoots)
+            restored = restored.split(mirroredRoot + path.sep).join(root);
+        return restored.split(this.dir).join("<一時コピー>");
+    }
+    /** スキャナーのエラーに一時ディレクトリのパスを出さない(応答のパスは常に元のファイルを指す) */
+    async guard(scan) {
+        try {
+            return await scan();
+        }
+        catch (error) {
+            if (!(error instanceof ScanToolError))
+                throw error;
+            throw new ScanToolError(error.kind, this.restorePaths(error.message), error.detail === undefined ? undefined : this.restorePaths(error.detail));
+        }
     }
     /** 元のファイルを安全にコピーする。同じファイルは1回だけコピーする */
     async copy(absolute, boundary, maxBytes = Infinity) {
@@ -89,11 +114,15 @@ const UNPARSEABLE = "親POMの指定を確実に解釈できないため(親要
 /**
  * pom.xmlと親POMの連鎖をスナップショットへコピーする。
  * 許可ルート設定時、連鎖が許可ルートの外・スナップショットの外を参照するか、解釈できない場合は除外理由を返す。
+ * 存在する親POMを再現できなかった場合(サイズ超過・通常のファイルでない等)はスキャンを続けるが、
+ * 親から継承する依存が欠ける可能性があるためincompleteに理由を返す(黙って成功扱いにしない)。
  */
 async function snapshotPom(snapshot, pomPath, context) {
-    const first = await snapshot.copy(pomPath, context.projectDir, MAX_POM_BYTES);
-    if (!first.ok)
-        return { ok: false, reason: first.message, kind: "unreadable" };
+    const copied = await snapshot.copy(pomPath, context.projectDir, MAX_POM_BYTES);
+    if (!copied.ok)
+        return { ok: false, reason: copied.message, kind: "unreadable" };
+    const first = { ok: true, path: copied.path };
+    const partial = (reason) => ({ ...first, incomplete: reason });
     const restricted = context.allowedRootReal !== undefined;
     let current = pomPath;
     let currentCopy = first.path;
@@ -101,8 +130,11 @@ async function snapshotPom(snapshot, pomPath, context) {
         const relativePath = await snapshot.parentOf(currentCopy);
         if (relativePath === null || relativePath === "")
             return first;
-        if (relativePath === undefined)
-            return restricted ? { ok: false, reason: UNPARSEABLE, kind: "unreadable" } : first;
+        if (relativePath === undefined) {
+            return restricted
+                ? { ok: false, reason: UNPARSEABLE, kind: "unreadable" }
+                : partial("親POMの指定を確実に解釈できないため、親POMを含めずにスキャンしました。親から継承する依存が結果に含まれない可能性があります");
+        }
         // Goのfilepath.Joinと同じ規則で結合する(絶対パスも連結し、..はルートで止まる)
         const inCopy = path.join(path.dirname(currentCopy), relativePath);
         if (!isInsideDir(snapshot.treeRoot, inCopy)) {
@@ -116,8 +148,12 @@ async function snapshotPom(snapshot, pomPath, context) {
             if ((await stat(candidate)).isDirectory())
                 candidate = path.join(candidate, "pom.xml");
         }
-        catch {
-            return first; // 参照先が無い: スナップショット内にも無いため、osv-scannerは親を読まない
+        catch (error) {
+            // 参照先が無い: 元の配置でもosv-scannerは親を読まないため、欠落ではない
+            const code = error.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                return first;
+            return partial(`親POM(relativePath: ${relativePath})を確認できないため、親POMを含めずにスキャンしました。親から継承する依存が結果に含まれない可能性があります`);
         }
         const parent = await snapshot.copy(candidate, context.allowedRootReal, MAX_POM_BYTES);
         if (!parent.ok) {
@@ -131,27 +167,36 @@ async function snapshotPom(snapshot, pomPath, context) {
             }
             if (parent.failure === "changed")
                 return { ok: false, reason: `親POMの${parent.message}`, kind: "unreadable" };
-            return first; // 読めない・通常のファイルでない等: コピーしないため、osv-scannerも読まない
+            // 読めない・通常のファイルでない・サイズ超過等: コピーしないため、osv-scannerも読まない
+            return partial(`親POM(relativePath: ${relativePath})を読めないため(${parent.message})、親POMを含めずにスキャンしました。` +
+                "親から継承する依存が結果に含まれない可能性があります(親のGAVが一致しない場合はもともと読まれません)");
         }
         current = candidate;
         currentCopy = parent.path;
     }
-    return restricted ? { ok: false, reason: `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`, kind: "unreadable" } : first;
+    return restricted
+        ? { ok: false, reason: `親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えています`, kind: "unreadable" }
+        : partial(`親POMの連鎖が上限(${MAX_PARENT_DEPTH}段)を超えるため、それより上の親POMを含めずにスキャンしました`);
 }
 /**
  * 検出済みのマニフェストをスナップショットへコピーし、osv-scannerに渡す対象(コピー)を返す。
- * コピーできない・除外すべきものはskippedに理由付きで返す。
+ * コピーできない・除外すべきものはskippedに、親POMを再現できずスキャンしたものはincompleteに理由付きで返す。
  */
 export async function snapshotManifests(snapshot, targets, context) {
     const copies = [];
     const skipped = [];
+    const incomplete = [];
     for (const target of targets) {
         if (target.format === "pom.xml") {
             const result = await snapshotPom(snapshot, target.path, context);
-            if (result.ok)
+            if (result.ok) {
                 copies.push({ path: result.path, format: target.format });
-            else
+                if (result.incomplete !== undefined)
+                    incomplete.push({ path: target.path, reason: result.incomplete });
+            }
+            else {
                 skipped.push({ path: target.path, reason: result.reason, kind: result.kind });
+            }
             continue;
         }
         const result = await snapshot.copy(target.path, context.projectDir);
@@ -160,5 +205,5 @@ export async function snapshotManifests(snapshot, targets, context) {
         else
             skipped.push({ path: target.path, reason: result.message, kind: "unreadable" });
     }
-    return { targets: copies, skipped };
+    return { targets: copies, skipped, incomplete };
 }

package/dist/utils/semverVersion.js

@@ -0,0 +1,69 @@
+/**
+ * Semantic Versioning 2.0.0のバージョン解釈と優先順位比較(semver.org 11節)。
+ *
+ * OSVのnpm・Goの範囲(SEMVER型、およびECOSYSTEM型)の順序はSemVerの優先順位に従う。
+ * 実データ(docs/DESIGN_TODO.md「suggest_fix npm/Go対応」)の要点:
+ * - Goの疑似バージョン(`0.0.0-20190101120000-abcdef123456`)はプレリリースとして正しく並ぶ
+ * - Goの`+incompatible`はビルドメタデータとして比較で無視する(`20.10.14+incompatible` = `20.10.14`)
+ * - `19.03.9`(数値部の先頭ゼロ)や`13.0`のような値はSemVerではないためnullを返す
+ */
+const NUMERIC = "0|[1-9]\\d*";
+const PRE_ID = "(?:0|[1-9]\\d*|\\d*[A-Za-z-][0-9A-Za-z-]*)";
+const BUILD_ID = "[0-9A-Za-z-]+";
+const SEMVER_RE = new RegExp(`^v?(${NUMERIC})\\.(${NUMERIC})\\.(${NUMERIC})` +
+    `(?:-(${PRE_ID}(?:\\.${PRE_ID})*))?` +
+    `(?:\\+${BUILD_ID}(?:\\.${BUILD_ID})*)?$`);
+/**
+ * SemVer 2.0.0として厳密に解釈する。解釈できなければnull。
+ * 先頭の`v`は防御的に1文字だけ受け付ける(OSVとosv-scannerはGoの版を`v`なしで返す)。
+ */
+export function parseSemver(version) {
+    const m = SEMVER_RE.exec(version);
+    if (!m)
+        return null;
+    const numbers = [m[1], m[2], m[3]].map(Number);
+    if (!numbers.every(Number.isSafeInteger))
+        return null;
+    return {
+        major: numbers[0],
+        minor: numbers[1],
+        patch: numbers[2],
+        prerelease: m[4] === undefined ? [] : m[4].split(".").map((id) => (/^\d+$/.test(id) ? BigInt(id) : id)),
+    };
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/** 解釈済みの2つの版をSemVerの優先順位で比較する(ビルドメタデータは無視)。 */
+export function compareParsedSemver(a, b) {
+    const core = cmp(a.major, b.major) || cmp(a.minor, b.minor) || cmp(a.patch, b.patch);
+    if (core !== 0)
+        return core;
+    // プレリリースを持つ版は、同じ版の正式リリースより小さい
+    if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+        return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length === 0 ? 1 : -1;
+    }
+    const length = Math.min(a.prerelease.length, b.prerelease.length);
+    for (let i = 0; i < length; i++) {
+        const x = a.prerelease[i];
+        const y = b.prerelease[i];
+        if (typeof x === typeof y) {
+            const result = cmp(x, y);
+            if (result !== 0)
+                return result;
+        }
+        else {
+            // 数値の識別子は英数字の識別子より小さい
+            return typeof x === "bigint" ? -1 : 1;
+        }
+    }
+    return cmp(a.prerelease.length, b.prerelease.length);
+}
+/**
+ * 2つの版をSemVerの優先順位で比較する。どちらかを解釈できなければnull。
+ */
+export function compareSemver(a, b) {
+    const x = parseSemver(a);
+    const y = parseSemver(b);
+    return x === null || y === null ? null : compareParsedSemver(x, y);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osv-scanner-mcp",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "MCP server that wraps Google's OSV-Scanner to scan Java projects for known vulnerabilities",
   "type": "module",
   "license": "Apache-2.0",