fix: bring the parser back in step with the JetBrains one

Ports the fix from stacktale-intellij#11, which closed the same three bugs
there. The two parsers are deliberate twins and had diverged.

- a block whose END delimiter has not arrived is discarded, not shown as a
  partial report (FORMAT.md requires this of any reader)
- a marked frame with no usable line number no longer falls back to the
  first frame, which for a wrapped exception is the wrapped by: line in a
  different class — jumping there silently is worse than not jumping
- the file pattern accepts Unicode names and .kts; \w is ASCII-only in JS
  without the u flag, so Ação.java matched nothing and the report came out
  with no culprit at all

Verified against the authoritative golden fixtures in the main repo: both
parsers now return the same culprit for all three, including null for the
no-throwable report.

Closes #5

Author: GabrielBBaldez

CHANGELOG.md

@@ -9,3 +9,9 @@ First release. Parity with the JetBrains plugin's core:
 - **Click to open the culprit** frame (`File.java:line`, the `← YOUR CODE` frame).
 - **Copy report for AI** — copies the full report block to the clipboard.
 - Auto-detects `errors-ai.log` in the workspace; `stacktale.file` overrides the path.
+- Clicking a report always responds: one with no source frame says so instead of doing
+  nothing, and the view header shows which `errors-ai.log` was resolved. Thanks
+  @11suixing11.
+- Parser conformance: a block caught mid-write is discarded until its closing delimiter
+  arrives (as `FORMAT.md` requires), a marked frame with no line number no longer falls
+  back to an unrelated file, and Unicode source names and `.kts` frames parse.

src/stParser.ts

@@ -25,8 +25,18 @@ const START = "━━━ ERROR #";
 const END = "━━━ END #";
 // id + timestamp from "━━━ ERROR #a1b2 ━━━ 2026-07-10 20:16:40.412 thread=… ━━━"
 const HEADER = /^━━━ ERROR #(\S+) ━━━ (.+?) thread=/;
-// a frame carrying a source location: "…(PaymentService.java:44)"
-const FRAME = /\(([\w$]+\.(?:java|kt|groovy|scala)):(\d+)\)/;
+// A frame carrying a source location: "…(PaymentService.java:44)".
+//
+// The file part accepts anything that isn't whitespace, a colon or a paren, so Unicode
+// source names (`Ação.java`) match — `\w` is ASCII-only in JS without the `u` flag, and a
+// frame that doesn't match leaves the report with no culprit at all.
+//
+// `kts` is listed before `kt` on purpose: with `kt` first the engine matches `.kt`, then
+// needs `:` and finds `s`, and the whole frame fails to parse.
+//
+// The line number allows a leading `-`. The JVM writes -1 for a class compiled without
+// `-g:lines` and -2 for a native method, and the library renders it verbatim.
+const FRAME = /\(([^\s:()]+\.(?:java|kts|kt|groovy|scala)):(-?\d+)\)/;
 
 export function parseReports(content: string): StReport[] {
   const reports: StReport[] = [];
@@ -42,6 +52,7 @@ export function parseReports(content: string): StReport[] {
       continue;
     }
     const block: string[] = [lines[i]];
+    let complete = false;
     let j = i + 1;
     while (j < lines.length) {
       const bl = lines[j];
@@ -50,14 +61,20 @@ export function parseReports(content: string): StReport[] {
       }
       block.push(bl);
       if (bl.startsWith(END)) {
+        complete = true;
         j++;
         break;
       }
       j++;
     }
-    const report = parseBlock(block);
-    if (report) {
-      reports.push(report);
+    // FORMAT.md: a block whose closing line is absent is incomplete and MUST be discarded
+    // rather than shown as a partial entry. The writer appends the block separately from
+    // the header, so a read can land mid-write and catch exactly this.
+    if (complete) {
+      const report = parseBlock(block);
+      if (report) {
+        reports.push(report);
+      }
     }
     i = j;
   }
@@ -74,18 +91,31 @@ function parseBlock(block: string[]): StReport | undefined {
   const headline = block.length > 1 ? block[1].trim() : "";
 
   let culprit: StFrame | undefined;
+  let markedFrameSeen = false;
   const frames: StFrame[] = [];
   for (const bl of block) {
     const fm = FRAME.exec(bl);
-    if (fm) {
-      const frame: StFrame = { file: fm[1], line: parseInt(fm[2], 10), text: bl.trim() };
-      frames.push(frame);
-      if (!culprit && (bl.includes("← YOUR CODE") || bl.includes("← culprit"))) {
-        culprit = frame;
-      }
+    if (!fm) {
+      continue;
+    }
+    const marked = bl.includes("← YOUR CODE") || bl.includes("← culprit");
+    if (marked) {
+      markedFrameSeen = true;
+    }
+    const line = parseInt(fm[2], 10);
+    if (line <= 0) {
+      continue; // no source position — nothing to navigate to
+    }
+    const frame: StFrame = { file: fm[1], line, text: bl.trim() };
+    frames.push(frame);
+    if (!culprit && marked) {
+      culprit = frame;
     }
   }
-  if (!culprit && frames.length > 0) {
+  // Fall back to the first frame ONLY when the block marked none. When a frame WAS marked
+  // but had no usable position, jumping to some other frame is worse than not jumping: for
+  // a wrapped exception that other frame is the `wrapped by:` line, in a different class.
+  if (!culprit && !markedFrameSeen && frames.length > 0) {
     culprit = frames[0];
   }
   return { id, timestamp, headline, culprit, frames, block: block.join("\n") };

src/test/parser.test.ts

@@ -64,3 +64,61 @@ test("keeps reports that do not contain a source frame", () => {
   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.
+
+test("discards a truncated block and still parses the next complete one", () => {
+  const truncated =
+    "━━━ ERROR #dead ━━━ 2026-07-10 20:18:00.000 thread=main ━━━\n" +
+    "RuntimeException: boom\n" +
+    "at Svc.run(Svc.java:12) ← YOUR CODE\n";
+
+  assert.equal(parseReports(truncated).length, 0);
+
+  const followed =
+    truncated +
+    "━━━ ERROR #beef ━━━ 2026-07-10 20:19:00.000 thread=main ━━━\n" +
+    "RuntimeException: complete\n" +
+    "at GoodService.run(GoodService.java:7) ← YOUR CODE\n" +
+    "━━━ END #beef ━━━\n";
+
+  const reports = parseReports(followed);
+  assert.equal(reports.length, 1);
+  assert.equal(reports[0].id, "beef");
+});
+
+test("a marked frame with no line number does not fall back to another file", () => {
+  // -1 is what the JVM reports for a class compiled without -g:lines
+  const content = [
+    "━━━ ERROR #nodebug ━━━ 2026-07-10 20:20:00.000 thread=main ━━━",
+    "IllegalStateException: wrapped failure",
+    "wrapped by: CheckoutException at CheckoutService.confirm(CheckoutService.java:88)",
+    "at OrderService.confirm(OrderService.java:-1) ← YOUR CODE",
+    "━━━ END #nodebug ━━━",
+  ].join("\n");
+
+  const r = parseReports(content)[0];
+  assert.equal(r.culprit, undefined);
+  assert.deepEqual(r.frames.map((f) => f.file), ["CheckoutService.java"]);
+});
+
+test("parses unicode filenames and .kts frames", () => {
+  const content = [
+    "━━━ ERROR #unicode ━━━ 2026-07-10 20:22:00.000 thread=main ━━━",
+    "RuntimeException: unicode filename",
+    "at Ação.run(Ação.java:23) ← YOUR CODE",
+    "━━━ END #unicode ━━━",
+    "━━━ ERROR #script ━━━ 2026-07-10 20:23:00.000 thread=main ━━━",
+    "RuntimeException: kotlin script",
+    "at 構建.run(構建.kts:9) ← YOUR CODE",
+    "━━━ END #script ━━━",
+  ].join("\n");
+
+  const reports = parseReports(content);
+  assert.equal(reports.length, 2);
+  assert.equal(reports[0].culprit?.file, "Ação.java");
+  assert.equal(reports[0].culprit?.line, 23);
+  assert.equal(reports[1].culprit?.file, "構建.kts");
+  assert.equal(reports[1].culprit?.line, 9);
+});