@yagni-app/code 1.0.6 → 1.0.8

package/dist/extension/telemetry/tracker.js

@@ -0,0 +1,551 @@
+/**
+ * Session telemetry tracker: turns pi's lifecycle into spans, metrics, and
+ * log events. Pure with respect to pi — `register.ts` feeds it events, tests
+ * feed it directly — and it only ever talks to the OTel API (tracer, meter,
+ * logger), never to exporters.
+ *
+ * Shape (Claude Code parity, prefix `yagni_code`):
+ *
+ *   spans    yagni_code.interaction ─┬─ yagni_code.turn ─┬─ yagni_code.llm_request
+ *                                    │                   └─ yagni_code.tool
+ *   metrics  session.count, token.usage, cost.usage, lines_of_code.count,
+ *            commit.count, pull_request.count, code_edit_tool.decision,
+ *            active_time.total
+ *   events   user_prompt, assistant_response, api_request, api_error,
+ *            tool_result, tool_decision, permission_mode_changed
+ *
+ * Metadata only. Prompt text, model output, tool arguments, and tool results
+ * never become attributes — only their lengths.
+ */
+import { randomUUID } from "node:crypto";
+import { context as otelContext, SpanStatusCode, trace, } from "@opentelemetry/api";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ATTR_APP_ENTRYPOINT, ATTR_APP_VERSION, ATTR_ERROR_TYPE, ATTR_GEN_AI_AGENT_NAME, ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY, ATTR_GEN_AI_CACHE_READ_TOKENS, ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY, ATTR_GEN_AI_CACHE_WRITE_TOKENS, ATTR_GEN_AI_CONVERSATION_ID, ATTR_GEN_AI_COST_ESTIMATED_TOTAL, ATTR_GEN_AI_FINISH_REASONS, ATTR_GEN_AI_INPUT_TOKENS, ATTR_GEN_AI_OPERATION_NAME, ATTR_GEN_AI_OUTPUT_TOKENS, ATTR_GEN_AI_TOTAL_TOKENS, ATTR_GEN_AI_PROVIDER_NAME, ATTR_GEN_AI_REQUEST_MODEL, ATTR_GEN_AI_RESPONSE_ID, ATTR_GEN_AI_RESPONSE_MODEL, ATTR_GEN_AI_SYSTEM, ATTR_GEN_AI_TOOL_CALL_ID, ATTR_GEN_AI_TOOL_NAME, ATTR_GEN_AI_TOOL_TYPE, ATTR_HTTP_STATUS_CODE, ATTR_ORGANIZATION_ID, ATTR_SESSION_ID, ATTR_TERMINAL_TYPE, ATTR_USER_EMAIL, EVENT_API_ERROR, EVENT_API_REQUEST, EVENT_ASSISTANT_RESPONSE, EVENT_PERMISSION_MODE_CHANGED, EVENT_TOOL_DECISION, EVENT_TOOL_RESULT, EVENT_USER_PROMPT, GEN_AI_PROVIDER, languageFromPath, METRIC_ACTIVE_TIME, METRIC_CODE_EDIT_DECISION, METRIC_COMMIT_COUNT, METRIC_COST_USAGE, METRIC_LINES_OF_CODE, METRIC_PULL_REQUEST_COUNT, METRIC_SESSION_COUNT, METRIC_TOKEN_USAGE, PREFIX, SPAN_INTERACTION, SPAN_LLM_REQUEST, SPAN_TOOL, SPAN_TURN, } from "./attrs.js";
+/** Idle cutoff for user active time: gaps longer than this are not "active". */
+export const USER_ACTIVE_IDLE_CUTOFF_MS = 5 * 60 * 1000;
+const EDIT_TOOLS = new Set(["edit", "write", "multi_edit", "notebook_edit"]);
+const GIT_COMMIT_RE = /(?:^|[;&|]\s*)git\s+(?:-C\s+\S+\s+)?(?:[a-z-]+=\S+\s+)*commit\b/;
+const GH_PR_CREATE_RE = /(?:^|[;&|]\s*)gh\s+pr\s+create\b/;
+export class SessionTelemetry {
+    tracer;
+    meter;
+    logger;
+    config;
+    now;
+    sessionId;
+    sessionCounted = false;
+    eventSequence = 0;
+    interactionSequence = 0;
+    interaction = null;
+    turn = null;
+    llm = null;
+    tools = new Map();
+    /** Decision recorded per tool call before it executes (feeds tool_result). */
+    decisions = new Map();
+    /** When the agent last went idle — the start of the user's active window. */
+    idleSince;
+    counters = {};
+    constructor(deps) {
+        this.tracer = deps.tracer;
+        this.meter = deps.meter;
+        this.logger = deps.logger;
+        this.config = deps.config;
+        this.now = deps.now ?? (() => Date.now());
+    }
+    // ── Standard attributes ─────────────────────────────────────────────────
+    /** Attributes every metric and event carries (Claude Code's standard set). */
+    standardAttributes() {
+        const id = this.config.identity;
+        const attrs = {};
+        if (this.config.includeSessionId && this.sessionId)
+            attrs[ATTR_SESSION_ID] = this.sessionId;
+        if (this.config.includeVersion && id.appVersion)
+            attrs[ATTR_APP_VERSION] = id.appVersion;
+        if (this.config.includeEntrypoint)
+            attrs[ATTR_APP_ENTRYPOINT] = id.entrypoint;
+        if (id.organizationId)
+            attrs[ATTR_ORGANIZATION_ID] = id.organizationId;
+        if (this.config.includeAccountId && id.userEmail)
+            attrs[ATTR_USER_EMAIL] = id.userEmail;
+        if (id.terminalType)
+            attrs[ATTR_TERMINAL_TYPE] = id.terminalType;
+        if (this.config.includeResourceAttributes)
+            Object.assign(attrs, this.config.resourceAttributes);
+        return attrs;
+    }
+    /** Attributes every span carries: session identity in both vocabularies. */
+    spanAttributes() {
+        const attrs = {
+            [ATTR_GEN_AI_PROVIDER_NAME]: GEN_AI_PROVIDER,
+            [ATTR_GEN_AI_SYSTEM]: GEN_AI_PROVIDER,
+            [ATTR_GEN_AI_AGENT_NAME]: this.config.serviceName,
+        };
+        if (this.sessionId) {
+            attrs[ATTR_SESSION_ID] = this.sessionId;
+            attrs[ATTR_GEN_AI_CONVERSATION_ID] = this.sessionId;
+        }
+        const id = this.config.identity;
+        if (id.organizationId)
+            attrs[ATTR_ORGANIZATION_ID] = id.organizationId;
+        // Same gate as the metrics/events attribute set: an admin who turned
+        // account identity off gets it off on spans too.
+        if (this.config.includeAccountId && id.userEmail)
+            attrs[ATTR_USER_EMAIL] = id.userEmail;
+        if (id.appVersion)
+            attrs[ATTR_APP_VERSION] = id.appVersion;
+        return attrs;
+    }
+    // ── Instruments ─────────────────────────────────────────────────────────
+    counter(name, unit, description) {
+        let c = this.counters[name];
+        if (!c) {
+            c = this.meter.createCounter(name, { unit, description });
+            this.counters[name] = c;
+        }
+        return c;
+    }
+    add(name, unit, description, value, attrs = {}) {
+        if (!Number.isFinite(value) || value === 0)
+            return;
+        try {
+            this.counter(name, unit, description).add(value, { ...this.standardAttributes(), ...attrs });
+        }
+        catch {
+            // Metrics are best-effort.
+        }
+    }
+    // ── Events ──────────────────────────────────────────────────────────────
+    emitEvent(name, attrs) {
+        this.eventSequence += 1;
+        const record = {
+            ...this.standardAttributes(),
+            "event.name": name,
+            "event.timestamp": new Date(this.now()).toISOString(),
+            "event.sequence": this.eventSequence,
+            ...(this.interaction ? { "prompt.id": this.interaction.promptId } : {}),
+            ...attrs,
+        };
+        try {
+            this.logger.emit({
+                eventName: `${PREFIX}.${name}`,
+                severityNumber: SeverityNumber.INFO,
+                severityText: "INFO",
+                body: `${PREFIX}.${name}`,
+                attributes: record,
+            });
+        }
+        catch {
+            // Logs are best-effort.
+        }
+    }
+    // ── Session ─────────────────────────────────────────────────────────────
+    sessionStart(sessionId) {
+        if (sessionId)
+            this.sessionId = sessionId;
+        if (!this.sessionCounted) {
+            this.sessionCounted = true;
+            this.add(METRIC_SESSION_COUNT, "1", "Count of CLI sessions started", 1);
+        }
+        this.idleSince = this.now();
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    // ── Interaction (one user prompt) ───────────────────────────────────────
+    interactionStart(prompt) {
+        if (this.interaction)
+            this.interactionEnd();
+        const now = this.now();
+        // User active time: the window since the agent last went idle, unless the
+        // user walked away (idle cutoff).
+        if (this.idleSince !== undefined) {
+            const gap = now - this.idleSince;
+            if (gap > 0 && gap <= USER_ACTIVE_IDLE_CUTOFF_MS) {
+                this.add(METRIC_ACTIVE_TIME, "s", "Total active time in seconds", gap / 1000, { type: "user" });
+            }
+            this.idleSince = undefined;
+        }
+        this.interactionSequence += 1;
+        const promptId = randomUUID();
+        const promptLength = typeof prompt === "string" ? prompt.length : 0;
+        // `invoke_agent` is the semconv operation for the root of an agent run.
+        // Without it Datadog files the trace as a generic workflow, flags an
+        // instrumentation issue on the span, and leaves it out of per-agent views.
+        const span = this.tracer.startSpan(SPAN_INTERACTION, {
+            attributes: {
+                ...this.spanAttributes(),
+                [ATTR_GEN_AI_OPERATION_NAME]: "invoke_agent",
+                user_prompt_length: promptLength,
+                "interaction.sequence": this.interactionSequence,
+                "prompt.id": promptId,
+            },
+        });
+        const ctx = trace.setSpan(otelContext.active(), span);
+        this.interaction = { span, ctx, startedAt: now, promptId };
+        this.emitEvent(EVENT_USER_PROMPT, { prompt_length: promptLength });
+    }
+    interactionEnd() {
+        if (!this.interaction)
+            return;
+        const now = this.now();
+        // Close stragglers: pi guarantees agent_end after its children, but an
+        // abort can leave a turn or tool open.
+        if (this.llm)
+            this.llmEnd(undefined);
+        for (const [id] of this.tools)
+            this.toolEnd(id, { isError: false, resultBytes: 0 });
+        if (this.turn)
+            this.turnEnd();
+        const elapsed = now - this.interaction.startedAt;
+        this.interaction.span.setAttribute("interaction.duration_ms", Math.max(0, Math.round(elapsed)));
+        this.interaction.span.end();
+        this.interaction = null;
+        this.decisions.clear();
+        this.add(METRIC_ACTIVE_TIME, "s", "Total active time in seconds", Math.max(0, elapsed) / 1000, { type: "cli" });
+        this.idleSince = now;
+    }
+    // ── Turn ────────────────────────────────────────────────────────────────
+    turnStart(turnIndex) {
+        if (!this.interaction)
+            return;
+        if (this.turn)
+            this.turnEnd();
+        const span = this.tracer.startSpan(SPAN_TURN, { attributes: { ...this.spanAttributes(), ...(typeof turnIndex === "number" ? { "turn.index": turnIndex } : {}) } }, this.interaction.ctx);
+        this.turn = { span, ctx: trace.setSpan(this.interaction.ctx, span), startedAt: this.now() };
+    }
+    turnEnd() {
+        if (!this.turn)
+            return;
+        this.turn.span.end();
+        this.turn = null;
+    }
+    // ── LLM request ─────────────────────────────────────────────────────────
+    parentCtx() {
+        return this.turn?.ctx ?? this.interaction?.ctx ?? otelContext.active();
+    }
+    llmStart(model) {
+        if (this.llm)
+            this.llmEnd(undefined);
+        const parent = this.parentCtx();
+        const clientRequestId = randomUUID();
+        const attrs = {
+            ...this.spanAttributes(),
+            [ATTR_GEN_AI_OPERATION_NAME]: "chat",
+            client_request_id: clientRequestId,
+            "llm_request.context": this.interaction ? "interaction" : "standalone",
+        };
+        if (model) {
+            attrs[ATTR_GEN_AI_REQUEST_MODEL] = model;
+            attrs.model = model;
+        }
+        const span = this.tracer.startSpan(SPAN_LLM_REQUEST, { attributes: attrs }, parent);
+        this.llm = {
+            span,
+            ctx: trace.setSpan(parent, span),
+            startedAt: this.now(),
+            clientRequestId,
+            ...(model ? { requestModel: model } : {}),
+        };
+    }
+    llmResponseHeaders(status, headers) {
+        if (!this.llm)
+            return;
+        if (typeof status === "number") {
+            this.llm.status = status;
+            this.llm.span.setAttribute(ATTR_HTTP_STATUS_CODE, status);
+        }
+        const h = headers ?? {};
+        const requestId = h["x-request-id"] ?? h["request-id"] ?? h["anthropic-request-id"] ?? h["openai-response-id"];
+        if (typeof requestId === "string" && requestId) {
+            this.llm.requestId = requestId;
+            this.llm.span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, requestId);
+            this.llm.span.setAttribute("request_id", requestId);
+        }
+    }
+    /**
+     * The assistant message ended: attach usage, emit api_request / api_error
+     * plus the token and cost counters, and close the LLM span. Opens a span
+     * first when pi delivered the message without a before_provider_request
+     * (e.g. a replayed or synthetic message) so nothing is lost.
+     */
+    assistantMessageEnd(message) {
+        if (!this.llm)
+            this.llmStart(message.model);
+        const slot = this.llm;
+        const now = this.now();
+        const durationMs = Math.max(0, Math.round(now - slot.startedAt));
+        const model = message.responseModel ?? message.model ?? slot.requestModel ?? "unknown";
+        const usage = message.usage ?? {};
+        const input = num(usage.input);
+        const output = num(usage.output);
+        const cacheRead = num(usage.cacheRead);
+        const cacheCreation = num(usage.cacheWrite);
+        // Claude Code always reports cost_usd (0 when it has nothing), so the flat
+        // attribute and the counter keep that shape. The vendor cost attribute is
+        // different: a 0 there renders as "$0" in cost views, so it is only set
+        // when pi actually priced the request.
+        const costKnown = typeof usage.cost === "number" || typeof usage.cost?.total === "number";
+        const cost = typeof usage.cost === "number" ? usage.cost : num(usage.cost?.total);
+        const stop = message.stopReason ?? "stop";
+        const isError = stop === "error";
+        const requestId = message.responseId ?? slot.requestId;
+        // pi's `input` excludes cached tokens (Anthropic semantics). The semconv
+        // `gen_ai.usage.input_tokens` includes them, with the cache counters as
+        // subsets; see attrs.ts. The flat Claude Code attributes below stay disjoint.
+        const inclusiveInput = input + cacheRead + cacheCreation;
+        const span = slot.span;
+        if (message.model)
+            span.setAttribute(ATTR_GEN_AI_REQUEST_MODEL, message.model);
+        span.setAttribute(ATTR_GEN_AI_RESPONSE_MODEL, model);
+        span.setAttribute("model", model);
+        span.setAttribute(ATTR_GEN_AI_INPUT_TOKENS, inclusiveInput);
+        span.setAttribute(ATTR_GEN_AI_OUTPUT_TOKENS, output);
+        span.setAttribute(ATTR_GEN_AI_TOTAL_TOKENS, inclusiveInput + output);
+        span.setAttribute(ATTR_GEN_AI_CACHE_READ_TOKENS, cacheRead);
+        span.setAttribute(ATTR_GEN_AI_CACHE_WRITE_TOKENS, cacheCreation);
+        span.setAttribute(ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY, cacheRead);
+        span.setAttribute(ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY, cacheCreation);
+        // Datadog ingests this attribute in nanodollars (its `ml_obs.span.llm.total.cost`
+        // unit); sending dollars renders a $0.012 call as 1.2e-9 cents. Verified against
+        // a live span on 2026-09-02. `cost_usd` below stays in dollars.
+        if (costKnown)
+            span.setAttribute(ATTR_GEN_AI_COST_ESTIMATED_TOTAL, Math.round(cost * 1_000_000_000));
+        span.setAttribute("input_tokens", input);
+        span.setAttribute("output_tokens", output);
+        span.setAttribute("cache_read_tokens", cacheRead);
+        span.setAttribute("cache_creation_tokens", cacheCreation);
+        span.setAttribute("cost_usd", cost);
+        span.setAttribute("duration_ms", durationMs);
+        span.setAttribute("stop_reason", stop);
+        span.setAttribute(ATTR_GEN_AI_FINISH_REASONS, [stop]);
+        span.setAttribute("success", isError ? "false" : "true");
+        span.setAttribute("response.has_tool_call", hasToolCall(message.content) ? "true" : "false");
+        if (requestId) {
+            span.setAttribute(ATTR_GEN_AI_RESPONSE_ID, requestId);
+            span.setAttribute("request_id", requestId);
+        }
+        const base = {
+            model,
+            duration_ms: durationMs,
+            client_request_id: slot.clientRequestId,
+            ...(requestId ? { request_id: requestId } : {}),
+        };
+        if (isError) {
+            // A short, single-line excerpt only: a provider error body can echo
+            // request content, and the contract is metadata-only. The status code
+            // and the leading words are what a dashboard needs.
+            const error = errorExcerpt(message.errorMessage);
+            span.setAttribute(ATTR_ERROR_TYPE, "api_error");
+            span.setAttribute("error", error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message: error });
+            this.emitEvent(EVENT_API_ERROR, {
+                ...base,
+                error,
+                attempt: 1,
+                ...(typeof slot.status === "number" ? { status_code: String(slot.status) } : {}),
+            });
+        }
+        else {
+            this.emitEvent(EVENT_API_REQUEST, {
+                ...base,
+                cost_usd: cost,
+                cost_usd_micros: Math.round(cost * 1_000_000),
+                input_tokens: input,
+                output_tokens: output,
+                cache_read_tokens: cacheRead,
+                cache_creation_tokens: cacheCreation,
+            });
+            this.emitEvent(EVENT_ASSISTANT_RESPONSE, {
+                model,
+                response_length: responseLength(message.content),
+                ...(requestId ? { request_id: requestId } : {}),
+            });
+        }
+        const tokenAttrs = (type) => ({ type, model });
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", input, tokenAttrs("input"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", output, tokenAttrs("output"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", cacheRead, tokenAttrs("cacheRead"));
+        this.add(METRIC_TOKEN_USAGE, "{token}", "Number of tokens used", cacheCreation, tokenAttrs("cacheCreation"));
+        this.add(METRIC_COST_USAGE, "USD", "Cost of the session", cost, { model });
+        this.llmEnd(undefined);
+    }
+    llmEnd(error) {
+        if (!this.llm)
+            return;
+        if (error) {
+            this.llm.span.setAttribute(ATTR_ERROR_TYPE, error.name || "Error");
+            this.llm.span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        }
+        this.llm.span.end();
+        this.llm = null;
+    }
+    // ── Tools ───────────────────────────────────────────────────────────────
+    toolDecision(input) {
+        const toolSource = input.toolName.startsWith("mcp__") ? "mcp" : "builtin";
+        // Only accepted calls go on to execute (and read this back in toolEnd);
+        // a rejected call never reaches tool_execution_end, so storing it would
+        // only leak.
+        if (input.toolCallId && input.decision === "accept") {
+            this.decisions.set(input.toolCallId, { decision: input.decision, source: input.source });
+        }
+        this.emitEvent(EVENT_TOOL_DECISION, {
+            tool_name: input.toolName,
+            ...(input.toolCallId ? { tool_use_id: input.toolCallId } : {}),
+            decision: input.decision,
+            source: input.source,
+            tool_source: toolSource,
+        });
+        if (EDIT_TOOLS.has(input.toolName)) {
+            const language = languageFromPath(input.filePath);
+            this.add(METRIC_CODE_EDIT_DECISION, "1", "Count of code editing tool permission decisions", 1, {
+                tool_name: input.toolName,
+                decision: input.decision,
+                source: input.source,
+                ...(language ? { language } : {}),
+            });
+        }
+    }
+    toolStart(toolCallId, toolName, args) {
+        if (this.tools.has(toolCallId))
+            return;
+        const parent = this.parentCtx();
+        const inputBytes = byteLength(args);
+        const attrs = {
+            ...this.spanAttributes(),
+            tool_name: toolName,
+            tool_use_id: toolCallId,
+            [ATTR_GEN_AI_TOOL_NAME]: toolName,
+            [ATTR_GEN_AI_TOOL_CALL_ID]: toolCallId,
+            [ATTR_GEN_AI_TOOL_TYPE]: toolName.startsWith("mcp__") ? "extension" : "function",
+            [ATTR_GEN_AI_OPERATION_NAME]: "execute_tool",
+            tool_input_size_bytes: inputBytes,
+        };
+        const span = this.tracer.startSpan(SPAN_TOOL, { attributes: attrs }, parent);
+        this.tools.set(toolCallId, { span, ctx: trace.setSpan(parent, span), startedAt: this.now(), name: toolName, inputBytes });
+    }
+    toolEnd(toolCallId, outcome) {
+        const slot = this.tools.get(toolCallId);
+        if (!slot)
+            return;
+        const durationMs = Math.max(0, Math.round(this.now() - slot.startedAt));
+        slot.span.setAttribute("duration_ms", durationMs);
+        slot.span.setAttribute("success", outcome.isError ? "false" : "true");
+        slot.span.setAttribute("tool_result_size_bytes", outcome.resultBytes);
+        if (outcome.isError) {
+            slot.span.setAttribute(ATTR_ERROR_TYPE, outcome.errorType ?? "tool_error");
+            slot.span.setStatus({ code: SpanStatusCode.ERROR });
+        }
+        slot.span.end();
+        this.tools.delete(toolCallId);
+        const decision = this.decisions.get(toolCallId);
+        this.decisions.delete(toolCallId);
+        this.emitEvent(EVENT_TOOL_RESULT, {
+            tool_name: slot.name,
+            tool_use_id: toolCallId,
+            success: outcome.isError ? "false" : "true",
+            duration_ms: durationMs,
+            tool_input_size_bytes: slot.inputBytes,
+            tool_result_size_bytes: outcome.resultBytes,
+            decision_type: "accept",
+            decision_source: decision?.source ?? "config",
+            ...(outcome.isError ? { error_type: outcome.errorType ?? "tool_error" } : {}),
+        });
+    }
+    /** Lines added/removed by an edit or write, from pi's tool_result details. */
+    linesOfCode(added, removed) {
+        this.add(METRIC_LINES_OF_CODE, "1", "Count of lines of code modified", added, { type: "added" });
+        this.add(METRIC_LINES_OF_CODE, "1", "Count of lines of code modified", removed, { type: "removed" });
+    }
+    /** A successful bash command: count commits and PR creations. */
+    bashSucceeded(command) {
+        if (typeof command !== "string")
+            return;
+        if (GIT_COMMIT_RE.test(command))
+            this.add(METRIC_COMMIT_COUNT, "1", "Count of git commits created", 1);
+        if (GH_PR_CREATE_RE.test(command))
+            this.add(METRIC_PULL_REQUEST_COUNT, "1", "Count of pull requests created", 1);
+    }
+    // ── Mode ────────────────────────────────────────────────────────────────
+    permissionModeChanged(fromMode, toMode) {
+        this.emitEvent(EVENT_PERMISSION_MODE_CHANGED, { from_mode: fromMode, to_mode: toMode });
+    }
+    // ── Shutdown ────────────────────────────────────────────────────────────
+    /** Close everything still open so no span is lost at exit. */
+    close() {
+        this.interactionEnd();
+        if (this.llm)
+            this.llmEnd(undefined);
+        for (const [id] of this.tools)
+            this.toolEnd(id, { isError: false, resultBytes: 0 });
+        if (this.turn)
+            this.turnEnd();
+    }
+}
+/** Cap on the exported error excerpt (characters, one line). */
+export const ERROR_EXCERPT_CHARS = 120;
+/** First line of a provider error, capped, never the full body. */
+export function errorExcerpt(message) {
+    const firstLine = (message ?? "").split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!firstLine)
+        return "LLM request failed";
+    return firstLine.length > ERROR_EXCERPT_CHARS ? `${firstLine.slice(0, ERROR_EXCERPT_CHARS)}…` : firstLine;
+}
+function num(v) {
+    return typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0;
+}
+function hasToolCall(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((p) => p && typeof p === "object" && p.type === "toolCall");
+}
+function responseLength(content) {
+    if (typeof content === "string")
+        return content.length;
+    if (!Array.isArray(content))
+        return 0;
+    let n = 0;
+    for (const p of content) {
+        if (p && typeof p === "object" && p.type === "text") {
+            const t = p.text;
+            if (typeof t === "string")
+                n += t.length;
+        }
+    }
+    return n;
+}
+export function byteLength(v) {
+    if (v === undefined || v === null)
+        return 0;
+    if (typeof v === "string")
+        return Buffer.byteLength(v, "utf8");
+    try {
+        return Buffer.byteLength(JSON.stringify(v) ?? "", "utf8");
+    }
+    catch {
+        return 0;
+    }
+}
+/** Count +/- lines in a unified patch, ignoring file headers. */
+export function countPatchLines(patch) {
+    let added = 0;
+    let removed = 0;
+    if (typeof patch !== "string")
+        return { added, removed };
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            added += 1;
+        else if (line.startsWith("-"))
+            removed += 1;
+    }
+    return { added, removed };
+}
+/** Line count of freshly written content (a write tool call). */
+export function countContentLines(content) {
+    if (typeof content !== "string" || content.length === 0)
+        return 0;
+    const n = content.split("\n").length;
+    return content.endsWith("\n") ? n - 1 : n;
+}
+//# sourceMappingURL=tracker.js.map

package/dist/extension/vendor/IGNORE-LICENSE-MIT

@@ -0,0 +1,21 @@
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/dist/extension/vendor/ignore.d.ts

@@ -0,0 +1,86 @@
+// VENDORED TYPES — copy of the npm `ignore` package v7.0.5 index.d.ts
+// (https://github.com/kaelzhang/node-ignore), MIT license. The upstream file
+// ends with `export = ignore` (CJS); this copy ends with an ESM default
+// export matching the ESM-converted ignore.js alongside.
+
+type Pathname = string
+
+interface IgnoreRule {
+  pattern: string
+  mark?: string
+  negative: boolean
+}
+
+interface TestResult {
+  ignored: boolean
+  unignored: boolean
+  rule?: IgnoreRule
+}
+
+interface PatternParams {
+  pattern: string
+  mark?: string
+}
+
+interface Ignore {
+  /**
+   * Adds one or several rules to the current manager.
+   * @param  {string[]} patterns
+   * @returns IgnoreBase
+   */
+  add(
+    patterns: string | Ignore | readonly (string | Ignore)[] | PatternParams
+  ): this
+
+  /**
+   * Filters the given array of pathnames, and returns the filtered array.
+   * NOTICE that each path here should be a relative path to the root of your repository.
+   * @param paths the array of paths to be filtered.
+   * @returns The filtered array of paths
+   */
+  filter(pathnames: readonly Pathname[]): Pathname[]
+
+  /**
+   * Creates a filter function which could filter
+   * an array of paths with Array.prototype.filter.
+   */
+  createFilter(): (pathname: Pathname) => boolean
+
+  /**
+   * Returns Boolean whether pathname should be ignored.
+   * @param  {string} pathname a path to check
+   * @returns boolean
+   */
+  ignores(pathname: Pathname): boolean
+
+  /**
+   * Returns whether pathname should be ignored or unignored
+   * @param  {string} pathname a path to check
+   * @returns TestResult
+   */
+  test(pathname: Pathname): TestResult
+
+  /**
+   * Debugs ignore rules and returns the checking result, which is
+   *   equivalent to `git check-ignore -v`.
+   * @returns TestResult
+   */
+  checkIgnore(pathname: Pathname): TestResult
+}
+
+interface Options {
+  ignorecase?: boolean
+  // For compatibility
+  ignoreCase?: boolean
+  allowRelativePaths?: boolean
+}
+
+/**
+ * Creates new ignore manager.
+ */
+declare function ignore(options?: Options): Ignore
+
+declare const isPathValid: (pathname: string) => boolean
+
+export { isPathValid }
+export default ignore