Class Logger

hindsight-integrations/opencode/src/logger.ts:43–100

const SERVICE = "hindsight";

export class Logger {
  private readonly client?: OpencodeLogClient;
  private readonly debugEnabled: boolean;
  private readonly silent: boolean;

  constructor(options: LoggerOptions = {}) {
    this.client = options.client;
    this.debugEnabled = options.debug ?? false;
    this.silent = options.silent ?? false;
  }

  private emit(level: LogLevel, message: string, extra?: Record<string, unknown>): void {
    if (this.silent) return;

    const app = this.client?.app;
    if (app && typeof app.log === "function") {
      try {
        // IMPORTANT: call as a method on `app` so `this` is preserved.
        // OpenCode's `app.log` is a class method that uses `this` internally;
        // calling a detached reference (`const log = app.log; log(...)`) throws
        // `this._client is undefined`, which would otherwise be swallowed below
        // and produce no log at all.
        const result = app.log({ body: { service: SERVICE, level, message, extra } });
        // Fire-and-forget: a logging failure must never surface to OpenCode.
        if (result && typeof (result as Promise<unknown>).then === "function") {
          (result as Promise<unknown>).then(undefined, () => {});
        }
        return;
      } catch {
        // Fall through to the console fallback if app.log throws synchronously.
      }
    }

    // Fallback when no OpenCode client is available (or app.log failed).
    // OpenCode captures plugin console output into its logs, so this stays
    // visible and TUI-safe.
    const line = extra
      ? `[Hindsight] ${message} ${JSON.stringify(extra)}`
      : `[Hindsight] ${message}`;
    console.error(line);
  }

  error(message: string, error?: unknown): void {
    this.emit("error", message, error === undefined ? undefined : { error: errorToString(error) });
  }

  warn(message: string, extra?: Record<string, unknown>): void {
    this.emit("warn", message, extra);
  }

  info(message: string, extra?: Record<string, unknown>): void {
    this.emit("info", message, extra);
  }

  debug(message: string, extra?: Record<string, unknown>): void {
    if (this.debugEnabled) this.emit("debug", message, extra);
  }
}