opencode-metrics-plugin 0.1.5

package/dist/metrics-handlers.js

@@ -0,0 +1,648 @@
+import { createTokenUsage } from "./metrics-types.js";
+import { parseHvigorwOutput } from "./compile-analyzer.js";
+// ─── Input Simplification ────────────────────────────────────────────────────
+function simplifyInput(raw) {
+    if (!raw)
+        return {};
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+// ─── Invalid Tool Detection ──────────────────────────────────────────────────
+function isInvalidTool(part) {
+    if (part.tool === "invalid")
+        return true;
+    const state = part.state;
+    if (state?.title === "Invalid Tool")
+        return true;
+    const input = state?.input;
+    if (input?.error !== undefined)
+        return true;
+    return false;
+}
+// ─── Stage Detection (skill-based) ─────────────────────────────────────────
+function handleStageDetection(state, part, now) {
+    const tool = part.tool;
+    const toolState = part.state;
+    const status = toolState?.status;
+    const parentMsgId = part.messageID || "";
+    // Track skill calls
+    if (tool === "skill" && status === "completed") {
+        const skillName = toolState?.input?.name || "";
+        const callID = part.callID;
+        if (skillName && callID) {
+            state.skillCallMap.set(callID, { skillName, parentMsgId, status: "completed" });
+        }
+        const isDevSkill = skillName === "harmonyos-atomic-dev" || skillName === "harmonyos-dev" || skillName === "harmonyos-dev4app";
+        const isBuildSkill = skillName === "harmonyos-hvigor";
+        if (isDevSkill && !state.htmlPreviewMsgId) {
+            // harmonyos dev skills → start dev phase (standard mode only, no html_preview)
+            transitionStage(state, "dev", now);
+        }
+        else if (isBuildSkill) {
+            // harmonyos-hvigor skill → start build phase
+            transitionStage(state, "build", now);
+        }
+        else if (!state.currentStage) {
+            // First non-dev/build skill → start design phase
+            transitionStage(state, "design", now);
+        }
+    }
+    // html_preview tool → end design, start dev (plugin mode)
+    if (tool === "html_preview" && (status === "completed" || status === "running") && !state.htmlPreviewMsgId) {
+        state.htmlPreviewMsgId = parentMsgId;
+        transitionStage(state, "dev", now);
+    }
+}
+function transitionStage(state, newStage, now) {
+    if (state.currentStage) {
+        state.currentStage.endTime = now;
+        state.currentStage.tokens = { ...state._stageTokens };
+        if (state.currentStage.stage === "build") {
+            state.currentStage.hvigorwCalls = state.compileStats.hvigorwCalls;
+        }
+        state.stages.push(state.currentStage);
+    }
+    state.lastStageEndTime = now;
+    state._stageTokens = createTokenUsage();
+    state.currentStage = {
+        stage: newStage,
+        startTime: now,
+        endTime: 0,
+        hvigorwCalls: 0,
+        tokens: createTokenUsage(),
+    };
+}
+// ─── Handler Functions ───────────────────────────────────────────────────────
+function handlePartUpdated(state, props) {
+    const part = props.part;
+    if (!part)
+        return;
+    // New activity — allow next session.idle to create a round
+    state._roundIdleProcessed = false;
+    state._idleFlushed = false;
+    const partType = part.type;
+    // Tool metrics
+    if (partType === "tool") {
+        const status = part.state?.status;
+        const callID = part.callID;
+        const parentMsgId = part.messageID || "";
+        const toolState = part.state;
+        // Dedup: check existing entry before updating (only when callID is present)
+        const existingEntry = callID ? state.toolCallMap.get(callID) : undefined;
+        const alreadyRunning = callID && existingEntry?.status === "running";
+        const alreadyCompleted = callID && existingEntry?.status === "completed";
+        const alreadyError = callID && existingEntry?.status === "error";
+        if (status === "running") {
+            const rawInput = toolState?.input;
+            state.toolCallMap.set(callID, {
+                callID,
+                tool: part.tool || "unknown",
+                status: "running",
+                input: simplifyInput(rawInput),
+                outputPreview: "",
+                startMs: toolState?.time?.start || 0,
+                endMs: 0,
+                parentMsgId,
+            });
+        }
+        if (status === "completed" || status === "error") {
+            const tc = existingEntry || {
+                callID,
+                tool: part.tool || "unknown",
+                status,
+                input: {},
+                outputPreview: "",
+                startMs: 0,
+                endMs: 0,
+                parentMsgId,
+            };
+            tc.status = status;
+            tc.endMs = toolState?.time?.end || 0;
+            if (!tc.startMs)
+                tc.startMs = toolState?.time?.start || 0;
+            // Truncate output to 500 chars
+            const output = toolState?.output || toolState?.raw || "";
+            tc.outputPreview = typeof output === "string" ? output.slice(0, 500) : "";
+            // Update input if available
+            if (toolState?.input && Object.keys(toolState.input).length > 0) {
+                Object.assign(tc.input, simplifyInput(toolState.input));
+            }
+            state.toolCallMap.set(callID, tc);
+        }
+        if (status === "running" && !alreadyRunning) {
+            if (isInvalidTool(part)) {
+                state.tools.invalidCalls++;
+            }
+            else {
+                state.tools.totalCalls++;
+                state._roundToolCalls++;
+            }
+        }
+        if (status === "completed" && !alreadyCompleted) {
+            state.tools.completedCalls++;
+            const toolName = part.tool || "unknown";
+            const time = toolState?.time;
+            const duration = time && time.start && time.end
+                ? (time.end - time.start)
+                : 0;
+            // Update distribution
+            const stats = state.tools.distribution.get(toolName) ?? { calls: 0, errors: 0, totalDuration: 0, maxDuration: 0 };
+            stats.calls++;
+            stats.totalDuration += duration;
+            if (duration > stats.maxDuration)
+                stats.maxDuration = duration;
+            state.tools.distribution.set(toolName, stats);
+            // Update slowest call
+            if (duration > state.tools.slowestCall.duration) {
+                state.tools.slowestCall = { tool: toolName, duration };
+            }
+        }
+        if (status === "error" && !alreadyError) {
+            state.tools.errorCalls++;
+            state._roundErrors++;
+            const toolName = part.tool || "unknown";
+            const stats = state.tools.distribution.get(toolName) ?? { calls: 0, errors: 0, totalDuration: 0, maxDuration: 0 };
+            stats.errors++;
+            state.tools.distribution.set(toolName, stats);
+        }
+        // Compile stats extraction (with dedup)
+        if (part.tool === "bash") {
+            const command = state.toolCallMap.get(callID)?.input?.command || "";
+            if (command.includes("hvigorw")) {
+                if (status === "completed" && !alreadyCompleted) {
+                    state.compileStats.hvigorwCalls++;
+                    const output = toolState?.output || "";
+                    const result = parseHvigorwOutput(output);
+                    state.compileStats.lastBuildSuccess = result.success;
+                    // First build per round
+                    if (!state._roundFirstBuildTracked) {
+                        state.compileStats.firstBuildPerRound.push(result.success);
+                        state._roundFirstBuildTracked = true;
+                    }
+                    // Error codes
+                    for (const err of result.errors) {
+                        const existing = state.compileStats.errorCodes.get(err.code);
+                        if (existing) {
+                            existing.count++;
+                        }
+                        else {
+                            state.compileStats.errorCodes.set(err.code, {
+                                count: 1, type: err.type, message: err.message,
+                            });
+                        }
+                    }
+                    // Warnings
+                    for (const warn of result.warnings) {
+                        const existing = state.compileStats.warnings.get(warn.type);
+                        if (existing) {
+                            existing.count++;
+                            existing.entries.push(warn);
+                        }
+                        else {
+                            state.compileStats.warnings.set(warn.type, {
+                                count: 1, entries: [warn],
+                            });
+                        }
+                    }
+                    // Module timings
+                    for (const [module, timing] of result.moduleTimings) {
+                        const existing = state.compileStats.moduleTimings.get(module);
+                        if (existing) {
+                            existing.totalDuration += timing.totalDuration;
+                            existing.taskCount += timing.taskCount;
+                            if (timing.slowestTask.duration > existing.slowestTask.duration) {
+                                existing.slowestTask = timing.slowestTask;
+                            }
+                        }
+                        else {
+                            state.compileStats.moduleTimings.set(module, { ...timing });
+                        }
+                    }
+                    // Fix cycle tracking
+                    if (!result.success) {
+                        if (state.compileStats._pendingFix) {
+                            state.compileStats._pendingFix.attempts++;
+                        }
+                        else {
+                            state.compileStats._pendingFix = {
+                                failTime: Date.now(), attempts: 1, codeChanges: 0,
+                            };
+                        }
+                        state.compileStats.hvigorwErrors++;
+                    }
+                    else {
+                        if (state.compileStats._pendingFix) {
+                            state.compileStats.fixCycles.push({
+                                failTime: state.compileStats._pendingFix.failTime,
+                                successTime: Date.now(),
+                                attempts: state.compileStats._pendingFix.attempts,
+                                codeChanges: state.compileStats._pendingFix.codeChanges,
+                            });
+                            state.compileStats._pendingFix = null;
+                        }
+                    }
+                }
+                if (status === "error" && !alreadyError) {
+                    state.compileStats.hvigorwErrors++;
+                }
+            }
+        }
+        if (part.tool === "write" && !alreadyCompleted) {
+            const entry = state.toolCallMap.get(callID);
+            const filePath = entry?.input?.filePath || entry?.input?.path || "";
+            if (filePath.endsWith(".ets") && status === "completed") {
+                const content = entry?.input?.content;
+                if (content) {
+                    state.compileStats.etsLines += content.split("\n").filter(l => l.length > 0).length;
+                }
+            }
+        }
+        // Fix cycle: count code changes
+        if ((part.tool === "write" || part.tool === "edit") && status === "completed") {
+            if (state.compileStats._pendingFix) {
+                state.compileStats._pendingFix.codeChanges++;
+            }
+        }
+        // ─── Planning (todowrite) tracking ──────────────────────────────────────
+        const toolNameForPlanning = part.tool || "";
+        if (toolNameForPlanning === "todowrite" && status === "completed" && !alreadyCompleted) {
+            const time = toolState?.time;
+            const startTime = time?.start || 0;
+            const endTime = time?.end || 0;
+            // Extract todos from metadata.todos (completed) or state.input.todos (fallback)
+            const metadata = part.metadata;
+            const rawTodos = metadata?.todos
+                || toolState?.input?.todos
+                || [];
+            const todos = rawTodos.map(t => ({
+                content: t.content || "",
+                status: t.status || "pending",
+                priority: t.priority || "medium",
+            }));
+            // Skip empty todowrite calls (no-op planning rounds)
+            if (todos.length === 0)
+                return;
+            state.planningCalls.push({
+                callID,
+                startTime,
+                endTime,
+                durationMs: endTime > startTime ? endTime - startTime : 0,
+                todos,
+            });
+        }
+        // ─── SkillSearch tracking ──────────────────────────────────────────────
+        const toolName = part.tool || "";
+        if (toolName === "skillSearch" && callID) {
+            if (status === "running" && !alreadyRunning) {
+                const rawInput = toolState?.input;
+                state.skillSearchMap.set(callID, {
+                    callID,
+                    skillPath: rawInput?.skill_path || "",
+                    query: rawInput?.query || "",
+                    topK: rawInput?.topK || 3,
+                    output: "",
+                    startMs: toolState?.time?.start || 0,
+                    endMs: 0,
+                    followUpReads: [],
+                });
+            }
+            if (status === "completed" && !alreadyCompleted) {
+                let entry = state.skillSearchMap.get(callID);
+                if (!entry) {
+                    const rawInput = toolState?.input;
+                    entry = {
+                        callID,
+                        skillPath: rawInput?.skill_path || "",
+                        query: rawInput?.query || "",
+                        topK: rawInput?.topK || 3,
+                        output: "",
+                        startMs: toolState?.time?.start || 0,
+                        endMs: 0,
+                        followUpReads: [],
+                    };
+                    state.skillSearchMap.set(callID, entry);
+                }
+                entry.output = toolState?.output || "";
+                entry.endMs = toolState?.time?.end || 0;
+                if (!entry.startMs) {
+                    entry.startMs = toolState?.time?.start || 0;
+                }
+                state._pendingReadChain = { searchCallID: callID };
+            }
+            if (status === "error" && !alreadyError) {
+                let entry = state.skillSearchMap.get(callID);
+                if (!entry) {
+                    const rawInput = toolState?.input;
+                    entry = {
+                        callID,
+                        skillPath: rawInput?.skill_path || "",
+                        query: rawInput?.query || "",
+                        topK: rawInput?.topK || 3,
+                        output: "",
+                        startMs: toolState?.time?.start || 0,
+                        endMs: 0,
+                        followUpReads: [],
+                    };
+                    state.skillSearchMap.set(callID, entry);
+                }
+                entry.endMs = toolState?.time?.end || 0;
+                state._pendingReadChain = null;
+            }
+        }
+        // Follow-up read chain: track read calls immediately after skillSearch
+        if (toolName === "read" && status === "completed" && !alreadyCompleted && state._pendingReadChain) {
+            const entry = state.skillSearchMap.get(state._pendingReadChain.searchCallID);
+            if (entry) {
+                const readEntry = state.toolCallMap.get(callID);
+                const filePath = readEntry?.input?.filePath || readEntry?.input?.path || "";
+                entry.followUpReads.push({ filePath, callID });
+            }
+        }
+        else if (toolName !== "skillSearch" && toolName !== "read" && state._pendingReadChain) {
+            state._pendingReadChain = null;
+        }
+        // Stage detection on tool calls
+        handleStageDetection(state, part, Date.now());
+    }
+    // Step-finish — extract tokens
+    if (partType === "step-finish") {
+        const tokens = part.tokens;
+        if (tokens) {
+            const cache = tokens.cache || {};
+            const input = tokens.input || 0;
+            const output = tokens.output || 0;
+            const reasoning = tokens.reasoning || 0;
+            const cacheRead = cache.read || 0;
+            const cacheWrite = cache.write || 0;
+            const total = tokens.total || 0;
+            // Accumulate to session totals
+            state.tokens.input += input;
+            state.tokens.output += output;
+            state.tokens.reasoning += reasoning;
+            state.tokens.cacheRead += cacheRead;
+            state.tokens.cacheWrite += cacheWrite;
+            state.tokens.total += total;
+            // Accumulate to per-round tokens
+            state._roundTokens.input += input;
+            state._roundTokens.output += output;
+            state._roundTokens.reasoning += reasoning;
+            state._roundTokens.cacheRead += cacheRead;
+            state._roundTokens.cacheWrite += cacheWrite;
+            state._roundTokens.total += total;
+            // Accumulate to current stage tokens
+            state._stageTokens.input += input;
+            state._stageTokens.output += output;
+            state._stageTokens.reasoning += reasoning;
+            state._stageTokens.cacheRead += cacheRead;
+            state._stageTokens.cacheWrite += cacheWrite;
+            state._stageTokens.total += total;
+            // Track model token distribution
+            if (state.model.current) {
+                const modelTokens = state.model.tokenDistribution.get(state.model.current) ?? createTokenUsage();
+                modelTokens.input += input;
+                modelTokens.output += output;
+                modelTokens.reasoning += reasoning;
+                modelTokens.cacheRead += cacheRead;
+                modelTokens.cacheWrite += cacheWrite;
+                modelTokens.total += total;
+                state.model.tokenDistribution.set(state.model.current, modelTokens);
+            }
+        }
+    }
+    // Text part — track first token latency
+    if (partType === "text" && !state._hasTextPart) {
+        state._hasTextPart = true;
+        state._firstTextTime = Date.now();
+    }
+    // Accumulate text length
+    if (partType === "text") {
+        const msgId = part.messageID;
+        const text = part.text;
+        if (msgId && text) {
+            state.textLengthMap.set(msgId, (state.textLengthMap.get(msgId) || 0) + text.length);
+            // Capture user message text for round snapshot
+            if (state._userMessageIds.has(msgId)) {
+                state._pendingUserMessage.push(text);
+            }
+        }
+    }
+}
+function handleSessionUpdated(state, props) {
+    const info = props.info;
+    if (!info)
+        return;
+    // Agent attribution
+    const agent = info.agent;
+    if (agent && agent !== state.agent.current) {
+        if (state.agent.current) {
+            // Finalize previous agent usage
+            const elapsed = Date.now() - state.agent.lastSwitchTime;
+            const prev = state.agent.usage.get(state.agent.current) ?? 0;
+            state.agent.usage.set(state.agent.current, prev + elapsed);
+        }
+        state.agent.current = agent;
+        state.agent.switches++;
+        state.agent.lastSwitchTime = Date.now();
+    }
+    // Model attribution
+    const model = info.model;
+    const modelId = model?.id;
+    if (modelId && modelId !== state.model.current) {
+        state.model.current = modelId;
+        state.model.switches++;
+    }
+    // Update sessionMeta
+    if (agent)
+        state.sessionMeta.agent = agent;
+    if (modelId)
+        state.sessionMeta.model = modelId;
+    // Extract working directory
+    const directory = info.directory;
+    if (directory)
+        state.sessionMeta.workingDirectory = directory;
+}
+function handleMessageUpdated(state, props) {
+    const info = props.info;
+    if (!info)
+        return;
+    // Track user message IDs so we can capture their text from message.part.updated
+    if (info.role === "user") {
+        const msgId = info.id;
+        if (msgId)
+            state._userMessageIds.add(msgId);
+        state._roundIdleProcessed = false;
+        return;
+    }
+    if (info.role !== "assistant")
+        return;
+    const msgId = info.id;
+    if (!msgId)
+        return;
+    const existing = state.messageMap.get(msgId);
+    const tokens = info.tokens;
+    const cache = tokens?.cache || {};
+    const newTokens = {
+        input: tokens?.input || 0,
+        output: tokens?.output || 0,
+        reasoning: tokens?.reasoning || 0,
+        cacheRead: cache.read || 0,
+        cacheWrite: cache.write || 0,
+        total: tokens?.total || 0,
+    };
+    const time = info.time;
+    const finish = info.finish || "";
+    // Prefer entries with finish + completed time
+    if (!existing || (finish && time?.completed)) {
+        state.messageMap.set(msgId, {
+            msgId,
+            tokens: newTokens.total > 0 ? newTokens : (existing?.tokens || newTokens),
+            cost: info.cost || existing?.cost || 0,
+            startTime: time?.created || existing?.startTime || 0,
+            endTime: time?.completed || existing?.endTime || 0,
+            finish: finish || existing?.finish || "",
+            order: existing?.order ?? state.orderCounter++,
+        });
+    }
+    else if (newTokens.total > (existing?.tokens.total || 0)) {
+        existing.tokens = newTokens;
+    }
+}
+function handleSubAgentParts(sub, event) {
+    const props = event.properties;
+    if (!props)
+        return;
+    if (event.type === "message.part.updated") {
+        const part = props.part;
+        if (!part)
+            return;
+        const partType = part.type;
+        const msgId = part.messageID || "";
+        // Text → update textLengthMap
+        if (partType === "text" && msgId) {
+            const text = part.text || "";
+            if (text) {
+                sub.textLengthMap.set(msgId, (sub.textLengthMap.get(msgId) || 0) + text.length);
+                if (sub._userMessageIds.has(msgId)) {
+                    sub._pendingUserMessage.push(text);
+                }
+            }
+        }
+        // Tool → write to toolCallMap
+        if (partType === "tool") {
+            const callID = part.callID;
+            const toolState = part.state;
+            const status = toolState?.status;
+            const parentMsgId = msgId;
+            if (status === "running" && callID) {
+                const rawInput = toolState?.input;
+                sub.toolCallMap.set(callID, {
+                    callID,
+                    tool: part.tool || "unknown",
+                    status: "running",
+                    input: simplifyInput(rawInput),
+                    outputPreview: "",
+                    startMs: toolState?.time?.start || 0,
+                    endMs: 0,
+                    parentMsgId,
+                });
+            }
+            if ((status === "completed" || status === "error") && callID) {
+                const existing = sub.toolCallMap.get(callID);
+                const tc = existing || {
+                    callID,
+                    tool: part.tool || "unknown",
+                    status,
+                    input: {},
+                    outputPreview: "",
+                    startMs: 0,
+                    endMs: 0,
+                    parentMsgId,
+                };
+                tc.status = status;
+                tc.endMs = toolState?.time?.end || 0;
+                if (!tc.startMs)
+                    tc.startMs = toolState?.time?.start || 0;
+                const output = toolState?.output || toolState?.raw || "";
+                tc.outputPreview = typeof output === "string" ? output.slice(0, 500) : "";
+                if (toolState?.input && Object.keys(toolState.input).length > 0) {
+                    Object.assign(tc.input, simplifyInput(toolState.input));
+                }
+                sub.toolCallMap.set(callID, tc);
+            }
+        }
+        // Step-finish → create/update messageMap entry with tokens
+        if (partType === "step-finish" && msgId) {
+            const tokens = part.tokens;
+            if (tokens) {
+                const cache = tokens.cache || {};
+                const newTokens = {
+                    input: tokens.input || 0,
+                    output: tokens.output || 0,
+                    reasoning: tokens.reasoning || 0,
+                    cacheRead: cache.read || 0,
+                    cacheWrite: cache.write || 0,
+                    total: tokens.total || 0,
+                };
+                const existing = sub.messageMap.get(msgId);
+                sub.messageMap.set(msgId, {
+                    msgId,
+                    tokens: newTokens,
+                    cost: existing?.cost || 0,
+                    startTime: existing?.startTime || 0,
+                    endTime: existing?.endTime || 0,
+                    finish: existing?.finish || "",
+                    order: existing?.order ?? sub.orderCounter++,
+                });
+            }
+        }
+    }
+    // message.updated → update finish/tokens/cost on messageMap entry
+    if (event.type === "message.updated") {
+        const info = props.info;
+        if (!info)
+            return;
+        if (info.role === "user") {
+            const msgId = info.id;
+            if (msgId)
+                sub._userMessageIds.add(msgId);
+            return;
+        }
+        if (info.role !== "assistant")
+            return;
+        const msgId = info.id;
+        if (!msgId)
+            return;
+        const existing = sub.messageMap.get(msgId);
+        const tokens = info.tokens;
+        const cache = tokens?.cache || {};
+        const newTokens = {
+            input: tokens?.input || 0,
+            output: tokens?.output || 0,
+            reasoning: tokens?.reasoning || 0,
+            cacheRead: cache.read || 0,
+            cacheWrite: cache.write || 0,
+            total: tokens?.total || 0,
+        };
+        const time = info.time;
+        const finish = info.finish || "";
+        if (!existing || (finish && time?.completed)) {
+            sub.messageMap.set(msgId, {
+                msgId,
+                tokens: newTokens.total > 0 ? newTokens : (existing?.tokens || newTokens),
+                cost: info.cost || existing?.cost || 0,
+                startTime: time?.created || existing?.startTime || 0,
+                endTime: time?.completed || existing?.endTime || 0,
+                finish: finish || existing?.finish || "",
+                order: existing?.order ?? sub.orderCounter++,
+            });
+        }
+        else if (newTokens.total > (existing?.tokens.total || 0)) {
+            existing.tokens = newTokens;
+        }
+    }
+}
+export { handlePartUpdated, handleSessionUpdated, handleMessageUpdated, handleSubAgentParts };

package/dist/metrics-output.d.ts

@@ -0,0 +1,11 @@
+import type { MetricsDirs } from "./dirs.js";
+import type { SessionMetricsState, MetricsOutput } from "./metrics-types.js";
+declare function flushMetrics(sessionId: string, state: SessionMetricsState, now: number, dirs?: Partial<MetricsDirs>): MetricsOutput;
+declare function handleSessionIdle(state: SessionMetricsState, sessionId: string, dirs?: Partial<MetricsDirs>): MetricsOutput | undefined;
+declare function mergeChildMetrics(parent: SessionMetricsState, child: SessionMetricsState, meta: {
+    childId: string;
+    agentName: string;
+    title: string;
+}): void;
+export declare function mergeMetricsOutput(existing: MetricsOutput | null, fresh: MetricsOutput): MetricsOutput;
+export { flushMetrics, handleSessionIdle, mergeChildMetrics };