@paretools/python 0.8.5 → 0.10.0

package/dist/lib/parsers.js

@@ -1,8 +1,13 @@
-/** Parses `pip install` output into structured data with installed packages and satisfaction status. */
+/** Parses `pip install` output into structured data with installed packages and satisfaction status.
+ *  Handles both normal installs ("Successfully installed ...") and dry-run output ("Would install ..."). */
 export function parsePipInstall(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
+    const lines = output.split("\n");
     const alreadySatisfied = output.includes("already satisfied");
+    const dryRun = output.includes("Would install") || output.includes("--dry-run");
     const installed = [];
+    const warnings = [];
+    // Normal mode: "Successfully installed pkg-1.0.0 pkg2-2.0.0"
     const installMatch = output.match(/Successfully installed (.+)/);
     if (installMatch) {
         const packages = installMatch[1].trim().split(/\s+/);
@@ -16,16 +21,73 @@ export function parsePipInstall(stdout, stderr, exitCode) {
             }
         }
     }
+    // Dry-run mode: "Would install pkg-1.0.0 pkg2-2.0.0"
+    if (installed.length === 0) {
+        const dryRunMatch = output.match(/Would install (.+)/);
+        if (dryRunMatch) {
+            const packages = dryRunMatch[1].trim().split(/\s+/);
+            for (const pkg of packages) {
+                const lastDash = pkg.lastIndexOf("-");
+                if (lastDash > 0) {
+                    installed.push({
+                        name: pkg.slice(0, lastDash),
+                        version: pkg.slice(lastDash + 1),
+                    });
+                }
+            }
+        }
+    }
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^(WARNING|DEPRECATION):/i.test(trimmed)) {
+            warnings.push(trimmed);
+        }
+    }
     return {
         success: exitCode === 0,
         installed,
         alreadySatisfied,
+        warnings: warnings.length > 0 ? warnings : undefined,
+        dryRun,
         total: installed.length,
     };
 }
 const MYPY_RE = /^(.+?):(\d+)(?::(\d+))?: (error|warning|note): (.+?)(?:\s+\[([^\]]+)\])?$/;
-/** Parses mypy type-checker output into structured diagnostics with file locations and error codes. */
-export function parseMypyOutput(stdout, exitCode) {
+/** Parses mypy JSON output (from `--output json`) into structured diagnostics. */
+export function parseMypyJsonOutput(stdout, exitCode) {
+    let entries;
+    try {
+        entries = JSON.parse(stdout);
+    }
+    catch {
+        // Fall back to text parsing if JSON parsing fails (older mypy without --output json)
+        return parseMypyTextOutput(stdout, exitCode);
+    }
+    if (!Array.isArray(entries)) {
+        return parseMypyTextOutput(stdout, exitCode);
+    }
+    const diagnostics = entries.map((e) => ({
+        file: e.file,
+        line: e.line,
+        column: e.column > 0 ? e.column : undefined,
+        severity: e.severity,
+        message: e.message,
+        code: e.code || undefined,
+    }));
+    const errors = diagnostics.filter((d) => d.severity === "error").length;
+    const warnings = diagnostics.filter((d) => d.severity === "warning").length;
+    const notes = diagnostics.filter((d) => d.severity === "note").length;
+    return {
+        success: exitCode === 0,
+        diagnostics,
+        total: diagnostics.length,
+        errors,
+        warnings,
+        notes,
+    };
+}
+/** Parses mypy text output into structured diagnostics (fallback for older mypy without JSON). */
+export function parseMypyTextOutput(stdout, exitCode) {
     const lines = stdout.split("\n");
     const diagnostics = [];
     for (const line of lines) {
@@ -42,23 +104,30 @@ export function parseMypyOutput(stdout, exitCode) {
         }
     }
     const errors = diagnostics.filter((d) => d.severity === "error").length;
-    const warnings = diagnostics.filter((d) => d.severity === "warning" || d.severity === "note").length;
+    const warnings = diagnostics.filter((d) => d.severity === "warning").length;
+    const notes = diagnostics.filter((d) => d.severity === "note").length;
     return {
         success: exitCode === 0,
         diagnostics,
         total: diagnostics.length,
         errors,
         warnings,
+        notes,
     };
 }
+/** Parses mypy output: tries JSON first, falls back to text parsing.
+ *  @deprecated Use parseMypyJsonOutput (which auto-falls back) instead. Kept for backward compat. */
+export function parseMypyOutput(stdout, exitCode) {
+    return parseMypyTextOutput(stdout, exitCode);
+}
 /** Parses `ruff check --output-format json` output into structured lint diagnostics with fixability info. */
-export function parseRuffJson(stdout) {
+export function parseRuffJson(stdout, exitCode, stderr = "") {
     let entries;
     try {
         entries = JSON.parse(stdout);
     }
     catch {
-        return { diagnostics: [], total: 0, fixable: 0 };
+        return { success: exitCode === 0, diagnostics: [], total: 0, fixable: 0 };
     }
     const diagnostics = entries.map((e) => ({
         file: e.filename,
@@ -69,34 +138,83 @@ export function parseRuffJson(stdout) {
         code: e.code,
         message: e.message,
         fixable: !!e.fix,
+        fixApplicability: extractFixApplicability(e.fix),
+        url: e.url || undefined,
     }));
     const fixable = diagnostics.filter((d) => d.fixable).length;
-    return { diagnostics, total: diagnostics.length, fixable };
+    const fixedMatch = stderr.match(/\bFixed\s+(\d+)\s+(?:errors?|violations?)\b/i) ??
+        stderr.match(/\b(\d+)\s+fixed\b/i);
+    const fixedCount = fixedMatch ? parseInt(fixedMatch[1], 10) : undefined;
+    return {
+        success: exitCode === 0,
+        diagnostics,
+        total: diagnostics.length,
+        fixable,
+        fixedCount,
+    };
+}
+/** Extracts fix applicability from a ruff fix object. */
+function extractFixApplicability(fix) {
+    if (!fix)
+        return undefined;
+    if (typeof fix === "object" && "applicability" in fix && typeof fix.applicability === "string") {
+        const val = fix.applicability.toLowerCase();
+        if (val === "safe" || val === "unsafe" || val === "display") {
+            return val;
+        }
+    }
+    return undefined;
 }
 /** Parses `pip-audit --format json` output into structured vulnerability data with fix versions. */
-export function parsePipAuditJson(stdout) {
+export function parsePipAuditJson(stdout, exitCode) {
     let data;
     try {
         data = JSON.parse(stdout);
     }
     catch {
-        return { vulnerabilities: [], total: 0 };
-    }
-    const vulnerabilities = (data.dependencies ?? []).flatMap((dep) => (dep.vulns ?? []).map((v) => ({
-        name: dep.name,
-        version: dep.version,
-        id: v.id,
-        description: v.description ?? "",
-        fixVersions: v.fix_versions ?? [],
-    })));
-    return { vulnerabilities, total: vulnerabilities.length };
+        return { success: exitCode === 0, vulnerabilities: [], total: 0 };
+    }
+    const byPackage = [];
+    const skipped = [];
+    const vulnerabilities = (data.dependencies ?? []).flatMap((dep) => {
+        if (dep.skip_reason) {
+            skipped.push({ name: dep.name, reason: dep.skip_reason });
+            return [];
+        }
+        const packageVulns = (dep.vulns ?? []).map((v) => ({
+            name: dep.name,
+            version: dep.version,
+            id: v.id,
+            description: v.description ?? "",
+            fixVersions: v.fix_versions ?? [],
+            aliases: v.aliases && v.aliases.length > 0 ? v.aliases : undefined,
+            url: v.url || undefined,
+            severity: v.severity || undefined,
+            cvssScore: v.cvss_score != null ? v.cvss_score : undefined,
+        }));
+        if (packageVulns.length > 0) {
+            byPackage.push({
+                name: dep.name,
+                version: dep.version,
+                vulnerabilities: packageVulns,
+            });
+        }
+        return packageVulns;
+    });
+    return {
+        success: exitCode === 0,
+        vulnerabilities,
+        byPackage: byPackage.length > 0 ? byPackage : undefined,
+        skipped: skipped.length > 0 ? skipped : undefined,
+        total: vulnerabilities.length,
+    };
 }
 const PYTEST_DURATION_RE = /in ([\d.]+)s/;
 function extractCount(line, label) {
     const m = line.match(label);
     return m ? parseInt(m[1], 10) : 0;
 }
-/** Parses pytest output into structured test results with pass/fail/error/skip counts and failure details. */
+/** Parses pytest output into structured test results with pass/fail/error/skip/warning counts and failure details. */
 export function parsePytestOutput(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
@@ -105,14 +223,16 @@ export function parsePytestOutput(stdout, stderr, exitCode) {
     let failed = 0;
     let errors = 0;
     let skipped = 0;
+    let warnings = 0;
     let duration = 0;
     for (const line of lines) {
         // Match lines containing pytest summary markers (== ... in Xs ==) or standalone counts
-        if (/\d+ (?:passed|failed|error|skipped)/.test(line) || /in [\d.]+s/.test(line)) {
+        if (/\d+ (?:passed|failed|error|skipped|warning)/.test(line) || /in [\d.]+s/.test(line)) {
             passed = Math.max(passed, extractCount(line, /(\d+) passed/));
             failed = Math.max(failed, extractCount(line, /(\d+) failed/));
             errors = Math.max(errors, extractCount(line, /(\d+) errors?/));
             skipped = Math.max(skipped, extractCount(line, /(\d+) skipped/));
+            warnings = Math.max(warnings, extractCount(line, /(\d+) warnings?/));
             const durationMatch = line.match(PYTEST_DURATION_RE);
             if (durationMatch) {
                 duration = parseFloat(durationMatch[1]);
@@ -128,6 +248,7 @@ export function parsePytestOutput(stdout, stderr, exitCode) {
             failed: 0,
             errors: 0,
             skipped: 0,
+            warnings,
             total: 0,
             duration,
             failures: [],
@@ -168,6 +289,7 @@ export function parsePytestOutput(stdout, stderr, exitCode) {
         failed,
         errors,
         skipped,
+        warnings,
         total,
         duration,
         failures,
@@ -176,7 +298,10 @@ export function parsePytestOutput(stdout, stderr, exitCode) {
 // Matches uv install output lines like: " + package==version" or "Installed N packages in Ns"
 const UV_INSTALLED_PKG_RE = /^\s*\+\s+(\S+)==(\S+)/;
 const UV_SUMMARY_RE = /Installed (\d+) packages? in ([\d.]+)/;
-/** Parses uv pip install output into structured data with installed packages. */
+// Matches uv resolution conflict lines like: "`package>=1.0` and `package<1.0`"
+const UV_CONFLICT_RE = /`([a-zA-Z0-9_-]+)\s*([^`]*)`/g;
+/** Parses uv pip install output into structured data with installed packages.
+ *  On failure, extracts resolution conflict information from stderr. */
 export function parseUvInstall(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
@@ -192,19 +317,90 @@ export function parseUvInstall(stdout, stderr, exitCode) {
             duration = parseFloat(summaryMatch[2]);
         }
     }
+    // On failure, extract resolution error details from stderr
+    let error;
+    let resolutionConflicts;
+    if (exitCode !== 0) {
+        const stderrTrimmed = stderr.trim();
+        if (stderrTrimmed) {
+            error = stderrTrimmed;
+        }
+        // Check for resolution/version conflict errors
+        if (stderr.includes("version solving failed") ||
+            stderr.includes("Cannot install") ||
+            stderr.includes("conflict") ||
+            stderr.includes("incompatible")) {
+            const conflicts = [];
+            const seen = new Set();
+            for (const line of stderr.split("\n")) {
+                // Reset lastIndex for global regex
+                UV_CONFLICT_RE.lastIndex = 0;
+                let match;
+                while ((match = UV_CONFLICT_RE.exec(line)) !== null) {
+                    const pkg = match[1];
+                    const constraint = match[2].trim();
+                    const key = `${pkg}:${constraint}`;
+                    if (!seen.has(key) && constraint) {
+                        seen.add(key);
+                        conflicts.push({ package: pkg, constraint });
+                    }
+                }
+            }
+            if (conflicts.length > 0) {
+                resolutionConflicts = conflicts;
+            }
+        }
+    }
+    const alreadySatisfied = exitCode === 0 &&
+        installed.length === 0 &&
+        /(already installed|already satisfied|audited \d+ packages|nothing to install)/i.test(output);
     return {
         success: exitCode === 0,
         installed,
         total: installed.length,
         duration,
+        alreadySatisfied,
+        error,
+        resolutionConflicts,
     };
 }
 /** Parses uv run output into structured result with exit code, stdout, stderr. */
-export function parseUvRun(stdout, stderr, exitCode, durationMs) {
+export function parseUvRun(stdout, stderr, exitCode, durationMs, options) {
+    const uvDiagnosticLines = [];
+    const commandErrLines = [];
+    for (const line of stderr.split("\n")) {
+        const trimmed = line.trim();
+        if (/^(Resolved|Prepared|Installed|Uninstalled|Audited)\b/.test(trimmed) ||
+            /^Using (?:Python|CPython)\b/.test(trimmed) ||
+            /^Downloading\b/.test(trimmed)) {
+            if (trimmed)
+                uvDiagnosticLines.push(trimmed);
+        }
+        else {
+            commandErrLines.push(line);
+        }
+    }
+    let outputStdout = stdout;
+    let outputStderr = commandErrLines.join("\n");
+    let truncated = false;
+    const maxOutputChars = options?.maxOutputChars ?? 0;
+    if (maxOutputChars > 0) {
+        if (outputStdout.length > maxOutputChars) {
+            outputStdout = outputStdout.slice(0, maxOutputChars) + "…";
+            truncated = true;
+        }
+        if (outputStderr.length > maxOutputChars) {
+            outputStderr = outputStderr.slice(0, maxOutputChars) + "…";
+            truncated = true;
+        }
+    }
     return {
         exitCode,
-        stdout,
-        stderr,
+        stdout: outputStdout,
+        stderr: outputStderr,
+        commandStderr: outputStderr || undefined,
+        uvDiagnostics: uvDiagnosticLines.length > 0 ? uvDiagnosticLines : undefined,
+        truncated: truncated || undefined,
         success: exitCode === 0,
         duration: Math.round(durationMs) / 1000,
     };
@@ -218,6 +414,7 @@ export function parseBlackOutput(stdout, stderr, exitCode) {
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
     const wouldReformat = [];
+    const diagnostics = [];
     let filesChanged = 0;
     let filesUnchanged = 0;
     for (const line of lines) {
@@ -229,6 +426,15 @@ export function parseBlackOutput(stdout, stderr, exitCode) {
         if (reformattedMatch) {
             wouldReformat.push(reformattedMatch[1].trim());
         }
+        const parseDiagMatch = line.match(/cannot format (.+?): Cannot parse: (\d+):(\d+): (.+)$/i);
+        if (parseDiagMatch) {
+            diagnostics.push({
+                file: parseDiagMatch[1],
+                line: parseInt(parseDiagMatch[2], 10),
+                column: parseInt(parseDiagMatch[3], 10),
+                message: parseDiagMatch[4],
+            });
+        }
     }
     // Parse summary line
     for (const line of lines) {
@@ -251,38 +457,69 @@ export function parseBlackOutput(stdout, stderr, exitCode) {
     const filesChecked = filesChanged + filesUnchanged;
     // In check mode, success means no files need reformatting
     // In format mode, success is always true (exitCode 0) unless black errors
-    // exitCode 1 in check mode = files would be reformatted
-    // exitCode 123 = internal error
+    // exitCode 1 in check mode = files would be reformatted ("check_failed")
+    // exitCode 123 = internal error (parse error or crash)
     const success = exitCode === 0;
+    let errorType;
+    if (exitCode === 1) {
+        errorType = "check_failed";
+    }
+    else if (exitCode === 123) {
+        errorType = "internal_error";
+    }
     return {
         filesChanged,
         filesUnchanged,
         filesChecked,
         success,
+        exitCode: exitCode !== 0 ? exitCode : undefined,
+        errorType,
+        diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
         wouldReformat,
     };
 }
-/** Parses `pip list --format json` output into structured package list. */
-export function parsePipListJson(stdout) {
+/** Parses `pip list --format json` output into structured package list.
+ *  When outdated=true, also parses latestVersion and latestFiletype fields.
+ *  On JSON parse failure, surfaces error with raw output for debugging. */
+export function parsePipListJson(stdout, exitCode, outdated) {
     let entries;
     try {
         entries = JSON.parse(stdout);
     }
-    catch {
-        return { packages: [], total: 0 };
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Failed to parse pip list JSON output";
+        // Truncate raw output to 500 chars to avoid bloating the response
+        const rawOutput = stdout.length > 500 ? stdout.slice(0, 500) + "..." : stdout;
+        return {
+            success: false,
+            packages: [],
+            total: 0,
+            error: errorMessage,
+            rawOutput: rawOutput || undefined,
+        };
     }
     if (!Array.isArray(entries)) {
-        return { packages: [], total: 0 };
+        return {
+            success: false,
+            packages: [],
+            total: 0,
+            error: "pip list output is not a JSON array",
+            rawOutput: stdout.length > 500 ? stdout.slice(0, 500) + "..." : stdout,
+        };
     }
     const packages = entries.map((e) => ({
         name: e.name,
         version: e.version,
+        location: e.location || undefined,
+        editableProject: e.editable_project != null ? true : undefined,
+        ...(outdated && e.latest_version ? { latestVersion: e.latest_version } : {}),
+        ...(outdated && e.latest_filetype ? { latestFiletype: e.latest_filetype } : {}),
     }));
-    return { packages, total: packages.length };
+    return { success: exitCode === 0, packages, total: packages.length };
 }
-/** Parses `pip show <package>` key-value output into structured package metadata. */
-export function parsePipShowOutput(stdout) {
-    const lines = stdout.split("\n");
+/** Parses a single block of `pip show` key-value output into a package info object. */
+function parseSinglePipShowBlock(block) {
+    const lines = block.split("\n");
     const data = {};
     for (const line of lines) {
         const colonIdx = line.indexOf(": ");
@@ -295,15 +532,62 @@ export function parsePipShowOutput(stdout) {
     const requires = data["Requires"] && data["Requires"].trim()
         ? data["Requires"].split(",").map((r) => r.trim())
         : [];
+    const requiredBy = data["Required-by"] && data["Required-by"].trim()
+        ? data["Required-by"].split(",").map((r) => r.trim())
+        : [];
+    const classifiers = data["Classifier"] && data["Classifier"].trim()
+        ? data["Classifier"].split(",").map((c) => c.trim())
+        : [];
     return {
         name: data["Name"] || "",
         version: data["Version"] || "",
         summary: data["Summary"] || "",
         homepage: data["Home-page"] || undefined,
         author: data["Author"] || undefined,
+        authorEmail: data["Author-email"] || undefined,
         license: data["License"] || undefined,
         location: data["Location"] || undefined,
         requires,
+        requiredBy: requiredBy.length > 0 ? requiredBy : undefined,
+        metadataVersion: data["Metadata-Version"] || undefined,
+        classifiers: classifiers.length > 0 ? classifiers : undefined,
+    };
+}
+/** Parses `pip show <package>` key-value output into structured package metadata.
+ *  Supports multiple packages separated by `---` delimiter. */
+export function parsePipShowOutput(stdout, exitCode) {
+    // Split on `---` separator for multi-package output
+    const blocks = stdout
+        .split(/^---$/m)
+        .map((b) => b.trim())
+        .filter(Boolean);
+    const packages = blocks.map(parseSinglePipShowBlock);
+    // Use first package for backward-compatible top-level fields
+    const first = packages.length > 0
+        ? packages[0]
+        : {
+            name: "",
+            version: "",
+            summary: "",
+            requires: [],
+        };
+    const hasName = Boolean(first.name);
+    return {
+        success: exitCode === 0 && hasName,
+        packages,
+        // Backward-compat top-level fields from first package
+        name: first.name,
+        version: first.version,
+        summary: first.summary,
+        homepage: first.homepage,
+        author: first.author,
+        authorEmail: first.authorEmail,
+        license: first.license,
+        location: first.location,
+        requires: first.requires,
+        requiredBy: first.requiredBy,
+        metadataVersion: first.metadataVersion,
+        classifiers: first.classifiers,
     };
 }
 /** Parses `pyenv` command output into structured version management data. */
@@ -347,6 +631,16 @@ export function parsePyenvOutput(stdout, stderr, exitCode, action) {
                 .trim();
             return { action, success: true, current: ver || undefined };
         }
+        case "installList": {
+            const availableVersions = [];
+            for (const line of stdout.split("\n")) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith("Available versions:") && !trimmed.startsWith("--")) {
+                    availableVersions.push(trimmed);
+                }
+            }
+            return { action, success: true, availableVersions };
+        }
         case "install": {
             // pyenv install outputs to stderr typically
             const installed = output.match(/Installed Python-(\S+)/)?.[1] || output.match(/Installing Python-(\S+)/)?.[1];
@@ -356,34 +650,73 @@ export function parsePyenvOutput(stdout, stderr, exitCode, action) {
                 installed: installed || undefined,
             };
         }
+        case "uninstall": {
+            // pyenv uninstall -f <version>
+            // On success, output may contain "pyenv: remove <version>" or similar
+            const version = output.match(/remove\s+(\S+)/)?.[1] ||
+                output.match(/uninstall(?:ed)?\s+(\S+)/i)?.[1] ||
+                // If no match, try extracting from stderr which often has the version
+                stderr.match(/(\d+\.\d+\.\d+\S*)/)?.[1] ||
+                stdout.match(/(\d+\.\d+\.\d+\S*)/)?.[1];
+            return {
+                action,
+                success: true,
+                uninstalled: version || undefined,
+            };
+        }
         case "local": {
             return { action, success: true, localVersion: stdout.trim() || undefined };
         }
         case "global": {
             return { action, success: true, globalVersion: stdout.trim() || undefined };
         }
+        case "which": {
+            const commandPath = stdout.trim();
+            return { action, success: true, commandPath: commandPath || undefined };
+        }
+        case "rehash": {
+            return { action, success: true };
+        }
     }
 }
-const RUFF_FORMAT_FILE_RE = /^(?:Would reformat|reformatted): (.+)$/;
-/** Parses `ruff format` output into structured result with file counts. */
+const RUFF_FORMAT_WOULD_RE = /^Would reformat: (.+)$/;
+const RUFF_FORMAT_DID_RE = /^reformatted: (.+)$/;
+/** Parses `ruff format` output into structured result with file counts.
+ *  Distinguishes check mode ("Would reformat") from fix mode ("reformatted"). */
 export function parseRuffFormatOutput(stdout, stderr, exitCode) {
     // ruff format writes file-level output to stderr
     const output = stdout + "\n" + stderr;
     const lines = output.split("\n");
     const files = [];
+    let checkMode = false;
     for (const line of lines) {
-        const match = line.match(RUFF_FORMAT_FILE_RE);
-        if (match) {
-            files.push(match[1].trim());
+        const wouldMatch = line.match(RUFF_FORMAT_WOULD_RE);
+        if (wouldMatch) {
+            files.push(wouldMatch[1].trim());
+            checkMode = true;
+            continue;
+        }
+        const didMatch = line.match(RUFF_FORMAT_DID_RE);
+        if (didMatch) {
+            files.push(didMatch[1].trim());
         }
     }
+    // Also detect check mode from summary line
+    if (output.includes("would be reformatted")) {
+        checkMode = true;
+    }
     // Parse summary line: "N files reformatted" or "N files would be reformatted" or "N files left unchanged"
     const reformattedMatch = output.match(/(\d+) files? (?:would be )?reformatted/);
     const filesChanged = reformattedMatch ? parseInt(reformattedMatch[1], 10) : files.length;
+    // Parse unchanged count: "N files left unchanged" or "N files would be left unchanged"
+    const unchangedMatch = output.match(/(\d+) files? (?:would be )?left unchanged/);
+    const filesUnchanged = unchangedMatch ? parseInt(unchangedMatch[1], 10) : 0;
     return {
         success: exitCode === 0,
         filesChanged: filesChanged || files.length,
+        filesUnchanged,
         files: files.length > 0 ? files : undefined,
+        checkMode,
     };
 }
 /** Parses `conda list --json` output into structured package list. */
@@ -392,11 +725,18 @@ export function parseCondaListJson(stdout, envName) {
     try {
         entries = JSON.parse(stdout);
     }
-    catch {
-        return { action: "list", packages: [], total: 0, environment: envName };
+    catch (err) {
+        const parseError = err instanceof Error ? err.message : "Failed to parse conda list JSON output";
+        return { action: "list", packages: [], total: 0, environment: envName, parseError };
     }
     if (!Array.isArray(entries)) {
-        return { action: "list", packages: [], total: 0, environment: envName };
+        return {
+            action: "list",
+            packages: [],
+            total: 0,
+            environment: envName,
+            parseError: "conda list output is not a JSON array",
+        };
     }
     const packages = entries.map((e) => ({
         name: e.name,
@@ -412,7 +752,8 @@ export function parseCondaInfoJson(stdout) {
     try {
         data = JSON.parse(stdout);
     }
-    catch {
+    catch (err) {
+        const parseError = err instanceof Error ? err.message : "Failed to parse conda info JSON output";
         return {
             action: "info",
             condaVersion: "",
@@ -422,6 +763,7 @@ export function parseCondaInfoJson(stdout) {
             channels: [],
             envsDirs: [],
             pkgsDirs: [],
+            parseError,
         };
     }
     return {
@@ -442,8 +784,9 @@ export function parseCondaEnvListJson(stdout, activePrefix) {
     try {
         data = JSON.parse(stdout);
     }
-    catch {
-        return { action: "env-list", environments: [], total: 0 };
+    catch (err) {
+        const parseError = err instanceof Error ? err.message : "Failed to parse conda env list JSON output";
+        return { action: "env-list", environments: [], total: 0, parseError };
     }
     const envs = (data.envs ?? []).map((envPath) => {
         // Extract name from the last path segment, or "base" for the root env
@@ -457,9 +800,104 @@ export function parseCondaEnvListJson(stdout, activePrefix) {
     });
     return { action: "env-list", environments: envs, total: envs.length };
 }
+/** Parses `conda create/remove/update --json` output into structured mutation summaries. */
+export function parseCondaMutationJson(stdout, stderr, action, environment, prefix) {
+    let data;
+    try {
+        data = stdout.trim() ? JSON.parse(stdout) : {};
+    }
+    catch (err) {
+        const parseError = err instanceof Error ? err.message : `Failed to parse conda ${action} JSON output`;
+        if (action === "create") {
+            return {
+                action,
+                success: false,
+                environment,
+                prefix,
+                totalAdded: 0,
+                error: stderr.trim() || undefined,
+                parseError,
+            };
+        }
+        if (action === "remove") {
+            return {
+                action,
+                success: false,
+                environment,
+                prefix,
+                totalRemoved: 0,
+                error: stderr.trim() || undefined,
+                parseError,
+            };
+        }
+        return {
+            action,
+            success: false,
+            environment,
+            prefix,
+            totalUpdated: 0,
+            error: stderr.trim() || undefined,
+            parseError,
+        };
+    }
+    const linked = (data.actions?.LINK ?? []).map((p) => ({
+        name: p.name ?? "",
+        version: p.version ?? undefined,
+        channel: p.channel ?? undefined,
+        buildString: p.build_string ?? undefined,
+    }));
+    const unlinked = (data.actions?.UNLINK ?? []).map((p) => ({
+        name: p.name ?? "",
+        version: p.version ?? undefined,
+        channel: p.channel ?? undefined,
+        buildString: p.build_string ?? undefined,
+    }));
+    const success = data.success !== false && !data.error;
+    const outPrefix = data.prefix ?? prefix;
+    const error = data.error ?? (success ? undefined : stderr.trim() || undefined);
+    if (action === "create") {
+        return {
+            action,
+            success,
+            environment,
+            prefix: outPrefix,
+            addedPackages: linked.length > 0 ? linked : undefined,
+            totalAdded: linked.length,
+            error,
+        };
+    }
+    if (action === "remove") {
+        return {
+            action,
+            success,
+            environment,
+            prefix: outPrefix,
+            removedPackages: unlinked.length > 0 ? unlinked : undefined,
+            totalRemoved: unlinked.length,
+            error,
+        };
+    }
+    const updatedPackages = linked.filter((l) => unlinked.some((u) => u.name === l.name));
+    const addedPackages = linked.filter((l) => !unlinked.some((u) => u.name === l.name));
+    const removedPackages = unlinked.filter((u) => !linked.some((l) => l.name === u.name));
+    return {
+        action,
+        success,
+        environment,
+        prefix: outPrefix,
+        updatedPackages: updatedPackages.length > 0 ? updatedPackages : undefined,
+        addedPackages: addedPackages.length > 0 ? addedPackages : undefined,
+        removedPackages: removedPackages.length > 0 ? removedPackages : undefined,
+        totalUpdated: updatedPackages.length + addedPackages.length + removedPackages.length,
+        error,
+    };
+}
 // ─── poetry parsers ──────────────────────────────────────────────────────────
-/** Regex matching `poetry show --no-ansi` lines: "package-name  version  description" */
-const POETRY_SHOW_RE = /^(\S+)\s+(\S+)/;
+/** Strict regex matching `poetry show --no-ansi` lines: "package-name  version  description"
+ *  Anchored to start, requires package name to start with a letter/digit, and version
+ *  to look like a version string (digit-prefixed). This avoids matching status lines,
+ *  blank lines, or other non-package output. */
+const POETRY_SHOW_RE = /^([a-zA-Z0-9][a-zA-Z0-9._-]*)\s+(\d[a-zA-Z0-9._-]*)(?:\s+(.+))?$/;
 /** Regex matching `poetry build` artifact lines: " - Built package-1.0.0.tar.gz" or "  Built package-1.0.0-py3-none-any.whl" */
 const POETRY_BUILT_RE = /Built\s+(\S+)/;
 /** Regex matching `poetry add/remove` installed/removed lines with version e.g. "  - Installing requests (2.31.0)" */
@@ -471,9 +909,17 @@ export function parsePoetryOutput(stdout, stderr, exitCode, action) {
     if (action === "show") {
         const packages = [];
         for (const line of lines) {
-            const match = line.match(POETRY_SHOW_RE);
+            const trimmed = line.trim();
+            // Skip empty lines and lines that don't look like package entries
+            if (!trimmed)
+                continue;
+            const match = trimmed.match(POETRY_SHOW_RE);
             if (match) {
-                packages.push({ name: match[1], version: match[2] });
+                packages.push({
+                    name: match[1],
+                    version: match[2],
+                    description: match[3]?.trim() || undefined,
+                });
             }
         }
         return {
@@ -498,7 +944,16 @@ export function parsePoetryOutput(stdout, stderr, exitCode, action) {
             total: artifacts.length,
         };
     }
-    // install, add, remove — parse installed/updated/removed packages
+    if (action === "check" || action === "lock" || action === "export") {
+        const messages = lines.map((l) => l.trim()).filter(Boolean);
+        return {
+            success: exitCode === 0,
+            action,
+            messages: messages.length > 0 ? messages : undefined,
+            total: messages.length,
+        };
+    }
+    // install, add, remove, update — parse installed/updated/removed packages
     const packages = [];
     for (const line of lines) {
         const match = line.match(POETRY_INSTALL_LINE_RE);