import { performance } from "node:perf_hooks";

import { log } from "./cli.ts";

export class Timer {

private initialTimestamp: number;

private lastCheckpointTimestamp: number | null = null;

constructor() {

this.initialTimestamp = performance.now();

}

checkpoint(name: string): void {

const now = performance.now();

const duration = this.lastCheckpointTimestamp

? now - this.lastCheckpointTimestamp

: now - this.initialTimestamp;

log.debug(`» ${name}: ${duration}ms`);

this.lastCheckpointTimestamp = now;

}

}

const THINKING_THRESHOLD = 3000; // ms

/**

* Measures wall-clock gap between the last tool_result and the next tool_call,

* surfacing it as a "thought for Xs" log when over `THINKING_THRESHOLD`.

*

* Use one instance per logical session (orchestrator, each subagent) — sharing

* a single timer across sessions conflates cross-session interleaving as

* thinking time. The optional `formatLine` lets the caller prefix output with

* a session label so attribution is visible in the merged log stream.

*/

export class ThinkingTimer {

private readonly durationFormatter = new Intl.NumberFormat("en-US", {

style: "unit",

unit: "second",

unitDisplay: "long",

minimumFractionDigits: 0,

maximumFractionDigits: 1,

});

private lastToolResultTimestamp: number | null = null;

private readonly formatLine: (line: string) => string;

// node's native TS strip-only mode does not support parameter properties,

// so the formatter is declared as a field and assigned in the body.

constructor(formatLine: (line: string) => string = (l) => l) {

this.formatLine = formatLine;

}

markToolResult(): void {

this.lastToolResultTimestamp = performance.now();

log.debug(

this.formatLine(`» thinking timer: markToolResult at ${this.lastToolResultTimestamp}`)

);

}

markToolCall(): void {

const now = performance.now();

log.debug(

this.formatLine(

`» thinking timer: markToolCall at ${now}, lastToolResult=${this.lastToolResultTimestamp}`

)

);

if (this.lastToolResultTimestamp === null) return;

const elapsed = now - this.lastToolResultTimestamp;

if (elapsed < THINKING_THRESHOLD) return;

const seconds = elapsed / 1000;

log.info(this.formatLine(`» thought for ${this.durationFormatter.format(seconds)}`));

}

}