src-services-log-parser-service.ts

import { Line, Command } from "./line.js";

/**
 * Pointer to a line in the parsed log, either a direct index or [groupIndex, childIndex] tuple
 */
export type LinePointer = number | [number, number];

/**
 * Main parser class for processing GitHub Actions log streams
 */
export class LogParser {
  counter: number;
  seenIDs: Set<string>;
  search: string;
  matches: number;
  lines: Line[];
  _visibleLines?: LinePointer[];
  onVisibleLinesChange?: (lines?: LinePointer[]) => void;

  constructor() {
    this.counter = 1;
    this.seenIDs = new Set();
    this.search = "";
    this.matches = 0;
    this.lines = [];
  }

  /**
   * Resets the parser to its initial state
   */
  reset() {
    this.counter = 1;
    this.seenIDs = new Set();
    this.matches = 0;
    this.lines = [];
    this.resetVisibleLines();
  }

  /**
   * Get an array of pointers to visible lines, taking into account group state
   * @returns Array of line pointers indicating which lines are currently visible
   */
  getVisibleLines(): LinePointer[] {
    if (this._visibleLines) {
      return this._visibleLines;
    }

    // build a mapping of visible lines to their locations in the array for fast lookups
    this._visibleLines = [];
    for (let i = 0; i < this.lines.length; i++) {
      this._visibleLines.push(i);

      const line = this.lines[i];
      if (line.group?.open) {
        // if we're in an open group, add all of its children
        for (let j = 0; j < line.group.children.length; j++) {
          this._visibleLines.push([i, j]);
        }
        continue;
      }
    }

    this.onVisibleLinesChange?.(this._visibleLines);
    return this._visibleLines;
  }

  /**
   * Gets a visible line by its index in the visible lines array
   * @param idx - Index in the visible lines array
   * @returns The line at the specified visible index, or undefined if not found
   */
  getVisibleLine(idx: number): Line | undefined {
    const mapping = this.getVisibleLines()[idx];
    if (typeof mapping === "undefined") {
      return;
    }
    if (typeof mapping === "number") {
      return this.lines[mapping];
    }
    return this.lines[mapping[0]].group?.children[mapping[1]];
  }

  /**
   * Resets the visible lines cache and notifies listeners
   */
  resetVisibleLines() {
    this._visibleLines = undefined;
    this.onVisibleLinesChange?.(this.getVisibleLines());
  }

  /**
   * Adds a new log line to the parser
   * @param raw - The raw log line string
   * @param id - Optional unique identifier for the line
   */
  add(raw: string, id?: string) {
    if (id) {
      if (this.seenIDs.has(id)) {
        return;
      }

      this.seenIDs.add(id);
    }

    const line = new Line(this.counter, raw, id);
    if (this.search) {
      line.highlight(this.search);
    }

    switch (line.cmd) {
      case Command.EndGroup: {
        if (this.inGroup()) {
          this.endGroup();
          // don't add endgroup lines when they properly close a group
          // also don't increment the index
          return;
        }

        // if not in group, treat endgroup as a regular line
        this.lines.push(line);
        break;
      }
      case Command.Group: {
        // add a callback to reset visible lines when the group changes
        line.group!.onGroupChange(() => this.resetVisibleLines());

        // we'll want to close any open group
        this.endGroup();
        this.lines.push(line);
        break;
      }
      default: {
        if (this.inGroup()) {
          // in a group, add it to said group
          line.parent = this.last();
          this.last()?.group!.children.push(line);
        } else {
          // otherwise, add it as a regular line
          this.lines.push(line);
        }
      }
    }

    this.counter++;
    this.matches += line.highlights.size;
    this.resetVisibleLines();
  }

  /**
   * Adds multiple log lines from a raw string (split by newlines)
   * @param raw - Raw string containing multiple log lines
   */
  addRaw(raw: string) {
    raw.split("\n").forEach((line) => this.add(line));
  }

  /**
   * Gets the last added line
   * @returns The most recently added line
   */
  last(): Line {
    return this.lines[this.lines.length - 1];
  }

  /**
   * Checks if the parser is currently in an open group
   * @returns True if currently in an open group, false otherwise
   */
  inGroup() {
    let group = this.last()?.group;
    return group && !group.ended;
  }

  /**
   * Ends the current group if one is open
   */
  endGroup() {
    if (this.inGroup()) {
      this.last().group!.end();
    }
  }

  /**
   * Sets the search term and highlights matching text in all lines
   * @param search - The search string to highlight
   * @returns The total number of matches found
   */
  setSearch(search: string): number {
    this.matches = 0;
    this.search = search;
    for (let line of this.lines) {
      this.matches += line.highlight(search);
    }
    return this.matches;
  }

  /**
   * Gets the current number of search matches
   * @returns The total number of search matches across all lines
   */
  getMatches(): number {
    return this.matches;
  }
}
  }

  /**
   * Parse multiple log entries from text
   */
  parseLogFile(content: string): LogEntry[] {
    const lines = content.split('\n').filter(line => line.trim());
    return lines
      .map(line => this.parseLogEntry(line))
      .filter((entry): entry is LogEntry => entry !== null);
  }
}