@robhowley/pi-structured-return 1.0.2 → 1.1.0

package/README.md

@@ -15,10 +15,11 @@ Linters: 1 unused variable warning in a single file.
 
 | Parser | Raw (tokens) | Structured (tokens) | Reduction | Notes |
 |---|---|---|---|---|
-| `pytest-json-report` | 446 | 59 | **87%** | verbose output with source snippets and summary footer |
+| `junit-xml` (go) | 446 | 58 | **87%** | verbose output with full stack trace per failure |
+| `junit-xml` (pytest) | 446 | 71 | **84%** | verbose output with source snippets and summary footer |
 | `vitest-json` | 348 | 75 | **78%** | source diff with inline arrows and ANSI color codes per failure |
 | `rspec-json` | 212 | 55 | **74%** | default output with backtrace |
-| `junit-xml` | 263 | 81 | **69%** | gradle console output with build lifecycle noise |
+| `junit-xml` (gradle) | 263 | 81 | **69%** | gradle console output with build lifecycle noise |
 | `minitest-text` | 168 | 59 | **65%** | default output with backtrace |
 | `ruff-json` | 107 | 52 | **51%** | source context + help text per error |
 | `eslint-json` | 64 | 59 | **8%** | already compact formatter |
@@ -26,13 +27,13 @@ Linters: 1 unused variable warning in a single file.
 Tokens counted with `cl100k_base` (tiktoken). Linter output is more compact than test runner output to begin with, so the baseline reduction is lower. The numbers above are measured against a single file with a single error — a conservative lower bound. Both ruff and eslint repeat absolute file paths per error in their raw output, so reduction grows as violations spread across more files.
 
 ## Built-in parsers
-- `pytest-json-report`
-- `ruff-json` (`ruff check` only — `ruff format` has no json support)
-- `eslint-json`
+- `junit-xml` (JUnit XML — covers pytest `--junitxml`, Gradle, Maven, Jest with `jest-junit`, Go with `go-junit-report`, and any other tool that emits the JUnit XML schema)
 - `vitest-json`
 - `rspec-json`
 - `minitest-text` (parses default minitest output — no flags or reporters needed)
-- `junit-xml` (JUnit XML — covers pytest `--junitxml`, Gradle, Maven, Jest with `jest-junit`, Go with `go-junit-report`, and any other tool that emits the JUnit XML schema)
+- `ruff-json` (`ruff check` only — `ruff format` has no json support)
+- `eslint-json`
+
 
 ## Before / after
 
@@ -76,6 +77,12 @@ pytest test_math.py --json-report ... → cwd: project
   test_math.py  ZeroDivisionError: division by zero
 ```
 
+## Installation
+
+```bash
+pi install npm:@robhowley/pi-structured-return
+```
+
 ## How it works
 
 1. The agent runs commands through `structured_return` instead of `bash`.

package/extensions/structured-return/src/config/registry.ts

@@ -1,6 +1,5 @@
 import path from "node:path";
 import type { ParserModule, ParserRegistration } from "../types";
-import pytestJsonReport from "../parsers/pytest-json-report";
 import ruffJson from "../parsers/ruff-json";
 import eslintJson from "../parsers/eslint-json";
 import vitestJson from "../parsers/vitest-json";
@@ -10,7 +9,6 @@ import junitXml from "../parsers/junit-xml";
 import tailFallback from "../parsers/tail-fallback";
 
 const builtIns: Record<string, ParserModule> = {
-  "pytest-json-report": pytestJsonReport,
   "ruff-json": ruffJson,
   "eslint-json": eslintJson,
   "vitest-json": vitestJson,
@@ -33,10 +31,6 @@ const AUTO_DETECT: Array<{ parserId: string; detect: (argv: string[]) => boolean
       argv.some((a) => a === "--output-format=json" || a === "json") &&
       (argv.includes("--output-format=json") || argv.includes("--output-format")),
   },
-  {
-    parserId: "pytest-json-report",
-    detect: (argv) => argv.includes("pytest") && argv.includes("--json-report"),
-  },
   {
     parserId: "vitest-json",
     detect: (argv) => argv.includes("vitest") && argv.includes("--reporter=json"),
@@ -54,6 +48,12 @@ const AUTO_DETECT: Array<{ parserId: string; detect: (argv: string[]) => boolean
   },
 ];
 
+export function listParsers(): { id: string; autoDetect: boolean }[] {
+  const builtInIds = Object.keys(builtIns).filter((id) => id !== "tail-fallback");
+  const autoDetectIds = new Set(AUTO_DETECT.map((d) => d.parserId));
+  return builtInIds.map((id) => ({ id, autoDetect: autoDetectIds.has(id) }));
+}
+
 export async function resolveParser(opts: {
   cwd: string;
   parseAs?: string;

package/extensions/structured-return/src/index.ts

@@ -7,9 +7,7 @@ import { Text } from "@mariozechner/pi-tui";
 import type { ObservedRunArgs, ParsedResult, RunContext } from "./types";
 import { ensureRunDir, writeRunArtifacts } from "./storage/log-store";
 import { loadProjectConfig } from "./config/project-config";
-import { resolveParser } from "./config/registry";
-
-const BUILT_IN_PARSER_IDS = ["pytest-json-report", "ruff-json", "eslint-json", "vitest-json", "tail-fallback"];
+import { resolveParser, listParsers } from "./config/registry";
 
 export default function structuredReturn(pi: ExtensionAPI) {
   pi.registerCommand("sr-parsers", {
@@ -18,8 +16,8 @@ export default function structuredReturn(pi: ExtensionAPI) {
       const lines: string[] = ["structured-return parsers", ""];
 
       lines.push("built-in:");
-      for (const id of BUILT_IN_PARSER_IDS) {
-        lines.push(`  ${id}`);
+      for (const { id, autoDetect } of listParsers()) {
+        lines.push(`  ${id}${autoDetect ? "  (auto-detect)" : ""}`);
       }
 
       const projectRegistrations = loadProjectConfig(ctx.cwd);

package/extensions/structured-return/src/parsers/junit-xml.test.ts

@@ -148,6 +148,64 @@ describe("junit-xml parser", () => {
     });
   });
 
+  describe("go-junit-report output", () => {
+    it("extracts panic message and file:line from system-out when failure body is empty", async () => {
+      const xml = `<testsuites tests="2" failures="1">
+        <testsuite name="math-benchmark" tests="2" failures="1" errors="0">
+          <testcase name="TestAddsTwoNumbersCorrectly" classname="math-benchmark" time="0.000"/>
+          <testcase name="TestDoesNotPanic" classname="math-benchmark" time="0.000">
+            <failure message="Failed"></failure>
+          </testcase>
+          <system-out><![CDATA[panic: runtime error: invalid memory address or nil pointer dereference [recovered, repanicked]
+goroutine 23 [running]:
+math-benchmark.TestDoesNotPanic(0x123)
+	/project/math_test.go:22 +0x4
+]]></system-out>
+        </testsuite>
+      </testsuites>`;
+      const result = await parser.parse(makeCtx(xml, "/project"));
+      expect(result.failures![0].message).toBe("runtime error: invalid memory address or nil pointer dereference");
+      expect(result.failures![0].file).toBe("math_test.go");
+      expect(result.failures![0].line).toBe(22);
+    });
+
+    it("extracts file, line, and message from Go failure body", async () => {
+      const xml = `<testsuites tests="2" failures="1">
+        <testsuite name="math-benchmark" tests="2" failures="1" errors="0">
+          <testcase name="TestAddsTwoNumbersCorrectly" classname="math-benchmark" time="0.000"/>
+          <testcase name="TestMultipliesTwoNumbersCorrectly" classname="math-benchmark" time="0.000">
+            <failure message="Failed"><![CDATA[    math_test.go:16: expected 99, got 12]]></failure>
+          </testcase>
+        </testsuite>
+      </testsuites>`;
+      const result = await parser.parse(makeCtx(xml, "/project"));
+      expect(result.failures![0].file).toBe("math_test.go");
+      expect(result.failures![0].line).toBe(16);
+      expect(result.failures![0].message).toBe("expected 99, got 12");
+    });
+  });
+
+  describe("pytest --junitxml output", () => {
+    it("extracts file and line from failure body when no file attr present", async () => {
+      const xml = `<?xml version="1.0" encoding="utf-8"?>
+        <testsuites name="pytest tests">
+          <testsuite name="pytest" errors="0" failures="1" skipped="0" tests="2">
+            <testcase classname="tests.test_math" name="test_adds" time="0.000"/>
+            <testcase classname="tests.test_math" name="test_multiplies" time="0.000">
+              <failure message="assert (3 * 4) == 99">def test_multiplies():
+&gt;       assert 3 * 4 == 99
+E       assert (3 * 4) == 99
+
+tests/test_math.py:5: AssertionError</failure>
+            </testcase>
+          </testsuite>
+        </testsuites>`;
+      const result = await parser.parse(makeCtx(xml, "/project"));
+      expect(result.failures![0].file).toBe("tests/test_math.py");
+      expect(result.failures![0].line).toBe(5);
+    });
+  });
+
   describe("multi-suite totals", () => {
     it("failures and errors summed across suites", async () => {
       const xml = `<testsuites>

package/extensions/structured-return/src/parsers/junit-xml.ts

@@ -25,6 +25,7 @@ interface JUnitTestSuite {
   failures?: string | number;
   errors?: string | number;
   testcase?: JUnitTestCase[];
+  "system-out"?: string;
 }
 
 interface JUnitDocument {
@@ -38,6 +39,45 @@ const xmlParser = new XMLParser({
   isArray: (name) => ["testsuite", "testcase"].includes(name),
 });
 
+/** Extract file, line, and message from failure body text.
+ *  Handles pytest-style (last line: "file.py:line: ExceptionType")
+ *  and Go-style (any line: "    file.go:line: message"). */
+function parseBodyLocation(text: string): { file: string; line: number; message?: string } | undefined {
+  const lines = text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean);
+  for (const line of lines) {
+    const m = line.match(/^([^:\s]+\.\w+):(\d+):\s*(.*)/);
+    if (m) return { file: m[1], line: Number(m[2]), message: m[3] || undefined };
+  }
+  return undefined;
+}
+
+/** Extract panic message and file:line for a specific test from Go's system-out. */
+function parsePanicInfo(
+  systemOut: string,
+  testName: string
+): { message?: string; file?: string; line?: number } | undefined {
+  const lines = systemOut.split("\n");
+  const panicLine = lines.find((l) => l.trim().startsWith("panic:"));
+  if (!panicLine) return undefined;
+  const message = panicLine
+    .trim()
+    .replace(/^panic:\s*/, "")
+    .replace(/\s*\[.*\]$/, "")
+    .trim();
+
+  // Find the stack frame for this test function, then grab the file:line on the next line
+  for (let i = 0; i < lines.length - 1; i++) {
+    if (lines[i].includes(`.${testName}(`)) {
+      const m = lines[i + 1].trim().match(/^([^:]+\.go):(\d+)/);
+      if (m) return { message, file: m[1].split("/").pop(), line: Number(m[2]) };
+    }
+  }
+  return { message };
+}
+
 function resolveFile(tc: JUnitTestCase, suite: JUnitTestSuite, cwd: string): string | undefined {
   const raw = tc.file ?? suite.file;
   if (raw) return path.relative(cwd, path.resolve(cwd, raw));
@@ -67,15 +107,22 @@ const parser: ParserModule = {
         const problem = tc.failure ?? tc.error;
         if (!problem) continue;
 
-        const file = resolveFile(tc, suite, ctx.cwd);
-        const line = tc.line !== undefined ? Number(tc.line) : undefined;
+        const bodyLocation = problem["#text"] ? parseBodyLocation(problem["#text"]) : undefined;
+        const panicInfo =
+          !bodyLocation && suite["system-out"] && tc.name ? parsePanicInfo(suite["system-out"], tc.name) : undefined;
+        const file =
+          (tc.file ?? suite.file)
+            ? resolveFile(tc, suite, ctx.cwd)
+            : (bodyLocation?.file ?? panicInfo?.file ?? resolveFile(tc, suite, ctx.cwd));
+        const line = tc.line !== undefined ? Number(tc.line) : (bodyLocation?.line ?? panicInfo?.line);
         const id = [file, line, tc.name].filter(Boolean).join(":");
 
         failures.push({
           id: id || String(failures.length),
           file,
           line: Number.isNaN(line) ? undefined : line,
-          message: problem.message ?? problem["#text"]?.trim().split("\n")[0],
+          message:
+            bodyLocation?.message ?? panicInfo?.message ?? problem.message ?? problem["#text"]?.trim().split("\n")[0],
           rule: problem.type,
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robhowley/pi-structured-return",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Structured command execution for Pi agents: compact results for the model, full logs for humans.",
   "license": "MIT",
   "repository": {

package/skills/structured-return/SKILL.md

@@ -25,8 +25,7 @@ Prefer better output at the source.
 ## Examples
 
 ### pytest
-- `structured_return({ command: "pytest [any pytest args] --json-report --json-report-file=.tmp/pytest-report.json", parseAs: "pytest-json-report", artifactPaths: [".tmp/pytest-report.json"] })` — append the json-report flags to whatever pytest invocation is needed; scope, filters, markers, etc. go in `[any pytest args]`
-- `structured_return({ command: "pytest -q" })` — fallback when json-report is unavailable
+- `structured_return({ command: "pytest [any pytest args] --junitxml=.tmp/report.xml", parseAs: "junit-xml", artifactPaths: [".tmp/report.xml"] })` — `--junitxml` is built into pytest, no extra dependencies needed; scope, filters, markers, etc. go in `[any pytest args]`
 
 ### ruff check
 - `structured_return({ command: "ruff check [any ruff args] --output-format=json", parseAs: "ruff-json" })` — scope, selects, ignores, etc. go in `[any ruff args]`
@@ -49,7 +48,8 @@ Prefer better output at the source.
 ### junit-xml
 JUnit XML is the de facto standard output format across the JVM ecosystem and many others — Maven, Gradle, pytest (`--junitxml`), Go (`go-junit-report`), .NET (`--logger trx` with conversion), Jest (`jest-junit`), and more. If a tool can emit JUnit XML, `junit-xml` covers it without a custom parser.
 
-- `structured_return({ command: "[tool] [args] --junitxml=.tmp/report.xml", parseAs: "junit-xml", artifactPaths: [".tmp/report.xml"] })` — pytest, nose2, and others that write to a file
+- `structured_return({ command: "[tool] [args] --junitxml=.tmp/report.xml", parseAs: "junit-xml", artifactPaths: [".tmp/report.xml"] })` — pytest, nose2, and any other tool that writes to a file via `--junitxml`
+- `structured_return({ command: "go test [any go test args] 2>&1 | go-junit-report > .tmp/report.xml", parseAs: "junit-xml", artifactPaths: [".tmp/report.xml"] })` — Go requires `go-junit-report` (`go install github.com/jstemmer/go-junit-report/v2@latest`); pipe `go test -v` output through it
 - `structured_return({ command: "gradle test", parseAs: "junit-xml", artifactPaths: ["build/test-results/test/TEST-*.xml"] })` — Gradle writes one XML per test class; pass all matching paths
 - `structured_return({ command: "mvn test", parseAs: "junit-xml", artifactPaths: ["target/surefire-reports/TEST-*.xml"] })` — Maven surefire same pattern
 

package/extensions/structured-return/src/parsers/pytest-json-report.test.ts

@@ -1,76 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { describe, it, expect } from "vitest";
-import parser from "./pytest-json-report";
-import type { RunContext } from "../types";
-
-function makeCtx(report: object | null): RunContext {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pytest-test-"));
-  const artifactPath = path.join(dir, "report.json");
-  if (report !== null) {
-    fs.writeFileSync(artifactPath, JSON.stringify(report));
-  }
-  return {
-    command: "pytest --json-report",
-    argv: ["pytest", "--json-report"],
-    cwd: "/project",
-    artifactPaths: [artifactPath],
-    stdoutPath: path.join(dir, "stdout"),
-    stderrPath: path.join(dir, "stderr"),
-    logPath: path.join(dir, "log"),
-  };
-}
-
-describe("pytest-json-report parser", () => {
-  it("mix of passed and failed tests → correct counts, status fail", async () => {
-    const report = {
-      summary: { passed: 3 },
-      tests: [
-        { nodeid: "test_foo.py::test_a", outcome: "passed" },
-        { nodeid: "test_foo.py::test_b", outcome: "failed", longrepr: "AssertionError: assert False" },
-        { nodeid: "test_foo.py::test_c", outcome: "failed", longrepr: "AssertionError: assert 1 == 2" },
-      ],
-    };
-    const result = await parser.parse(makeCtx(report));
-    expect(result.status).toBe("fail");
-    expect(result.failures).toHaveLength(2);
-    expect(result.summary).toBe("2 failed, 3 passed");
-  });
-
-  it("all passing → status pass, summary reflects passed count", async () => {
-    const report = {
-      summary: { passed: 5 },
-      tests: [
-        { nodeid: "test_foo.py::test_a", outcome: "passed" },
-        { nodeid: "test_foo.py::test_b", outcome: "passed" },
-      ],
-    };
-    const result = await parser.parse(makeCtx(report));
-    expect(result.status).toBe("pass");
-    expect(result.failures).toHaveLength(0);
-    expect(result.summary).toBe("5 passed");
-  });
-
-  it("failed test with longrepr → first line surfaced as message", async () => {
-    const report = {
-      summary: { passed: 0 },
-      tests: [
-        {
-          nodeid: "test_foo.py::test_a",
-          outcome: "failed",
-          longrepr: "AssertionError: assert False\nfull traceback line 2\nfull traceback line 3",
-        },
-      ],
-    };
-    const result = await parser.parse(makeCtx(report));
-    expect(result.failures![0].message).toBe("AssertionError: assert False");
-  });
-
-  it("missing artifact file → throws", async () => {
-    const ctx = makeCtx(null);
-    // point artifact at a file that doesn't exist
-    ctx.artifactPaths = ["/nonexistent/path/report.json"];
-    await expect(parser.parse(ctx)).rejects.toThrow();
-  });
-});

package/extensions/structured-return/src/parsers/pytest-json-report.ts

@@ -1,41 +0,0 @@
-import fs from "node:fs";
-import type { ParserModule } from "../types";
-
-interface PytestTest {
-  nodeid: string;
-  outcome: string;
-  longrepr?: string;
-}
-
-interface PytestReport {
-  tests?: PytestTest[];
-  summary?: { passed?: number };
-}
-
-const parser: ParserModule = {
-  id: "pytest-json-report",
-  async parse(ctx) {
-    const artifact = ctx.artifactPaths[0];
-    const data = JSON.parse(fs.readFileSync(artifact, "utf8")) as PytestReport;
-    const tests = Array.isArray(data.tests) ? data.tests : [];
-    const failures = tests
-      .filter((t) => t.outcome === "failed")
-      .map((t) => ({
-        id: t.nodeid,
-        file: String(t.nodeid || "").split("::")[0] || undefined,
-        message: typeof t.longrepr === "string" ? t.longrepr.split("\n")[0] : "test failed",
-      }));
-    const failed = failures.length;
-    const passed = Number(data.summary?.passed ?? 0);
-    return {
-      tool: "pytest",
-      status: failed > 0 ? "fail" : "pass",
-      summary: failed > 0 ? `${failed} failed, ${passed} passed` : `${passed} passed`,
-      failures,
-      artifact,
-      logPath: ctx.logPath,
-    };
-  },
-};
-
-export default parser;