@timmeck/brain 1.8.0 → 1.8.2

package/src/parsing/parsers/generic.ts

@@ -1,28 +1,28 @@
-import type { ErrorParser, ParsedError } from '../types.js';
-
-const ERROR_LINE_RE = /(?:error|Error|ERROR)[\s:]+(.+)/;
-
-export const genericParser: ErrorParser = {
-  name: 'generic',
-  priority: 0,
-
-  canParse(_input: string): boolean {
-    return true;
-  },
-
-  parse(input: string): ParsedError | null {
-    const match = ERROR_LINE_RE.exec(input);
-    const firstLine = input.trim().split('\n')[0] ?? input;
-    const message = match ? match[1]! : firstLine;
-
-    return {
-      errorType: 'UnknownError',
-      message: message.trim(),
-      stackTrace: null,
-      frames: [],
-      sourceFile: null,
-      sourceLine: null,
-      language: null,
-    };
-  },
-};
+import type { ErrorParser, ParsedError } from '../types.js';
+
+const ERROR_LINE_RE = /(?:error|Error|ERROR)[\s:]+(.+)/;
+
+export const genericParser: ErrorParser = {
+  name: 'generic',
+  priority: 0,
+
+  canParse(_input: string): boolean {
+    return true;
+  },
+
+  parse(input: string): ParsedError | null {
+    const match = ERROR_LINE_RE.exec(input);
+    const firstLine = input.trim().split('\n')[0] ?? input;
+    const message = match ? match[1]! : firstLine;
+
+    return {
+      errorType: 'UnknownError',
+      message: message.trim(),
+      stackTrace: null,
+      frames: [],
+      sourceFile: null,
+      sourceLine: null,
+      language: null,
+    };
+  },
+};

package/src/parsing/parsers/go.ts

@@ -1,97 +1,97 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const GO_FILE_ERROR_RE = /^\.?\/?(.+\.go):(\d+):(\d+): (.+)/m;
-const GO_PANIC_RE = /^panic: (.+)/m;
-const GO_GOROUTINE_RE = /^goroutine \d+ \[.+\]:/m;
-const GO_STACK_RE = /^\t(.+\.go):(\d+)/gm;
-const GO_FUNC_RE = /^(.+)\(.*\)$/gm;
-
-export const goParser: ErrorParser = {
-  name: 'go',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return (
-      GO_FILE_ERROR_RE.test(input) ||
-      GO_PANIC_RE.test(input) ||
-      /^fatal error:/.test(input)
-    );
-  },
-
-  parse(input: string): ParsedError | null {
-    const panicMatch = GO_PANIC_RE.exec(input);
-    if (panicMatch) {
-      return parsePanic(input, panicMatch[1]!);
-    }
-
-    const fileMatch = GO_FILE_ERROR_RE.exec(input);
-    if (fileMatch) {
-      return {
-        errorType: 'CompilerError',
-        message: fileMatch[4]!,
-        stackTrace: input,
-        frames: [{
-          function_name: null,
-          file_path: fileMatch[1]!,
-          line_number: parseInt(fileMatch[2]!, 10),
-          column_number: parseInt(fileMatch[3]!, 10),
-          normalized: `<compiler>@${path.basename(fileMatch[1]!)}`,
-        }],
-        sourceFile: fileMatch[1]!,
-        sourceLine: parseInt(fileMatch[2]!, 10),
-        language: 'go',
-      };
-    }
-
-    const fatalMatch = /^fatal error: (.+)/m.exec(input);
-    if (fatalMatch) {
-      return {
-        errorType: 'FatalError',
-        message: fatalMatch[1]!,
-        stackTrace: input,
-        frames: [],
-        sourceFile: null,
-        sourceLine: null,
-        language: 'go',
-      };
-    }
-
-    return null;
-  },
-};
-
-function parsePanic(input: string, message: string): ParsedError {
-  const frames: StackFrame[] = [];
-  const lines = input.split('\n');
-  let i = 0;
-
-  while (i < lines.length) {
-    if (lines[i]!.startsWith('\t')) {
-      const stackMatch = /^\t(.+\.go):(\d+)/.exec(lines[i]!);
-      if (stackMatch) {
-        const funcLine = i > 0 ? lines[i - 1]!.trim() : null;
-        const funcName = funcLine?.replace(/\(.*\)$/, '') ?? null;
-        frames.push({
-          function_name: funcName,
-          file_path: stackMatch[1]!,
-          line_number: parseInt(stackMatch[2]!, 10),
-          column_number: null,
-          normalized: `${funcName || '<anon>'}@${path.basename(stackMatch[1]!)}`,
-        });
-      }
-    }
-    i++;
-  }
-
-  const topFrame = frames[0];
-  return {
-    errorType: 'PanicError',
-    message,
-    stackTrace: input,
-    frames,
-    sourceFile: topFrame?.file_path ?? null,
-    sourceLine: topFrame?.line_number ?? null,
-    language: 'go',
-  };
-}
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const GO_FILE_ERROR_RE = /^\.?\/?(.+\.go):(\d+):(\d+): (.+)/m;
+const GO_PANIC_RE = /^panic: (.+)/m;
+const GO_GOROUTINE_RE = /^goroutine \d+ \[.+\]:/m;
+const GO_STACK_RE = /^\t(.+\.go):(\d+)/gm;
+const GO_FUNC_RE = /^(.+)\(.*\)$/gm;
+
+export const goParser: ErrorParser = {
+  name: 'go',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      GO_FILE_ERROR_RE.test(input) ||
+      GO_PANIC_RE.test(input) ||
+      /^fatal error:/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const panicMatch = GO_PANIC_RE.exec(input);
+    if (panicMatch) {
+      return parsePanic(input, panicMatch[1]!);
+    }
+
+    const fileMatch = GO_FILE_ERROR_RE.exec(input);
+    if (fileMatch) {
+      return {
+        errorType: 'CompilerError',
+        message: fileMatch[4]!,
+        stackTrace: input,
+        frames: [{
+          function_name: null,
+          file_path: fileMatch[1]!,
+          line_number: parseInt(fileMatch[2]!, 10),
+          column_number: parseInt(fileMatch[3]!, 10),
+          normalized: `<compiler>@${path.basename(fileMatch[1]!)}`,
+        }],
+        sourceFile: fileMatch[1]!,
+        sourceLine: parseInt(fileMatch[2]!, 10),
+        language: 'go',
+      };
+    }
+
+    const fatalMatch = /^fatal error: (.+)/m.exec(input);
+    if (fatalMatch) {
+      return {
+        errorType: 'FatalError',
+        message: fatalMatch[1]!,
+        stackTrace: input,
+        frames: [],
+        sourceFile: null,
+        sourceLine: null,
+        language: 'go',
+      };
+    }
+
+    return null;
+  },
+};
+
+function parsePanic(input: string, message: string): ParsedError {
+  const frames: StackFrame[] = [];
+  const lines = input.split('\n');
+  let i = 0;
+
+  while (i < lines.length) {
+    if (lines[i]!.startsWith('\t')) {
+      const stackMatch = /^\t(.+\.go):(\d+)/.exec(lines[i]!);
+      if (stackMatch) {
+        const funcLine = i > 0 ? lines[i - 1]!.trim() : null;
+        const funcName = funcLine?.replace(/\(.*\)$/, '') ?? null;
+        frames.push({
+          function_name: funcName,
+          file_path: stackMatch[1]!,
+          line_number: parseInt(stackMatch[2]!, 10),
+          column_number: null,
+          normalized: `${funcName || '<anon>'}@${path.basename(stackMatch[1]!)}`,
+        });
+      }
+    }
+    i++;
+  }
+
+  const topFrame = frames[0];
+  return {
+    errorType: 'PanicError',
+    message,
+    stackTrace: input,
+    frames,
+    sourceFile: topFrame?.file_path ?? null,
+    sourceLine: topFrame?.line_number ?? null,
+    language: 'go',
+  };
+}

package/src/parsing/parsers/node.ts

@@ -1,69 +1,69 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const V8_STACK_RE = /at (?:(.+?) )?\((.+?):(\d+):(\d+)\)/;
-const V8_STACK_BARE_RE = /at (.+?):(\d+):(\d+)/;
-const ERROR_TYPE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
-
-function parseFrames(input: string): StackFrame[] {
-  const frames: StackFrame[] = [];
-  for (const line of input.split('\n')) {
-    const trimmed = line.trim();
-    let match = V8_STACK_RE.exec(trimmed);
-    if (match) {
-      frames.push({
-        function_name: match[1] || null,
-        file_path: match[2]!,
-        line_number: parseInt(match[3]!, 10),
-        column_number: parseInt(match[4]!, 10),
-        normalized: `${match[1] || '<anon>'}@${path.basename(match[2]!)}`,
-      });
-      continue;
-    }
-    match = V8_STACK_BARE_RE.exec(trimmed);
-    if (match) {
-      frames.push({
-        function_name: null,
-        file_path: match[1]!,
-        line_number: parseInt(match[2]!, 10),
-        column_number: parseInt(match[3]!, 10),
-        normalized: `<anon>@${path.basename(match[1]!)}`,
-      });
-    }
-  }
-  return frames;
-}
-
-export const nodeParser: ErrorParser = {
-  name: 'node',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return (
-      /at .+ \(.+:\d+:\d+\)/.test(input) ||
-      /at .+:\d+:\d+/.test(input) ||
-      /^\w*Error:/.test(input) ||
-      /^\w*TypeError:/.test(input)
-    );
-  },
-
-  parse(input: string): ParsedError | null {
-    const typeMatch = ERROR_TYPE_RE.exec(input);
-    if (!typeMatch) return null;
-
-    const errorType = typeMatch[1]!;
-    const message = typeMatch[2]!;
-    const frames = parseFrames(input);
-    const topFrame = frames[0];
-
-    return {
-      errorType,
-      message,
-      stackTrace: input,
-      frames,
-      sourceFile: topFrame?.file_path ?? null,
-      sourceLine: topFrame?.line_number ?? null,
-      language: 'javascript',
-    };
-  },
-};
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const V8_STACK_RE = /at (?:(.+?) )?\((.+?):(\d+):(\d+)\)/;
+const V8_STACK_BARE_RE = /at (.+?):(\d+):(\d+)/;
+const ERROR_TYPE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
+
+function parseFrames(input: string): StackFrame[] {
+  const frames: StackFrame[] = [];
+  for (const line of input.split('\n')) {
+    const trimmed = line.trim();
+    let match = V8_STACK_RE.exec(trimmed);
+    if (match) {
+      frames.push({
+        function_name: match[1] || null,
+        file_path: match[2]!,
+        line_number: parseInt(match[3]!, 10),
+        column_number: parseInt(match[4]!, 10),
+        normalized: `${match[1] || '<anon>'}@${path.basename(match[2]!)}`,
+      });
+      continue;
+    }
+    match = V8_STACK_BARE_RE.exec(trimmed);
+    if (match) {
+      frames.push({
+        function_name: null,
+        file_path: match[1]!,
+        line_number: parseInt(match[2]!, 10),
+        column_number: parseInt(match[3]!, 10),
+        normalized: `<anon>@${path.basename(match[1]!)}`,
+      });
+    }
+  }
+  return frames;
+}
+
+export const nodeParser: ErrorParser = {
+  name: 'node',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      /at .+ \(.+:\d+:\d+\)/.test(input) ||
+      /at .+:\d+:\d+/.test(input) ||
+      /^\w*Error:/.test(input) ||
+      /^\w*TypeError:/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const typeMatch = ERROR_TYPE_RE.exec(input);
+    if (!typeMatch) return null;
+
+    const errorType = typeMatch[1]!;
+    const message = typeMatch[2]!;
+    const frames = parseFrames(input);
+    const topFrame = frames[0];
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile: topFrame?.file_path ?? null,
+      sourceLine: topFrame?.line_number ?? null,
+      language: 'javascript',
+    };
+  },
+};

package/src/parsing/parsers/python.ts

@@ -1,62 +1,62 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const FRAME_RE = /File "(.+?)", line (\d+)(?:, in (.+))?/g;
-const ERROR_LINE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
-
-export const pythonParser: ErrorParser = {
-  name: 'python',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return (
-      /Traceback \(most recent call last\)/.test(input) ||
-      /File ".+", line \d+/.test(input)
-    );
-  },
-
-  parse(input: string): ParsedError | null {
-    const frames: StackFrame[] = [];
-    let match: RegExpExecArray | null;
-    const frameRe = new RegExp(FRAME_RE.source, 'g');
-
-    while ((match = frameRe.exec(input)) !== null) {
-      frames.push({
-        function_name: match[3] || null,
-        file_path: match[1]!,
-        line_number: parseInt(match[2]!, 10),
-        column_number: null,
-        normalized: `${match[3] || '<module>'}@${path.basename(match[1]!)}`,
-      });
-    }
-
-    const lines = input.trim().split('\n');
-    let errorType = 'PythonError';
-    let message = '';
-
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const errMatch = ERROR_LINE_RE.exec(lines[i]!);
-      if (errMatch) {
-        errorType = errMatch[1]!;
-        message = errMatch[2]!;
-        break;
-      }
-    }
-
-    if (!message && lines.length > 0) {
-      message = lines[lines.length - 1]!;
-    }
-
-    const topFrame = frames[frames.length - 1];
-
-    return {
-      errorType,
-      message,
-      stackTrace: input,
-      frames,
-      sourceFile: topFrame?.file_path ?? null,
-      sourceLine: topFrame?.line_number ?? null,
-      language: 'python',
-    };
-  },
-};
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const FRAME_RE = /File "(.+?)", line (\d+)(?:, in (.+))?/g;
+const ERROR_LINE_RE = /^(\w+(?:Error|Exception|Warning)?): (.+)$/m;
+
+export const pythonParser: ErrorParser = {
+  name: 'python',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return (
+      /Traceback \(most recent call last\)/.test(input) ||
+      /File ".+", line \d+/.test(input)
+    );
+  },
+
+  parse(input: string): ParsedError | null {
+    const frames: StackFrame[] = [];
+    let match: RegExpExecArray | null;
+    const frameRe = new RegExp(FRAME_RE.source, 'g');
+
+    while ((match = frameRe.exec(input)) !== null) {
+      frames.push({
+        function_name: match[3] || null,
+        file_path: match[1]!,
+        line_number: parseInt(match[2]!, 10),
+        column_number: null,
+        normalized: `${match[3] || '<module>'}@${path.basename(match[1]!)}`,
+      });
+    }
+
+    const lines = input.trim().split('\n');
+    let errorType = 'PythonError';
+    let message = '';
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const errMatch = ERROR_LINE_RE.exec(lines[i]!);
+      if (errMatch) {
+        errorType = errMatch[1]!;
+        message = errMatch[2]!;
+        break;
+      }
+    }
+
+    if (!message && lines.length > 0) {
+      message = lines[lines.length - 1]!;
+    }
+
+    const topFrame = frames[frames.length - 1];
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile: topFrame?.file_path ?? null,
+      sourceLine: topFrame?.line_number ?? null,
+      language: 'python',
+    };
+  },
+};

package/src/parsing/parsers/rust.ts

@@ -1,50 +1,50 @@
-import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
-import path from 'node:path';
-
-const RUST_ERROR_RE = /error(?:\[E(\d+)\])?: (.+)/;
-const RUST_LOCATION_RE = /^\s*--> (.+):(\d+):(\d+)/m;
-const RUST_NOTE_RE = /^\s*= note: (.+)/gm;
-
-export const rustParser: ErrorParser = {
-  name: 'rust',
-  priority: 10,
-
-  canParse(input: string): boolean {
-    return /error\[E\d+\]:/.test(input) || /^error:/.test(input);
-  },
-
-  parse(input: string): ParsedError | null {
-    const errMatch = RUST_ERROR_RE.exec(input);
-    if (!errMatch) return null;
-
-    const message = errMatch[2]!.trim();
-    const errorType = errMatch[1] ? `E${errMatch[1]}` : 'CompilerError';
-
-    const frames: StackFrame[] = [];
-    let sourceFile: string | null = null;
-    let sourceLine: number | null = null;
-
-    const locMatch = RUST_LOCATION_RE.exec(input);
-    if (locMatch) {
-      sourceFile = locMatch[1]!;
-      sourceLine = parseInt(locMatch[2]!, 10);
-      frames.push({
-        function_name: null,
-        file_path: locMatch[1]!,
-        line_number: parseInt(locMatch[2]!, 10),
-        column_number: parseInt(locMatch[3]!, 10),
-        normalized: `<compiler>@${path.basename(locMatch[1]!)}`,
-      });
-    }
-
-    return {
-      errorType,
-      message,
-      stackTrace: input,
-      frames,
-      sourceFile,
-      sourceLine,
-      language: 'rust',
-    };
-  },
-};
+import type { ErrorParser, ParsedError, StackFrame } from '../types.js';
+import path from 'node:path';
+
+const RUST_ERROR_RE = /error(?:\[E(\d+)\])?: (.+)/;
+const RUST_LOCATION_RE = /^\s*--> (.+):(\d+):(\d+)/m;
+const RUST_NOTE_RE = /^\s*= note: (.+)/gm;
+
+export const rustParser: ErrorParser = {
+  name: 'rust',
+  priority: 10,
+
+  canParse(input: string): boolean {
+    return /error\[E\d+\]:/.test(input) || /^error:/.test(input);
+  },
+
+  parse(input: string): ParsedError | null {
+    const errMatch = RUST_ERROR_RE.exec(input);
+    if (!errMatch) return null;
+
+    const message = errMatch[2]!.trim();
+    const errorType = errMatch[1] ? `E${errMatch[1]}` : 'CompilerError';
+
+    const frames: StackFrame[] = [];
+    let sourceFile: string | null = null;
+    let sourceLine: number | null = null;
+
+    const locMatch = RUST_LOCATION_RE.exec(input);
+    if (locMatch) {
+      sourceFile = locMatch[1]!;
+      sourceLine = parseInt(locMatch[2]!, 10);
+      frames.push({
+        function_name: null,
+        file_path: locMatch[1]!,
+        line_number: parseInt(locMatch[2]!, 10),
+        column_number: parseInt(locMatch[3]!, 10),
+        normalized: `<compiler>@${path.basename(locMatch[1]!)}`,
+      });
+    }
+
+    return {
+      errorType,
+      message,
+      stackTrace: input,
+      frames,
+      sourceFile,
+      sourceLine,
+      language: 'rust',
+    };
+  },
+};