@paretools/go 0.8.5 → 0.9.0

package/dist/lib/parsers.js

@@ -1,11 +1,37 @@
 const GO_ERROR_RE = /^(.+?\.go):(\d+)(?::(\d+))?: (.+)$/;
+/**
+ * Regex to detect non-file build error lines. These are package-level or linker
+ * errors that don't match the standard file:line:col format.
+ * Matches: "package X is not in GOROOT", linker errors, build constraint errors, etc.
+ * Ignores: blank lines, "# package" headers (captured separately as context).
+ */
+const GO_NON_FILE_ERROR_PATTERNS = [
+    /^package .+ is not in (?:GOROOT|GOPATH|std)/,
+    /^can(?:not|'t) (?:find|load) package/,
+    /^no required module provides package/,
+    /^build constraints exclude all Go files/,
+    /^imports .+ is not in/,
+    // Linker errors
+    /^(?:\/[^\s]+\/)?ld[.:]/,
+    /^(?:#\s+command-line-arguments|link:)/,
+    /undefined reference to/,
+    /multiple definition of/,
+    // CGO errors
+    /^cgo: /,
+    // Module errors
+    /^go: /,
+];
 /** Parses `go build` stderr output into structured error data with file locations. */
 export function parseGoBuildOutput(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
     const errors = [];
+    const rawErrors = [];
     for (const line of lines) {
-        const match = line.match(GO_ERROR_RE);
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const match = trimmed.match(GO_ERROR_RE);
         if (match) {
             errors.push({
                 file: match[1],
@@ -13,12 +39,22 @@ export function parseGoBuildOutput(stdout, stderr, exitCode) {
                 column: match[3] ? parseInt(match[3], 10) : undefined,
                 message: match[4],
             });
+            continue;
+        }
+        // Only capture non-file errors when the build actually failed
+        if (exitCode !== 0) {
+            const isNonFileError = GO_NON_FILE_ERROR_PATTERNS.some((re) => re.test(trimmed));
+            if (isNonFileError) {
+                rawErrors.push(trimmed);
+            }
         }
     }
+    const total = errors.length + rawErrors.length;
     return {
         success: exitCode === 0,
         errors,
-        total: errors.length,
+        rawErrors: rawErrors.length > 0 ? rawErrors : undefined,
+        total,
     };
 }
 /**
@@ -28,7 +64,13 @@ export function parseGoBuildOutput(stdout, stderr, exitCode) {
  */
 export function parseGoTestJson(stdout, exitCode) {
     const lines = stdout.trim().split("\n").filter(Boolean);
+    // Collect output lines per test (keyed by package/test)
+    const testOutputMap = new Map();
+    // Collect output lines per package (for package-level output)
+    const pkgOutputMap = new Map();
     const testMap = new Map();
+    // Track package-level failures (where event.Test is undefined)
+    const pkgFailures = new Map();
     for (const line of lines) {
         let event;
         try {
@@ -37,18 +79,62 @@ export function parseGoTestJson(stdout, exitCode) {
         catch {
             continue;
         }
-        if (!event.Test)
-            continue;
-        const key = `${event.Package}/${event.Test}`;
-        if (event.Action === "pass" || event.Action === "fail" || event.Action === "skip") {
-            testMap.set(key, {
-                package: event.Package,
-                name: event.Test,
-                status: event.Action,
-                elapsed: event.Elapsed,
-            });
+        if (event.Test) {
+            const key = `${event.Package}/${event.Test}`;
+            // Collect output lines for tests (#51)
+            if (event.Action === "output" && event.Output) {
+                if (!testOutputMap.has(key)) {
+                    testOutputMap.set(key, []);
+                }
+                testOutputMap.get(key).push(event.Output);
+            }
+            if (event.Action === "pass" || event.Action === "fail" || event.Action === "skip") {
+                testMap.set(key, {
+                    package: event.Package,
+                    name: event.Test,
+                    status: event.Action,
+                    elapsed: event.Elapsed,
+                });
+            }
+        }
+        else {
+            // Package-level events (no Test field) (#52)
+            if (event.Action === "output" && event.Output) {
+                if (!pkgOutputMap.has(event.Package)) {
+                    pkgOutputMap.set(event.Package, []);
+                }
+                pkgOutputMap.get(event.Package).push(event.Output);
+            }
+            if (event.Action === "fail") {
+                pkgFailures.set(event.Package, {
+                    package: event.Package,
+                });
+            }
         }
     }
+    // Attach output to failed tests (#51)
+    for (const [key, entry] of testMap) {
+        if (entry.status === "fail") {
+            const outputLines = testOutputMap.get(key);
+            if (outputLines && outputLines.length > 0) {
+                entry.output = outputLines.join("").trimEnd();
+            }
+        }
+    }
+    // Attach package-level output to package failures (#52)
+    for (const [pkg, failure] of pkgFailures) {
+        const outputLines = pkgOutputMap.get(pkg);
+        if (outputLines && outputLines.length > 0) {
+            failure.output = outputLines.join("").trimEnd();
+        }
+    }
+    // Filter out package failures that have corresponding test-level results
+    // (a package "fail" event with tests means the package summary, not a build failure)
+    const pkgWithTests = new Set();
+    for (const entry of testMap.values()) {
+        pkgWithTests.add(entry.package);
+    }
+    const packageFailures = Array.from(pkgFailures.values()).filter((f) => !pkgWithTests.has(f.package));
     const tests = Array.from(testMap.values());
     const passed = tests.filter((t) => t.status === "pass").length;
     const failed = tests.filter((t) => t.status === "fail").length;
@@ -56,14 +142,119 @@ export function parseGoTestJson(stdout, exitCode) {
     return {
         success: exitCode === 0,
         tests,
+        packageFailures: packageFailures.length > 0 ? packageFailures : undefined,
         total: tests.length,
         passed,
         failed,
         skipped,
     };
 }
-/** Parses `go vet` output into structured diagnostics with file locations and messages. */
-export function parseGoVetOutput(stdout, stderr) {
+/**
+ * Parses `go vet -json` output into structured diagnostics.
+ *
+ * The `-json` flag produces output grouped by package. Each package entry is a JSON
+ * object keyed by package import path, containing analyzer results:
+ * ```json
+ * {
+ *   "<package>": {
+ *     "<analyzer>": {
+ *       "posn": "file.go:10:5",
+ *       "message": "..."
+ *     }
+ *     // or an array of diagnostics per analyzer
+ *   }
+ * }
+ * ```
+ *
+ * Falls back to text parsing if JSON parsing fails (e.g., older Go versions).
+ */
+export function parseGoVetOutput(stdout, stderr, exitCode) {
+    // Try JSON parsing first (go vet -json)
+    const jsonResult = tryParseGoVetJson(stdout, stderr);
+    if (jsonResult) {
+        return { ...jsonResult, success: exitCode === 0 };
+    }
+    // Fallback: text parsing
+    return parseGoVetText(stdout, stderr, exitCode);
+}
+/**
+ * Attempt to parse `go vet -json` structured output.
+ * Returns null if the output doesn't look like JSON.
+ *
+ * go vet -json emits one JSON object per package on stdout/stderr.
+ * The structure is: { "<package-path>": { "<analyzer>": <diagnostic-or-array> } }
+ * Each diagnostic has: { posn: "file:line:col", message: "..." }
+ */
+function tryParseGoVetJson(stdout, stderr) {
+    // go vet -json writes JSON to stdout; stderr may have non-JSON messages
+    const combined = (stdout + "\n" + stderr).trim();
+    if (!combined || !combined.includes("{"))
+        return null;
+    const diagnostics = [];
+    // go vet -json outputs concatenated JSON objects (one per package)
+    const chunks = splitJsonObjects(combined);
+    if (chunks.length === 0)
+        return null;
+    let parsedAny = false;
+    for (const chunk of chunks) {
+        let pkgObj;
+        try {
+            pkgObj = JSON.parse(chunk);
+        }
+        catch {
+            continue;
+        }
+        // Each top-level key is a package path
+        for (const [, analyzerMap] of Object.entries(pkgObj)) {
+            if (typeof analyzerMap !== "object" || analyzerMap === null)
+                continue;
+            // Each key in the analyzerMap is an analyzer name
+            for (const [analyzerName, diagData] of Object.entries(analyzerMap)) {
+                const diagItems = Array.isArray(diagData) ? diagData : [diagData];
+                for (const item of diagItems) {
+                    if (typeof item !== "object" || item === null)
+                        continue;
+                    const diag = item;
+                    if (!diag.posn || !diag.message)
+                        continue;
+                    parsedAny = true;
+                    const parsed = parseVetPosn(diag.posn);
+                    diagnostics.push({
+                        file: parsed.file,
+                        line: parsed.line,
+                        column: parsed.column,
+                        message: diag.message,
+                        analyzer: analyzerName,
+                    });
+                }
+            }
+        }
+    }
+    if (!parsedAny)
+        return null;
+    return { diagnostics, total: diagnostics.length };
+}
+/** Parse a posn string like "file.go:10:5" or "file.go:10" into components. */
+function parseVetPosn(posn) {
+    // posn format: "file.go:line:col" or "file.go:line"
+    const parts = posn.split(":");
+    if (parts.length >= 3) {
+        return {
+            file: parts.slice(0, -2).join(":"),
+            line: parseInt(parts[parts.length - 2], 10) || 0,
+            column: parseInt(parts[parts.length - 1], 10) || undefined,
+        };
+    }
+    if (parts.length === 2) {
+        return {
+            file: parts[0],
+            line: parseInt(parts[1], 10) || 0,
+        };
+    }
+    return { file: posn, line: 0 };
+}
+/** Fallback text parser for go vet output (non-JSON mode). */
+function parseGoVetText(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
     const diagnostics = [];
@@ -78,7 +269,7 @@ export function parseGoVetOutput(stdout, stderr) {
             });
         }
     }
-    return { diagnostics, total: diagnostics.length };
+    return { success: exitCode === 0, diagnostics, total: diagnostics.length };
 }
 /** Parses `go run` output into structured result with stdout, stderr, and exit code. */
 export function parseGoRunOutput(stdout, stderr, exitCode) {
@@ -89,13 +280,39 @@ export function parseGoRunOutput(stdout, stderr, exitCode) {
         success: exitCode === 0,
     };
 }
-/** Parses `go mod tidy` output into structured result with success status and summary. */
-export function parseGoModTidyOutput(stdout, stderr, exitCode) {
+/**
+ * Parses `go mod tidy` output into structured result with success status, summary,
+ * and whether changes were made.
+ *
+ * @param goModHashBefore - MD5/hash of go.mod before tidy (optional, for change detection)
+ * @param goModHashAfter - MD5/hash of go.mod after tidy (optional, for change detection)
+ * @param goSumHashBefore - MD5/hash of go.sum before tidy (optional, for change detection)
+ * @param goSumHashAfter - MD5/hash of go.sum after tidy (optional, for change detection)
+ */
+export function parseGoModTidyOutput(stdout, stderr, exitCode, goModHashBefore, goModHashAfter, goSumHashBefore, goSumHashAfter) {
     if (exitCode === 0) {
         const combined = (stdout + "\n" + stderr).trim();
+        // Determine whether changes were made
+        let madeChanges;
+        if (goModHashBefore !== undefined && goModHashAfter !== undefined) {
+            const modChanged = goModHashBefore !== goModHashAfter;
+            const sumChanged = goSumHashBefore !== undefined &&
+                goSumHashAfter !== undefined &&
+                goSumHashBefore !== goSumHashAfter;
+            madeChanges = modChanged || sumChanged;
+        }
+        else if (combined) {
+            // If we have output (e.g., "go: downloading..."), changes were likely made
+            madeChanges = true;
+        }
+        else {
+            // No output and no hashes: assume no changes
+            madeChanges = false;
+        }
         return {
             success: true,
             summary: combined || "go.mod and go.sum are already tidy.",
+            madeChanges,
         };
     }
     const combined = (stderr + "\n" + stdout).trim();
@@ -104,51 +321,147 @@ export function parseGoModTidyOutput(stdout, stderr, exitCode) {
         summary: combined || "go mod tidy failed.",
     };
 }
-/** Parses `gofmt -l` or `gofmt -w` output into structured result with file list. */
+/**
+ * Regex for gofmt stderr parse errors.
+ * Matches patterns like: "file.go:10:5: expected ..." or "file.go:10: expected ..."
+ */
+const GOFMT_ERROR_RE = /^(.+?):(\d+)(?::(\d+))?: (.+)$/;
+/** Parses `gofmt -l` or `gofmt -l -w` output into structured result with file list. */
 export function parseGoFmtOutput(stdout, stderr, exitCode, checkMode) {
-    // In check mode (-l), stdout lists files that need formatting (one per line).
-    // In fix mode (-w), stdout is typically empty (files are rewritten in place).
+    // Both check mode (-l) and fix mode (-l -w) list changed files on stdout.
+    // The -l flag causes gofmt to print filenames, -w causes it to also rewrite them.
     // stderr may contain error messages.
-    const output = checkMode ? stdout : stdout;
-    const files = output
+    const files = stdout
         .split("\n")
         .map((f) => f.trim())
         .filter(Boolean);
     const hasErrors = exitCode !== 0 || (checkMode && files.length > 0);
+    // Parse stderr for parse errors (Gap #151)
+    const parseErrors = [];
+    if (stderr) {
+        const stderrLines = stderr.split("\n");
+        for (const line of stderrLines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const match = trimmed.match(GOFMT_ERROR_RE);
+            if (match) {
+                parseErrors.push({
+                    file: match[1],
+                    line: parseInt(match[2], 10),
+                    column: match[3] ? parseInt(match[3], 10) : undefined,
+                    message: match[4],
+                });
+            }
+        }
+    }
     return {
         success: !hasErrors,
         filesChanged: files.length,
         files,
+        parseErrors: parseErrors.length > 0 ? parseErrors : undefined,
     };
 }
+/**
+ * Regex for go generate -v output: prints package name as it's processed.
+ * Format: "mypackage" (just package name on stderr when -v is used)
+ *
+ * Regex for go generate -x output: prints the command being executed.
+ * Format on stderr: "cd /path/to/pkg; <command>" or just the command
+ *
+ * Combined regex for go generate verbose output lines indicating per-directive status.
+ * Patterns:
+ *   - `<file>:<line>: running "<command>"...` (from -v, not always present)
+ *   - `<file>.go:<line>: <command>` (from stderr with -x)
+ *   - `cd /path; <command>` (from -x)
+ */
+const GO_GENERATE_DIRECTIVE_RE = /^(.+\.go):(\d+): running "(.+?)"$/;
+const GO_GENERATE_X_FILE_RE = /^(.+\.go):(\d+): (.+)$/;
 /** Parses `go generate` output into structured result with success status and output text. */
 export function parseGoGenerateOutput(stdout, stderr, exitCode) {
     const combined = (stdout + "\n" + stderr).trim();
+    // Parse per-directive output from -v/-x flags (Gap #152)
+    const directives = [];
+    const allLines = combined.split("\n");
+    for (const line of allLines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Match "file.go:10: running "command""
+        const verboseMatch = trimmed.match(GO_GENERATE_DIRECTIVE_RE);
+        if (verboseMatch) {
+            directives.push({
+                file: verboseMatch[1],
+                line: parseInt(verboseMatch[2], 10),
+                command: verboseMatch[3],
+                status: exitCode === 0 ? "completed" : "running",
+            });
+            continue;
+        }
+        // Match "file.go:10: <command>" from -x output
+        const xMatch = trimmed.match(GO_GENERATE_X_FILE_RE);
+        if (xMatch) {
+            // Avoid matching error messages that look like file:line: patterns
+            const command = xMatch[3];
+            // Skip lines that look like error messages (contain "exec:", "not found", etc.)
+            if (!command.startsWith("running ") &&
+                !command.includes("executable file not found") &&
+                !command.startsWith("bad flag syntax")) {
+                directives.push({
+                    file: xMatch[1],
+                    line: parseInt(xMatch[2], 10),
+                    command: command,
+                    status: exitCode === 0 ? "completed" : undefined,
+                });
+            }
+        }
+    }
     return {
         success: exitCode === 0,
         output: combined,
+        directives: directives.length > 0 ? directives : undefined,
     };
 }
-/** Parses `go env -json` output into structured result with environment variables and key fields. */
-export function parseGoEnvOutput(stdout) {
-    const vars = JSON.parse(stdout || "{}");
+/**
+ * Parses `go env -json` output into structured result with environment variables and key fields.
+ * When specific vars are queried, the result only contains those vars from the JSON output.
+ * The queriedVars parameter is used to ensure compact mode includes the queried variables.
+ */
+export function parseGoEnvOutput(stdout, _queriedVars) {
+    let vars;
+    try {
+        vars = JSON.parse(stdout || "{}");
+    }
+    catch {
+        return {
+            success: false,
+            vars: undefined,
+            goroot: "",
+            gopath: "",
+            goversion: "",
+            goos: "",
+            goarch: "",
+        };
+    }
     return {
+        success: true,
         vars,
         goroot: vars.GOROOT ?? "",
         gopath: vars.GOPATH ?? "",
         goversion: vars.GOVERSION ?? "",
         goos: vars.GOOS ?? "",
         goarch: vars.GOARCH ?? "",
+        // Store queriedVars for compact mode usage (handled in formatter)
     };
 }
 /**
  * Parses `go list -json` output into structured result with package list and total count.
  * go list -json emits concatenated JSON objects (JSONL), one per package.
  */
-export function parseGoListOutput(stdout) {
+export function parseGoListOutput(stdout, exitCode) {
     const packages = [];
     if (!stdout.trim()) {
-        return { packages, total: 0 };
+        return { success: exitCode === 0, packages, total: 0 };
     }
     // go list -json outputs concatenated JSON objects separated by newlines.
     // Split by detecting `}\n{` boundary and parse each object individually.
@@ -156,18 +469,54 @@ export function parseGoListOutput(stdout) {
     for (const chunk of chunks) {
         try {
             const pkg = JSON.parse(chunk);
-            packages.push({
+            const entry = {
                 dir: pkg.Dir ?? "",
                 importPath: pkg.ImportPath ?? "",
                 name: pkg.Name ?? "",
                 goFiles: pkg.GoFiles,
+                testGoFiles: pkg.TestGoFiles,
+                imports: pkg.Imports,
+            };
+            // Capture Error field (Gap #155)
+            if (pkg.Error && typeof pkg.Error === "object" && pkg.Error.Err) {
+                entry.error = { err: String(pkg.Error.Err) };
+            }
+            packages.push(entry);
+        }
+        catch {
+            // skip malformed JSON chunks
+        }
+    }
+    return { success: exitCode === 0, packages, total: packages.length };
+}
+/**
+ * Parses `go list -json -m` output into structured result with module list and total count.
+ * go list -json -m emits concatenated JSON objects, one per module.
+ */
+export function parseGoListModulesOutput(stdout, exitCode) {
+    const modules = [];
+    if (!stdout.trim()) {
+        return { success: exitCode === 0, modules, total: 0 };
+    }
+    const chunks = splitJsonObjects(stdout);
+    for (const chunk of chunks) {
+        try {
+            const mod = JSON.parse(chunk);
+            modules.push({
+                path: mod.Path ?? "",
+                version: mod.Version || undefined,
+                dir: mod.Dir || undefined,
+                goMod: mod.GoMod || undefined,
+                goVersion: mod.GoVersion || undefined,
+                main: mod.Main || undefined,
+                indirect: mod.Indirect || undefined,
             });
         }
         catch {
             // skip malformed JSON chunks
         }
     }
-    return { packages, total: packages.length };
+    return { success: exitCode === 0, modules, total: modules.length };
 }
 /** Splits concatenated JSON objects from go list -json output. */
 function splitJsonObjects(text) {
@@ -211,7 +560,7 @@ export function parseGolangciLintJson(stdout, _exitCode) {
     const issues = parsed.Issues ?? [];
     for (const issue of issues) {
         const severity = mapSeverity(issue.Severity);
-        diagnostics.push({
+        const diag = {
             file: issue.Pos?.Filename ?? "",
             line: issue.Pos?.Line ?? 0,
             column: issue.Pos?.Column || undefined,
@@ -219,7 +568,35 @@ export function parseGolangciLintJson(stdout, _exitCode) {
             severity,
             message: issue.Text ?? "",
             sourceLine: issue.SourceLines?.[0] || undefined,
-        });
+        };
+        // Capture Replacement/fix data (Gap #154)
+        if (issue.Replacement) {
+            const replacement = issue.Replacement;
+            if (replacement.NeedOnlyDelete || replacement.NewLines !== undefined) {
+                const fix = {
+                    text: replacement.NeedOnlyDelete ? "" : (replacement.NewLines ?? []).join("\n"),
+                };
+                // Include range if inline fix info is present
+                if (replacement.Inline) {
+                    fix.range = {
+                        start: {
+                            line: replacement.Inline.StartLine ?? issue.Pos?.Line ?? 0,
+                            column: replacement.Inline.StartCol,
+                        },
+                        end: {
+                            line: replacement.Inline.EndLine ?? issue.Pos?.Line ?? 0,
+                            column: replacement.Inline.EndCol,
+                        },
+                    };
+                }
+                diag.fix = fix;
+            }
+            else if (typeof replacement.NewLines === "undefined" && !replacement.NeedOnlyDelete) {
+                // Some replacements only have NewLines without inline info
+                // If Replacement exists but has no expected structure, still try to capture it
+            }
+        }
+        diagnostics.push(diag);
     }
     const errors = diagnostics.filter((d) => d.severity === "error").length;
     const warnings = diagnostics.filter((d) => d.severity === "warning").length;
@@ -249,12 +626,92 @@ function mapSeverity(severity) {
         return "info";
     return "warning";
 }
-/** Parses `go get` output into structured result with success status and output text. */
-export function parseGoGetOutput(stdout, stderr, exitCode) {
+/**
+ * Regex patterns for go get output lines that indicate version resolution.
+ * Matches lines like:
+ *   go: upgraded golang.org/x/text v0.3.7 => v0.14.0
+ *   go: added github.com/pkg/errors v0.9.1
+ *   go: downgraded golang.org/x/net v0.10.0 => v0.8.0
+ */
+const GO_GET_UPGRADED_RE = /^go: (?:upgraded|downgraded)\s+(\S+)\s+(\S+)\s+=>\s+(\S+)$/;
+const GO_GET_ADDED_RE = /^go: added\s+(\S+)\s+(\S+)$/;
+/**
+ * Regex for go get error lines per package.
+ * Examples:
+ *   go: module github.com/nonexistent/pkg: no matching versions for query "latest"
+ *   go: github.com/some/pkg@v1.0.0: verifying module: ...
+ */
+const GO_GET_ERROR_RE = /^go: (?:module\s+)?(\S+?)(?:@(\S+))?:\s+(.+)$/;
+/** Parses `go get` output into structured result with success status, output text, resolved packages, and per-package status. */
+export function parseGoGetOutput(stdout, stderr, exitCode, requestedPackages) {
     const combined = (stdout + "\n" + stderr).trim();
+    const resolvedPackages = [];
+    // Per-package status tracking (Gap #153)
+    const packageStatuses = new Map();
+    const lines = combined.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Match "go: upgraded <pkg> <old> => <new>" or "go: downgraded <pkg> <old> => <new>"
+        const upgradeMatch = trimmed.match(GO_GET_UPGRADED_RE);
+        if (upgradeMatch) {
+            resolvedPackages.push({
+                package: upgradeMatch[1],
+                previousVersion: upgradeMatch[2],
+                newVersion: upgradeMatch[3],
+            });
+            packageStatuses.set(upgradeMatch[1], {
+                path: upgradeMatch[1],
+                version: upgradeMatch[3],
+            });
+            continue;
+        }
+        // Match "go: added <pkg> <version>"
+        const addedMatch = trimmed.match(GO_GET_ADDED_RE);
+        if (addedMatch) {
+            resolvedPackages.push({
+                package: addedMatch[1],
+                newVersion: addedMatch[2],
+            });
+            packageStatuses.set(addedMatch[1], {
+                path: addedMatch[1],
+                version: addedMatch[2],
+            });
+            continue;
+        }
+        // Match per-package error lines (Gap #153)
+        const errorMatch = trimmed.match(GO_GET_ERROR_RE);
+        if (errorMatch) {
+            const pkgPath = errorMatch[1];
+            const errMsg = errorMatch[3];
+            // Skip "downloading" lines which are progress, not errors
+            if (!errMsg.startsWith("downloading ")) {
+                packageStatuses.set(pkgPath, {
+                    path: pkgPath,
+                    version: errorMatch[2] || undefined,
+                    error: errMsg,
+                });
+            }
+        }
+    }
+    // If we have requestedPackages but some aren't in statuses, add them as successful (no error, no explicit status)
+    if (requestedPackages) {
+        for (const reqPkg of requestedPackages) {
+            // Strip version suffix from request (e.g., "github.com/pkg/errors@latest" -> "github.com/pkg/errors")
+            const pkgPath = reqPkg.replace(/@.*$/, "");
+            if (!packageStatuses.has(pkgPath)) {
+                // If the overall command succeeded, mark as successful
+                if (exitCode === 0) {
+                    packageStatuses.set(pkgPath, { path: pkgPath });
+                }
+            }
+        }
+    }
+    const packages = packageStatuses.size > 0 ? Array.from(packageStatuses.values()) : undefined;
     return {
         success: exitCode === 0,
         output: combined || undefined,
+        resolvedPackages: resolvedPackages.length > 0 ? resolvedPackages : undefined,
+        packages,
     };
 }
 //# sourceMappingURL=parsers.js.map