@narumitw/pi-analytics 0.49.9 → 0.49.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/analytics.ts CHANGED
@@ -1,10 +1,6 @@
1
1
  import { randomUUID } from "node:crypto";
2
2
  import path from "node:path";
3
- import {
4
- type ExtensionAPI,
5
- type ExtensionContext,
6
- getAgentDir,
7
- } from "@earendil-works/pi-coding-agent";
3
+ import { type ExtensionAPI, type ExtensionContext, getAgentDir } from "@earendil-works/pi-coding-agent";
8
4
  import { ResponseCollector } from "./collector.js";
9
5
  import { type AnalyticsMenuDataSource, showAnalyticsMenu } from "./menu.js";
10
6
  import { SkillTracker } from "./skills.js";
@@ -13,385 +9,399 @@ import type { AnalyticsSnapshot, TimeRange } from "./storage/queries.js";
13
9
  import { AnalyticsStore } from "./storage/store.js";
14
10
  import type { ModelIdentity, SettledRun, TriggerSource } from "./types.js";
15
11
 
12
+ interface PendingProviderGeneration {
13
+ id: string;
14
+ startedAtMs: number;
15
+ model?: ModelIdentity;
16
+ responses: Array<{ status: number; occurredAtMs: number }>;
17
+ }
18
+
16
19
  const STORAGE_DIRECTORY = "pi-analytics";
17
20
 
18
21
  export interface AnalyticsStorePort {
19
- readonly path: string;
20
- recordRun(run: SettledRun, signal?: AbortSignal): Promise<void>;
21
- getSnapshot(range: TimeRange, signal?: AbortSignal): Promise<AnalyticsSnapshot>;
22
- clearAll(signal?: AbortSignal): Promise<ClearAnalyticsResult>;
23
- close(): Promise<void>;
22
+ readonly path: string;
23
+ recordRun(run: SettledRun, signal?: AbortSignal): Promise<void>;
24
+ getSnapshot(range: TimeRange, signal?: AbortSignal): Promise<AnalyticsSnapshot>;
25
+ clearAll(signal?: AbortSignal): Promise<ClearAnalyticsResult>;
26
+ close(): Promise<void>;
24
27
  }
25
28
 
26
29
  interface AnalyticsDependencies {
27
- createStore(path: string): AnalyticsStorePort;
28
- createSkillTracker(cwd: string): SkillTracker;
29
- getAgentDir(): string;
30
- now(): number;
31
- createId(): string;
30
+ createStore(path: string): AnalyticsStorePort;
31
+ createSkillTracker(cwd: string): SkillTracker;
32
+ getAgentDir(): string;
33
+ now(): number;
34
+ createId(): string;
32
35
  }
33
36
 
34
37
  export function createAnalyticsExtension(
35
- dependencies: Partial<AnalyticsDependencies> = {},
38
+ dependencies: Partial<AnalyticsDependencies> = {},
36
39
  ): (pi: ExtensionAPI) => void {
37
- const deps: AnalyticsDependencies = {
38
- createStore: dependencies.createStore ?? ((rootPath) => new AnalyticsStore(rootPath)),
39
- createSkillTracker: dependencies.createSkillTracker ?? ((cwd) => new SkillTracker(cwd)),
40
- getAgentDir: dependencies.getAgentDir ?? getAgentDir,
41
- now: dependencies.now ?? Date.now,
42
- createId: dependencies.createId ?? randomUUID,
43
- };
44
-
45
- return function analyticsExtension(pi: ExtensionAPI): void {
46
- let sessionGeneration = 0;
47
- let sessionController = new AbortController();
48
- let collector = new ResponseCollector();
49
- let skillTracker: SkillTracker | undefined;
50
- let store: AnalyticsStorePort | undefined;
51
- let storageFailure: string | undefined;
52
- const retiredCloseTasks = new Set<Promise<boolean>>();
53
- let writeFailureActive = false;
54
- let pendingTriggerSource: TriggerSource = "unknown";
55
- let pendingAttemptWithoutRun = false;
56
-
57
- pi.registerCommand("analytics", {
58
- description: "Open local Pi usage analytics",
59
- handler: async (args, ctx) => {
60
- if (args.trim()) {
61
- if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
62
- throw new Error("/analytics does not accept arguments.");
63
- }
64
- ctx.ui.notify("/analytics does not accept arguments.", "warning");
65
- return;
66
- }
67
- if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
68
- throw new Error("/analytics requires Pi TUI or RPC mode.");
69
- }
70
- const generation = sessionGeneration;
71
- const owner = sessionController;
72
- const source = menuSource(generation, owner.signal);
73
- await showAnalyticsMenu(ctx, source, {
74
- signal: owner.signal,
75
- isCurrent: () => generation === sessionGeneration && !owner.signal.aborted,
76
- });
77
- },
78
- });
79
-
80
- pi.on("session_start", (_event, ctx) => {
81
- ++sessionGeneration;
82
- const previousStore = store;
83
- sessionController.abort(new DOMException("Analytics session replaced", "AbortError"));
84
- if (previousStore) retire(previousStore);
85
- sessionController = new AbortController();
86
- collector = new ResponseCollector();
87
- skillTracker = deps.createSkillTracker(ctx.cwd);
88
- store = undefined;
89
- storageFailure = undefined;
90
- writeFailureActive = false;
91
- pendingTriggerSource = "unknown";
92
- pendingAttemptWithoutRun = false;
93
- const storageRoot = path.join(deps.getAgentDir(), STORAGE_DIRECTORY);
94
- try {
95
- store = deps.createStore(storageRoot);
96
- } catch {
97
- storageFailure = unavailableMessage();
98
- safeNotify(ctx, storageFailure, "warning");
99
- }
100
- });
101
-
102
- pi.on("input", (event, ctx) => {
103
- const now = deps.now();
104
- const tracker = skillTracker;
105
- tracker?.observeInput(event.text, event.source, now);
106
- if (event.source !== "extension") pendingTriggerSource = event.source;
107
- if (!tracker || !collector.hasActiveRun()) return;
108
- const explicit = tracker.consumeExplicitSkill();
109
- if (!explicit || !tracker.hasAvailableSkill(explicit.name)) return;
110
- collector.activateSkill({
111
- name: explicit.name,
112
- initiatedBy: "user",
113
- now: explicit.observedAtMs,
114
- model: modelIdentity(ctx, pi),
115
- });
116
- });
117
-
118
- pi.on("before_agent_start", async (event, ctx) => {
119
- const generation = sessionGeneration;
120
- const tracker = skillTracker;
121
- const activeCollector = collector;
122
- if (!tracker) return;
123
- const skills = availableSkills(pi, event.systemPromptOptions.skills ?? []);
124
- await tracker.setAvailableSkills(skills);
125
- if (
126
- generation !== sessionGeneration ||
127
- tracker !== skillTracker ||
128
- activeCollector !== collector
129
- ) {
130
- return;
131
- }
132
- const explicit = tracker.consumeExplicitSkill();
133
- const interrupted = activeCollector.begin({
134
- id: deps.createId(),
135
- now: deps.now(),
136
- triggerSource: explicit?.source ?? pendingTriggerSource,
137
- model: modelIdentity(ctx, pi),
138
- });
139
- pendingTriggerSource = "unknown";
140
- if (interrupted) {
141
- await persistRun(interrupted, ctx, generation, sessionController.signal);
142
- if (
143
- generation !== sessionGeneration ||
144
- tracker !== skillTracker ||
145
- activeCollector !== collector
146
- ) {
147
- return;
148
- }
149
- }
150
- if (explicit && skills.some(({ name }) => name === explicit.name)) {
151
- activeCollector.activateSkill({
152
- name: explicit.name,
153
- initiatedBy: "user",
154
- now: explicit.observedAtMs,
155
- model: modelIdentity(ctx, pi),
156
- });
157
- }
158
- });
159
-
160
- pi.on("agent_start", () => {
161
- if (collector.hasActiveRun()) collector.beginAttempt();
162
- else pendingAttemptWithoutRun = true;
163
- });
164
-
165
- pi.on("turn_start", (_event, ctx) => ensureRun(ctx, "extension"));
166
-
167
- pi.on("before_provider_request", (_event, ctx) => {
168
- ensureRun(ctx, "extension");
169
- collector.beginGeneration({
170
- id: deps.createId(),
171
- now: deps.now(),
172
- model: modelIdentity(ctx, pi),
173
- });
174
- });
175
-
176
- pi.on("after_provider_response", (event) => {
177
- collector.recordProviderResponse({ status: event.status, now: deps.now() });
178
- });
179
-
180
- pi.on("message_end", (event) => {
181
- if (event.message.role !== "assistant") return;
182
- collector.finishGeneration({
183
- now: deps.now(),
184
- stopReason: event.message.stopReason,
185
- errorMessage: event.message.errorMessage,
186
- });
187
- });
188
-
189
- pi.on("tool_execution_start", (event, ctx) => {
190
- ensureRun(ctx, "extension");
191
- collector.beginTool({
192
- id: event.toolCallId,
193
- name: event.toolName,
194
- now: deps.now(),
195
- model: modelIdentity(ctx, pi),
196
- });
197
- });
198
-
199
- pi.on("tool_result", async (event, ctx) => {
200
- if (event.toolName === "read" && !isBuiltinReadTool(pi)) return;
201
- const generation = sessionGeneration;
202
- const tracker = skillTracker;
203
- const activeCollector = collector;
204
- const runId = activeCollector.getActiveRunId();
205
- if (!tracker || !runId) return;
206
- const name = await tracker.matchSuccessfulRead({
207
- toolName: event.toolName,
208
- input: event.input,
209
- isError: event.isError,
210
- });
211
- if (
212
- !name ||
213
- generation !== sessionGeneration ||
214
- tracker !== skillTracker ||
215
- activeCollector !== collector ||
216
- activeCollector.getActiveRunId() !== runId
217
- ) {
218
- return;
219
- }
220
- activeCollector.activateSkill({
221
- name,
222
- initiatedBy: "model",
223
- now: deps.now(),
224
- model: modelIdentity(ctx, pi),
225
- });
226
- });
227
-
228
- pi.on("tool_execution_end", (event) => {
229
- collector.finishTool({ id: event.toolCallId, now: deps.now(), isError: event.isError });
230
- });
231
-
232
- pi.on("agent_settled", async (_event, ctx) => {
233
- const generation = sessionGeneration;
234
- const owner = sessionController;
235
- const run = collector.settle(deps.now());
236
- pendingAttemptWithoutRun = false;
237
- pendingTriggerSource = "unknown";
238
- skillTracker?.clearPending();
239
- if (run) await persistRun(run, ctx, generation, owner.signal);
240
- });
241
-
242
- pi.on("session_shutdown", async (_event, ctx) => {
243
- const activeStore = store;
244
- ++sessionGeneration;
245
- sessionController.abort(new DOMException("Analytics session shut down", "AbortError"));
246
- skillTracker?.clearPending();
247
- skillTracker = undefined;
248
- store = undefined;
249
- collector.interrupt(deps.now());
250
- const closing = activeStore
251
- ? [closeResult(activeStore), ...retiredCloseTasks]
252
- : [...retiredCloseTasks];
253
- const results = await Promise.all(closing);
254
- if (results.some((closed) => !closed)) {
255
- safeNotify(ctx, "Analytics storage shutdown was incomplete.", "warning");
256
- }
257
- });
258
-
259
- function retire(retiredStore: AnalyticsStorePort): void {
260
- const task = closeResult(retiredStore).finally(() => retiredCloseTasks.delete(task));
261
- retiredCloseTasks.add(task);
262
- }
263
-
264
- async function closeResult(activeStore: AnalyticsStorePort): Promise<boolean> {
265
- try {
266
- await activeStore.close();
267
- return true;
268
- } catch {
269
- return false;
270
- }
271
- }
272
-
273
- function ensureRun(ctx: ExtensionContext, triggerSource: TriggerSource): void {
274
- if (collector.hasActiveRun()) return;
275
- collector.begin({
276
- id: deps.createId(),
277
- now: deps.now(),
278
- triggerSource,
279
- model: modelIdentity(ctx, pi),
280
- });
281
- if (pendingAttemptWithoutRun) {
282
- pendingAttemptWithoutRun = false;
283
- collector.beginAttempt();
284
- }
285
- }
286
-
287
- async function persistRun(
288
- run: SettledRun,
289
- ctx: ExtensionContext,
290
- generation: number,
291
- signal: AbortSignal,
292
- ): Promise<void> {
293
- const activeStore = store;
294
- if (!activeStore || signal.aborted) return;
295
- try {
296
- await activeStore.recordRun(run, signal);
297
- if (generation !== sessionGeneration || activeStore !== store || signal.aborted) return;
298
- if (writeFailureActive) {
299
- writeFailureActive = false;
300
- safeNotify(ctx, "Local analytics storage recovered.", "info");
301
- }
302
- } catch {
303
- if (
304
- generation !== sessionGeneration ||
305
- activeStore !== store ||
306
- signal.aborted ||
307
- writeFailureActive
308
- ) {
309
- return;
310
- }
311
- writeFailureActive = true;
312
- safeNotify(
313
- ctx,
314
- "Analytics could not save this response cycle; its metrics were dropped.",
315
- "warning",
316
- );
317
- }
318
- }
319
-
320
- function menuSource(generation: number, signal: AbortSignal): AnalyticsMenuDataSource {
321
- return {
322
- path: store?.path ?? path.join(deps.getAgentDir(), STORAGE_DIRECTORY),
323
- async load(range, actionSignal) {
324
- assertCurrent(generation, signal);
325
- const activeStore = store;
326
- if (!activeStore) {
327
- return { kind: "unavailable", message: storageFailure ?? unavailableMessage() };
328
- }
329
- const snapshot = await activeStore.getSnapshot(range, actionSignal);
330
- assertCurrent(generation, signal);
331
- return { kind: "ready", snapshot };
332
- },
333
- async clearAll(actionSignal) {
334
- assertCurrent(generation, signal);
335
- const activeStore = store;
336
- if (!activeStore) return { cleanupIncomplete: false };
337
- return activeStore.clearAll(actionSignal);
338
- },
339
- };
340
- }
341
-
342
- function assertCurrent(generation: number, signal: AbortSignal): void {
343
- if (generation !== sessionGeneration || signal.aborted) {
344
- throw new DOMException("Analytics interaction replaced", "AbortError");
345
- }
346
- }
347
- };
40
+ const deps: AnalyticsDependencies = {
41
+ createStore: dependencies.createStore ?? ((rootPath) => new AnalyticsStore(rootPath)),
42
+ createSkillTracker: dependencies.createSkillTracker ?? ((cwd) => new SkillTracker(cwd)),
43
+ getAgentDir: dependencies.getAgentDir ?? getAgentDir,
44
+ now: dependencies.now ?? Date.now,
45
+ createId: dependencies.createId ?? randomUUID,
46
+ };
47
+
48
+ return function analyticsExtension(pi: ExtensionAPI): void {
49
+ let sessionGeneration = 0;
50
+ let sessionController = new AbortController();
51
+ let collector = new ResponseCollector();
52
+ let skillTracker: SkillTracker | undefined;
53
+ let store: AnalyticsStorePort | undefined;
54
+ let storageFailure: string | undefined;
55
+ const retiredCloseTasks = new Set<Promise<boolean>>();
56
+ let writeFailureActive = false;
57
+ let pendingTriggerSource: TriggerSource = "unknown";
58
+ let pendingAttemptWithoutRun = false;
59
+ let pendingProviderGeneration: PendingProviderGeneration | undefined;
60
+
61
+ pi.registerCommand("analytics", {
62
+ description: "Open local Pi usage analytics",
63
+ handler: async (args, ctx) => {
64
+ if (args.trim()) {
65
+ if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
66
+ throw new Error("/analytics does not accept arguments.");
67
+ }
68
+ ctx.ui.notify("/analytics does not accept arguments.", "warning");
69
+ return;
70
+ }
71
+ if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
72
+ throw new Error("/analytics requires Pi TUI or RPC mode.");
73
+ }
74
+ const generation = sessionGeneration;
75
+ const owner = sessionController;
76
+ const source = menuSource(generation, owner.signal);
77
+ await showAnalyticsMenu(ctx, source, {
78
+ signal: owner.signal,
79
+ isCurrent: () => generation === sessionGeneration && !owner.signal.aborted,
80
+ });
81
+ },
82
+ });
83
+
84
+ pi.on("session_start", (_event, ctx) => {
85
+ ++sessionGeneration;
86
+ const previousStore = store;
87
+ sessionController.abort(new DOMException("Analytics session replaced", "AbortError"));
88
+ if (previousStore) retire(previousStore);
89
+ sessionController = new AbortController();
90
+ collector = new ResponseCollector();
91
+ skillTracker = deps.createSkillTracker(ctx.cwd);
92
+ store = undefined;
93
+ storageFailure = undefined;
94
+ writeFailureActive = false;
95
+ pendingTriggerSource = "unknown";
96
+ pendingAttemptWithoutRun = false;
97
+ pendingProviderGeneration = undefined;
98
+ const storageRoot = path.join(deps.getAgentDir(), STORAGE_DIRECTORY);
99
+ try {
100
+ store = deps.createStore(storageRoot);
101
+ } catch {
102
+ storageFailure = unavailableMessage();
103
+ safeNotify(ctx, storageFailure, "warning");
104
+ }
105
+ });
106
+
107
+ pi.on("input", (event, ctx) => {
108
+ const now = deps.now();
109
+ const tracker = skillTracker;
110
+ tracker?.observeInput(event.text, event.source, now);
111
+ if (event.source !== "extension") pendingTriggerSource = event.source;
112
+ if (!tracker || !collector.hasActiveRun()) return;
113
+ const explicit = tracker.consumeExplicitSkill();
114
+ if (!explicit || !tracker.hasAvailableSkill(explicit.name)) return;
115
+ collector.activateSkill({
116
+ name: explicit.name,
117
+ initiatedBy: "user",
118
+ now: explicit.observedAtMs,
119
+ model: modelIdentity(ctx, pi),
120
+ });
121
+ });
122
+
123
+ pi.on("before_agent_start", async (event, ctx) => {
124
+ // A cache warm has provider hooks but no assistant lifecycle. Drop any unclaimed
125
+ // warm metadata when the next real agent run begins instead of classifying by timing.
126
+ pendingProviderGeneration = undefined;
127
+ const generation = sessionGeneration;
128
+ const tracker = skillTracker;
129
+ const activeCollector = collector;
130
+ if (!tracker) return;
131
+ const skills = availableSkills(pi, event.systemPromptOptions.skills ?? []);
132
+ await tracker.setAvailableSkills(skills);
133
+ if (generation !== sessionGeneration || tracker !== skillTracker || activeCollector !== collector) {
134
+ return;
135
+ }
136
+ const explicit = tracker.consumeExplicitSkill();
137
+ const interrupted = activeCollector.begin({
138
+ id: deps.createId(),
139
+ now: deps.now(),
140
+ triggerSource: explicit?.source ?? pendingTriggerSource,
141
+ model: modelIdentity(ctx, pi),
142
+ });
143
+ pendingTriggerSource = "unknown";
144
+ if (interrupted) {
145
+ await persistRun(interrupted, ctx, generation, sessionController.signal);
146
+ if (generation !== sessionGeneration || tracker !== skillTracker || activeCollector !== collector) {
147
+ return;
148
+ }
149
+ }
150
+ if (explicit && skills.some(({ name }) => name === explicit.name)) {
151
+ activeCollector.activateSkill({
152
+ name: explicit.name,
153
+ initiatedBy: "user",
154
+ now: explicit.observedAtMs,
155
+ model: modelIdentity(ctx, pi),
156
+ });
157
+ }
158
+ });
159
+
160
+ pi.on("agent_start", () => {
161
+ if (collector.hasActiveRun()) collector.beginAttempt();
162
+ else pendingAttemptWithoutRun = true;
163
+ });
164
+
165
+ pi.on("turn_start", (_event, ctx) => ensureRun(ctx, "extension"));
166
+
167
+ pi.on("before_provider_request", (_event, ctx) => {
168
+ pendingProviderGeneration = {
169
+ id: deps.createId(),
170
+ startedAtMs: deps.now(),
171
+ model: modelIdentity(ctx, pi),
172
+ responses: [],
173
+ };
174
+ });
175
+
176
+ pi.on("after_provider_response", (event) => {
177
+ pendingProviderGeneration?.responses.push({ status: event.status, occurredAtMs: deps.now() });
178
+ });
179
+
180
+ pi.on("message_start", (event, ctx) => {
181
+ if (event.message.role === "assistant") claimPendingProviderGeneration(ctx);
182
+ });
183
+
184
+ pi.on("message_end", (event, ctx) => {
185
+ if (event.message.role !== "assistant") return;
186
+ claimPendingProviderGeneration(ctx);
187
+ collector.finishGeneration({
188
+ now: deps.now(),
189
+ stopReason: event.message.stopReason,
190
+ errorMessage: event.message.errorMessage,
191
+ });
192
+ });
193
+
194
+ pi.on("tool_execution_start", (event, ctx) => {
195
+ ensureRun(ctx, "extension");
196
+ collector.beginTool({
197
+ id: event.toolCallId,
198
+ name: event.toolName,
199
+ now: deps.now(),
200
+ model: modelIdentity(ctx, pi),
201
+ });
202
+ });
203
+
204
+ pi.on("tool_result", async (event, ctx) => {
205
+ if (event.toolName === "read" && !isBuiltinReadTool(pi)) return;
206
+ const generation = sessionGeneration;
207
+ const tracker = skillTracker;
208
+ const activeCollector = collector;
209
+ const runId = activeCollector.getActiveRunId();
210
+ if (!tracker || !runId) return;
211
+ const name = await tracker.matchSuccessfulRead({
212
+ toolName: event.toolName,
213
+ input: event.input,
214
+ isError: event.isError,
215
+ });
216
+ if (
217
+ !name ||
218
+ generation !== sessionGeneration ||
219
+ tracker !== skillTracker ||
220
+ activeCollector !== collector ||
221
+ activeCollector.getActiveRunId() !== runId
222
+ ) {
223
+ return;
224
+ }
225
+ activeCollector.activateSkill({
226
+ name,
227
+ initiatedBy: "model",
228
+ now: deps.now(),
229
+ model: modelIdentity(ctx, pi),
230
+ });
231
+ });
232
+
233
+ pi.on("tool_execution_end", (event) => {
234
+ collector.finishTool({ id: event.toolCallId, now: deps.now(), isError: event.isError });
235
+ });
236
+
237
+ pi.on("agent_settled", async (_event, ctx) => {
238
+ const generation = sessionGeneration;
239
+ const owner = sessionController;
240
+ const run = collector.settle(deps.now());
241
+ pendingAttemptWithoutRun = false;
242
+ pendingProviderGeneration = undefined;
243
+ pendingTriggerSource = "unknown";
244
+ skillTracker?.clearPending();
245
+ if (run) await persistRun(run, ctx, generation, owner.signal);
246
+ });
247
+
248
+ pi.on("session_shutdown", async (_event, ctx) => {
249
+ const activeStore = store;
250
+ ++sessionGeneration;
251
+ sessionController.abort(new DOMException("Analytics session shut down", "AbortError"));
252
+ skillTracker?.clearPending();
253
+ skillTracker = undefined;
254
+ store = undefined;
255
+ pendingProviderGeneration = undefined;
256
+ collector.interrupt(deps.now());
257
+ const closing = activeStore ? [closeResult(activeStore), ...retiredCloseTasks] : [...retiredCloseTasks];
258
+ const results = await Promise.all(closing);
259
+ if (results.some((closed) => !closed)) {
260
+ safeNotify(ctx, "Analytics storage shutdown was incomplete.", "warning");
261
+ }
262
+ });
263
+
264
+ function retire(retiredStore: AnalyticsStorePort): void {
265
+ const task = closeResult(retiredStore).finally(() => retiredCloseTasks.delete(task));
266
+ retiredCloseTasks.add(task);
267
+ }
268
+
269
+ async function closeResult(activeStore: AnalyticsStorePort): Promise<boolean> {
270
+ try {
271
+ await activeStore.close();
272
+ return true;
273
+ } catch {
274
+ return false;
275
+ }
276
+ }
277
+
278
+ function claimPendingProviderGeneration(ctx: ExtensionContext): void {
279
+ const pending = pendingProviderGeneration;
280
+ if (!pending) return;
281
+ pendingProviderGeneration = undefined;
282
+ ensureRun(ctx, "extension");
283
+ collector.beginGeneration({
284
+ id: pending.id,
285
+ now: pending.startedAtMs,
286
+ model: pending.model,
287
+ });
288
+ for (const response of pending.responses) {
289
+ collector.recordProviderResponse({ status: response.status, now: response.occurredAtMs });
290
+ }
291
+ }
292
+
293
+ function ensureRun(ctx: ExtensionContext, triggerSource: TriggerSource): void {
294
+ if (collector.hasActiveRun()) return;
295
+ collector.begin({
296
+ id: deps.createId(),
297
+ now: deps.now(),
298
+ triggerSource,
299
+ model: modelIdentity(ctx, pi),
300
+ });
301
+ if (pendingAttemptWithoutRun) {
302
+ pendingAttemptWithoutRun = false;
303
+ collector.beginAttempt();
304
+ }
305
+ }
306
+
307
+ async function persistRun(
308
+ run: SettledRun,
309
+ ctx: ExtensionContext,
310
+ generation: number,
311
+ signal: AbortSignal,
312
+ ): Promise<void> {
313
+ const activeStore = store;
314
+ if (!activeStore || signal.aborted) return;
315
+ try {
316
+ await activeStore.recordRun(run, signal);
317
+ if (generation !== sessionGeneration || activeStore !== store || signal.aborted) return;
318
+ if (writeFailureActive) {
319
+ writeFailureActive = false;
320
+ safeNotify(ctx, "Local analytics storage recovered.", "info");
321
+ }
322
+ } catch {
323
+ if (generation !== sessionGeneration || activeStore !== store || signal.aborted || writeFailureActive) {
324
+ return;
325
+ }
326
+ writeFailureActive = true;
327
+ safeNotify(ctx, "Analytics could not save this response cycle; its metrics were dropped.", "warning");
328
+ }
329
+ }
330
+
331
+ function menuSource(generation: number, signal: AbortSignal): AnalyticsMenuDataSource {
332
+ return {
333
+ path: store?.path ?? path.join(deps.getAgentDir(), STORAGE_DIRECTORY),
334
+ async load(range, actionSignal) {
335
+ assertCurrent(generation, signal);
336
+ const activeStore = store;
337
+ if (!activeStore) {
338
+ return { kind: "unavailable", message: storageFailure ?? unavailableMessage() };
339
+ }
340
+ const snapshot = await activeStore.getSnapshot(range, actionSignal);
341
+ assertCurrent(generation, signal);
342
+ return { kind: "ready", snapshot };
343
+ },
344
+ async clearAll(actionSignal) {
345
+ assertCurrent(generation, signal);
346
+ const activeStore = store;
347
+ if (!activeStore) return { cleanupIncomplete: false };
348
+ return activeStore.clearAll(actionSignal);
349
+ },
350
+ };
351
+ }
352
+
353
+ function assertCurrent(generation: number, signal: AbortSignal): void {
354
+ if (generation !== sessionGeneration || signal.aborted) {
355
+ throw new DOMException("Analytics interaction replaced", "AbortError");
356
+ }
357
+ }
358
+ };
348
359
  }
349
360
 
350
361
  function modelIdentity(ctx: ExtensionContext, pi: ExtensionAPI): ModelIdentity | undefined {
351
- if (!ctx.model) return undefined;
352
- return {
353
- provider: ctx.model.provider,
354
- model: ctx.model.id,
355
- thinkingLevel: pi.getThinkingLevel(),
356
- };
362
+ if (!ctx.model) return undefined;
363
+ return {
364
+ provider: ctx.model.provider,
365
+ model: ctx.model.id,
366
+ thinkingLevel: pi.getThinkingLevel(),
367
+ };
357
368
  }
358
369
 
359
370
  export function isBuiltinReadTool(pi: ExtensionAPI): boolean {
360
- const read = pi.getAllTools().find(({ name }) => name === "read");
361
- return read?.sourceInfo.source === "builtin";
371
+ const read = pi.getAllTools().find(({ name }) => name === "read");
372
+ return read?.sourceInfo.source === "builtin";
362
373
  }
363
374
 
364
375
  function availableSkills(
365
- pi: ExtensionAPI,
366
- systemSkills: ReadonlyArray<{ name: string; filePath: string }>,
376
+ pi: ExtensionAPI,
377
+ systemSkills: ReadonlyArray<{ name: string; filePath: string }>,
367
378
  ): Array<{ name: string; filePath: string }> {
368
- const result = [...systemSkills];
369
- const seen = new Set(result.map(({ name }) => name));
370
- const getCommands = (pi as ExtensionAPI & { getCommands?: ExtensionAPI["getCommands"] })
371
- .getCommands;
372
- for (const command of typeof getCommands === "function" ? getCommands.call(pi) : []) {
373
- if (command.source !== "skill" || seen.has(command.name.replace(/^skill:/u, ""))) continue;
374
- const name = command.name.replace(/^skill:/u, "");
375
- seen.add(name);
376
- result.push({ name, filePath: command.sourceInfo.path });
377
- }
378
- return result;
379
+ const result = [...systemSkills];
380
+ const seen = new Set(result.map(({ name }) => name));
381
+ const getCommands = (pi as ExtensionAPI & { getCommands?: ExtensionAPI["getCommands"] }).getCommands;
382
+ for (const command of typeof getCommands === "function" ? getCommands.call(pi) : []) {
383
+ if (command.source !== "skill" || seen.has(command.name.replace(/^skill:/u, ""))) continue;
384
+ const name = command.name.replace(/^skill:/u, "");
385
+ seen.add(name);
386
+ result.push({ name, filePath: command.sourceInfo.path });
387
+ }
388
+ return result;
379
389
  }
380
390
 
381
391
  function unavailableMessage(): string {
382
- return [
383
- "Local analytics storage could not be initialized safely.",
384
- "Existing files were not replaced.",
385
- "No analytics are being collected.",
386
- ].join("\n");
392
+ return [
393
+ "Local analytics storage could not be initialized safely.",
394
+ "Existing files were not replaced.",
395
+ "No analytics are being collected.",
396
+ ].join("\n");
387
397
  }
388
398
 
389
399
  function safeNotify(ctx: ExtensionContext, message: string, level: "info" | "warning"): void {
390
- try {
391
- ctx.ui.notify(message, level);
392
- } catch {
393
- // A replaced Pi context cannot receive lifecycle feedback.
394
- }
400
+ try {
401
+ ctx.ui.notify(message, level);
402
+ } catch {
403
+ // A replaced Pi context cannot receive lifecycle feedback.
404
+ }
395
405
  }
396
406
 
397
407
  export default createAnalyticsExtension();