feat: parse st-json/1 reports (#13)

Author: janithcd

src/stParser.ts

@@ -1,7 +1,8 @@
-// Parses the st/1 text in errors-ai.log into reports. Pure — no vscode dependency — so it
-// is unit-testable headless. Mirrors the IntelliJ plugin's parser: tolerant of unknown
-// lines (forward compatibility per the st/1 spec), of the self-describing file header
-// (which quotes the delimiter mid-line inside a '#' comment), and of truncated/rotated files.
+// Parses st/1 text or st-json/1 NDJSON in errors-ai.log into reports. Pure — no vscode
+// dependency — so it is unit-testable headless. Mirrors the IntelliJ plugin's text parser:
+// tolerant of unknown lines (forward compatibility per the st/1 spec), of the
+// self-describing file header (which quotes the delimiter mid-line inside a '#' comment),
+// and of truncated/rotated files.
 
 export interface StFrame {
   /** The source file name as written in the frame, e.g. "PaymentService.java". */
@@ -39,10 +40,21 @@ const HEADER = /^━━━ ERROR #(\S+) ━━━ (.+?) thread=/;
 const FRAME = /\(([^\s:()]+\.(?:java|kts|kt|groovy|scala)):(-?\d+)\)/;
 
 export function parseReports(content: string): StReport[] {
-  const reports: StReport[] = [];
   if (!content) {
-    return reports;
+    return [];
   }
+
+  const firstEntry = content
+    .split("\n")
+    .map(stripCr)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0 && !line.startsWith("#"));
+
+  return firstEntry?.startsWith("{") ? parseJsonReports(content) : parseTextReports(content);
+}
+
+function parseTextReports(content: string): StReport[] {
+  const reports: StReport[] = [];
   const lines = content.split("\n").map(stripCr);
   let i = 0;
   while (i < lines.length) {
@@ -81,6 +93,121 @@ export function parseReports(content: string): StReport[] {
   return reports;
 }
 
+function parseJsonReports(content: string): StReport[] {
+  const reports: StReport[] = [];
+  for (const rawLine of content.split("\n")) {
+    const line = stripCr(rawLine).trim();
+    if (!line) {
+      continue;
+    }
+
+    let entry: unknown;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue; // torn/half-written lines must not abort the rest of the file
+    }
+
+    const report = parseJsonReport(entry);
+    if (report) {
+      reports.push(report);
+    }
+  }
+  return reports;
+}
+
+function parseJsonReport(entry: unknown): StReport | undefined {
+  if (!isObject(entry) || entry.type !== "report") {
+    return undefined;
+  }
+
+  const id = stringValue(entry.id);
+  if (!id) {
+    return undefined;
+  }
+
+  const timestamp = jsonTimestamp(stringValue(entry.ts));
+  const error = isObject(entry.error) ? entry.error : {};
+  const headline = jsonHeadline(error);
+  const frames: StFrame[] = [];
+
+  let culprit: StFrame | undefined;
+  const culpritValue = isObject(error.culprit) ? error.culprit : undefined;
+  if (culpritValue) {
+    const frameText = stringValue(culpritValue.frame);
+    const text = culpritValue.appCode === true ? `${frameText} ← YOUR CODE` : frameText;
+    culprit = parseFrame(text);
+    if (culprit) {
+      frames.push(culprit);
+    }
+  }
+
+  if (Array.isArray(error.wrappedBy)) {
+    for (const value of error.wrappedBy) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      const frame = parseFrame(value);
+      if (frame) {
+        frames.push(frame);
+      }
+    }
+  }
+
+  const stack = isObject(entry.stack) ? entry.stack : undefined;
+  if (stack && Array.isArray(stack.frames)) {
+    for (const value of stack.frames) {
+      if (typeof value !== "string") {
+        continue;
+      }
+      const frame = parseFrame(value);
+      if (frame) {
+        frames.push(frame);
+      }
+    }
+  }
+
+  return {
+    id,
+    timestamp,
+    headline,
+    culprit,
+    frames,
+    block: JSON.stringify(entry, null, 2) + "\n",
+  };
+}
+
+function jsonHeadline(error: Record<string, unknown>): string {
+  const message = stringValue(error.message);
+  if (error.noException === true) {
+    return `ERROR (no exception): ${message}`;
+  }
+  const type = stringValue(error.type);
+  return message ? `${type}: ${message}` : type;
+}
+
+function jsonTimestamp(timestamp: string): string {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}\.\d{3})(?:Z|[+-]\d{2}:\d{2})$/.exec(timestamp);
+  return match ? `${match[1]} ${match[2]}` : timestamp;
+}
+
+function parseFrame(text: string): StFrame | undefined {
+  const match = FRAME.exec(text);
+  if (!match) {
+    return undefined;
+  }
+  const line = parseInt(match[2], 10);
+  return line > 0 ? { file: match[1], line, text: text.trim() } : undefined;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
 function parseBlock(block: string[]): StReport | undefined {
   const header = HEADER.exec(block[0]);
   if (!header) {

src/test/parser.test.ts

@@ -65,6 +65,59 @@ test("keeps reports that do not contain a source frame", () => {
   assert.equal(reports[0].culprit, undefined);
 });
 
+test("parses st-json/1 reports and ignores non-report and torn entries", () => {
+  const content = [
+    '  {"type":"header","format":"st-json/1"}',
+    JSON.stringify({
+      type: "report",
+      id: "json0001",
+      ts: "2026-07-10T20:16:40.412Z",
+      thread: "main",
+      error: {
+        type: "IllegalStateException",
+        message: "payment gateway refused",
+        culprit: {
+          frame: "PaymentService.charge(PaymentService.java:44)",
+          appCode: true,
+        },
+      },
+      stack: {
+        shown: 1,
+        total: 1,
+        frames: ["PaymentService.charge(PaymentService.java:44)"],
+      },
+    }),
+    '{"type":"repeat","id":"json0001","count":3,"last":"2026-07-10T20:17:30.000Z"}',
+    '{"type":"report","id":"half-written"',
+  ].join("\n");
+
+  const reports = parseReports(content);
+  assert.equal(reports.length, 1);
+  const r = reports[0];
+  assert.equal(r.id, "json0001");
+  assert.equal(r.timestamp, "2026-07-10 20:16:40.412");
+  assert.equal(r.headline, "IllegalStateException: payment gateway refused");
+  assert.equal(r.culprit?.file, "PaymentService.java");
+  assert.equal(r.culprit?.line, 44);
+  assert.equal(JSON.parse(r.block).type, "report");
+});
+
+test("maps an st-json/1 no-exception report", () => {
+  const content = JSON.stringify({
+    type: "report",
+    id: "json0002",
+    ts: "2026-07-10T20:17:01.000Z",
+    thread: "worker-1",
+    error: { noException: true, message: "checkout timed out" },
+  });
+
+  const reports = parseReports(content);
+  assert.equal(reports.length, 1);
+  assert.equal(reports[0].headline, "ERROR (no exception): checkout timed out");
+  assert.equal(reports[0].frames.length, 0);
+  assert.equal(reports[0].culprit, undefined);
+});
+
 // The three bugs from #5, mirroring the fix landed in the JetBrains plugin (its PR #11).
 // The two parsers are deliberate twins; these cases must behave identically in both.