opencode-metrics-plugin 0.1.5

package/dist/metrics-steps.js

@@ -0,0 +1,90 @@
+import * as fs from "fs";
+import * as path from "path";
+import { getEventsDir } from "./dirs.js";
+function buildSteps(maps, contentMaps) {
+    const sorted = [...maps.messageMap.values()]
+        .filter(m => m.finish && m.tokens.total > 0)
+        .sort((a, b) => a.order - b.order);
+    return sorted.map((msg, idx) => {
+        const tools = [...maps.toolCallMap.values()]
+            .filter(tc => tc.parentMsgId === msg.msgId && tc.status !== "running")
+            .map(tc => ({
+            tool: tc.tool,
+            callID: tc.callID,
+            status: tc.status,
+            input: tc.input,
+            output: contentMaps?.toolOutputMap.get(tc.callID) ?? tc.outputPreview,
+            durationMs: tc.endMs && tc.startMs ? tc.endMs - tc.startMs : 0,
+        }));
+        return {
+            index: idx,
+            startTime: msg.startTime,
+            endTime: msg.endTime,
+            durationMs: msg.endTime && msg.startTime ? msg.endTime - msg.startTime : 0,
+            tokens: msg.tokens,
+            cost: msg.cost,
+            tools,
+            textLength: maps.textLengthMap.get(msg.msgId) || 0,
+            text: contentMaps?.textMap.get(msg.msgId) || "",
+            reasoning: contentMaps?.reasoningMap.get(msg.msgId) || "",
+        };
+    });
+}
+function extractStepContent(sessionId, opts) {
+    const textMap = new Map();
+    const reasoningMap = new Map();
+    const toolOutputMap = new Map();
+    const filterMsgIds = opts?.filterMsgIds;
+    try {
+        const filePath = path.join(opts?.eventsDir ?? getEventsDir(), `${sessionId}.log`);
+        const content = fs.readFileSync(filePath, "utf-8");
+        // Split by [timestamp] prefix (zero-width lookahead)
+        const blocks = content.split(/^(?=\[\d{4}-\d{2}-\d{2} )/m);
+        for (const block of blocks) {
+            const dataIdx = block.indexOf("  DATA: ");
+            if (dataIdx < 0)
+                continue;
+            const jsonStr = block.slice(dataIdx + 8);
+            if (!jsonStr.trim())
+                continue;
+            try {
+                const event = JSON.parse(jsonStr);
+                const props = event;
+                const part = props.part;
+                if (!part)
+                    continue;
+                const partType = part.type;
+                const msgId = part.messageID;
+                if (partType === "text" && msgId) {
+                    if (filterMsgIds && !filterMsgIds.has(msgId))
+                        continue;
+                    const text = part.text || "";
+                    textMap.set(msgId, (textMap.get(msgId) || "") + text);
+                }
+                if (partType === "reasoning" && msgId) {
+                    if (filterMsgIds && !filterMsgIds.has(msgId))
+                        continue;
+                    const text = part.text || "";
+                    reasoningMap.set(msgId, (reasoningMap.get(msgId) || "") + text);
+                }
+                if (partType === "tool") {
+                    const callID = part.callID;
+                    const toolState = part.state;
+                    const status = toolState?.status;
+                    if (callID && (status === "completed" || status === "error")) {
+                        const output = toolState?.output || toolState?.raw || "";
+                        toolOutputMap.set(callID, output);
+                    }
+                }
+            }
+            catch {
+                // Skip unparseable blocks
+            }
+        }
+    }
+    catch {
+        // File doesn't exist or read error 鈥?return empty maps
+    }
+    return { textMap, reasoningMap, toolOutputMap };
+}
+export { buildSteps, extractStepContent };

package/dist/metrics-types.d.ts

@@ -0,0 +1,381 @@
+export declare const TRACKED_EVENT_TYPES: Set<string>;
+export interface TokenUsage {
+    input: number;
+    output: number;
+    reasoning: number;
+    cacheRead: number;
+    cacheWrite: number;
+    total: number;
+}
+export interface ToolStats {
+    calls: number;
+    errors: number;
+    totalDuration: number;
+    maxDuration: number;
+}
+export type StageType = "design" | "dev" | "build";
+export interface StageInfo {
+    stage: StageType;
+    startTime: number;
+    endTime: number;
+    hvigorwCalls: number;
+    tokens: TokenUsage;
+}
+export interface MessageEntry {
+    msgId: string;
+    tokens: TokenUsage;
+    cost: number;
+    startTime: number;
+    endTime: number;
+    finish: string;
+    order: number;
+}
+export interface ToolCallEntry {
+    callID: string;
+    tool: string;
+    status: "running" | "completed" | "error";
+    input: Record<string, unknown>;
+    outputPreview: string;
+    startMs: number;
+    endMs: number;
+    parentMsgId: string;
+}
+export interface SessionMeta {
+    sessionId: string;
+    workingDirectory: string;
+    startTime: string;
+    model: string;
+    agent: string;
+    agentSwitches: number;
+    agentUsage: Record<string, number>;
+    modelSwitches: number;
+    modelTokenDistribution: Record<string, TokenUsage>;
+    /** opencode session.title（实时事件不产出，采集/回填场景可选填充） */
+    title?: string;
+}
+export interface FixCycle {
+    failTime: number;
+    successTime: number;
+    attempts: number;
+    codeChanges: number;
+}
+export interface PendingFix {
+    failTime: number;
+    attempts: number;
+    codeChanges: number;
+}
+export interface WarningInfo {
+    count: number;
+    entries: Array<{
+        type: string;
+        message: string;
+        file?: string;
+        line?: number;
+    }>;
+}
+export interface ModuleTimingInfo {
+    totalDuration: number;
+    taskCount: number;
+    slowestTask: {
+        name: string;
+        duration: number;
+    };
+}
+export interface CompileStats {
+    hvigorwCalls: number;
+    hvigorwErrors: number;
+    lastBuildSuccess: boolean;
+    etsLines: number;
+    firstBuildPerRound: boolean[];
+    errorCodes: Map<string, {
+        count: number;
+        type: string;
+        message: string;
+    }>;
+    fixCycles: FixCycle[];
+    _pendingFix: PendingFix | null;
+    warnings: Map<string, WarningInfo>;
+    moduleTimings: Map<string, ModuleTimingInfo>;
+}
+export interface SkillCallEntry {
+    skillName: string;
+    parentMsgId: string;
+    status: string;
+}
+export interface TodoSnapshot {
+    content: string;
+    status: string;
+    priority: string;
+}
+export interface PlanningCall {
+    callID: string;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    todos: TodoSnapshot[];
+}
+export interface PlanningMetrics {
+    planningRounds: number;
+    totalPlanningDuration: number;
+    avgPlanningDuration: number;
+    totalTasks: number;
+    completedTasks: number;
+    inProgressTasks: number;
+    pendingTasks: number;
+    completionRate: number;
+    priorityDistribution: Record<string, number>;
+    calls: PlanningCall[];
+}
+export interface SkillSearchEntry {
+    callID: string;
+    skillPath: string;
+    query: string;
+    topK: number;
+    output: string;
+    startMs: number;
+    endMs: number;
+    followUpReads: Array<{
+        filePath: string;
+        callID: string;
+    }>;
+}
+export interface StepData {
+    index: number;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    tokens: TokenUsage;
+    cost: number;
+    tools: Array<{
+        tool: string;
+        callID: string;
+        status: string;
+        input: Record<string, unknown>;
+        output: string;
+        durationMs: number;
+    }>;
+    textLength: number;
+    text: string;
+    reasoning: string;
+}
+export interface RoundSnapshot {
+    roundIndex: number;
+    duration: number;
+    firstTokenLatency: number;
+    tokens: TokenUsage;
+    toolCalls: number;
+    errors: number;
+    userMessage?: string[];
+}
+export interface SubAgentOutput {
+    sessionId: string;
+    agent: string;
+    title: string;
+    steps: StepData[];
+    tokens: TokenUsage;
+    tools: {
+        totalCalls: number;
+        invalidCalls: number;
+        successRate: number;
+        distribution: Record<string, {
+            calls: number;
+            errors: number;
+            avgDuration: number;
+            maxDuration: number;
+        }>;
+        slowestCall: {
+            tool: string;
+            duration: number;
+        };
+    };
+    userMessages?: string[];
+}
+export interface MetricsOutput {
+    sessionId: string;
+    /** 快照来源标记：live 进程写入 / opencode.db 回填生成（force 重建仅保护 live 源）。 */
+    source?: "live" | "backfill";
+    startTime: number;
+    endTime: number;
+    duration: number;
+    systemPrompts: Record<string, string[]>;
+    rounds: RoundSnapshot[];
+    tokens: TokenUsage & {
+        cacheHitRate: number;
+        avgTokensPerStep: number;
+    };
+    tools: {
+        totalCalls: number;
+        invalidCalls: number;
+        successRate: number;
+        distribution: Record<string, {
+            calls: number;
+            errors: number;
+            avgDuration: number;
+            maxDuration: number;
+        }>;
+        slowestCall: {
+            tool: string;
+            duration: number;
+        };
+    };
+    compactions: number;
+    anomaly: {
+        triggered: boolean;
+        events: string[];
+    };
+    stages: Array<{
+        stage: StageType;
+        duration: number;
+        hvigorwCalls: number;
+        tokens: TokenUsage;
+    }>;
+    header: SessionMeta;
+    codeStats: {
+        etsLines: number;
+        buildSuccess: boolean;
+        fixCompileCount: number;
+        totalCompileErrors: number;
+        firstBuildPerRound: boolean[];
+        firstBuildPassRate: number;
+        errorCodes: Array<{
+            code: string;
+            count: number;
+            type: string;
+            message: string;
+        }>;
+        warnings: {
+            total: number;
+            byType: Record<string, number>;
+            entries: Array<{
+                type: string;
+                message: string;
+                file?: string;
+                line?: number;
+            }>;
+        };
+        fixCycles: {
+            successRate: number;
+            avgAttempts: number;
+            cycles: Array<{
+                success: boolean;
+                attempts: number;
+                codeChanges: number;
+                durationMs: number;
+            }>;
+        };
+        moduleTimings: Array<{
+            module: string;
+            totalDurationMs: number;
+            taskCount: number;
+            slowestTask: {
+                name: string;
+                duration: number;
+            };
+        }>;
+    };
+    responseLength: number;
+    skills: Array<{
+        skillName: string;
+        status: string;
+    }>;
+    skillSearches: Array<{
+        query: string;
+        skillPath: string;
+        topK: number;
+        output: string;
+        durationMs: number;
+        followUpReads: string[];
+    }>;
+    steps: StepData[];
+    subagents: SubAgentOutput[];
+    planning: PlanningMetrics;
+}
+export interface MetricsEngine {
+    ingest(event: {
+        type: string;
+        properties?: Record<string, unknown>;
+    }): void;
+    ingestPrompt(sessionId: string, modelId: string, system: string[]): void;
+    isSubAgent(sessionId: string): boolean;
+    flush(sessionId: string): void;
+    dispose(): void;
+}
+export interface SubAgentState {
+    sessionId: string;
+    agentName: string;
+    title: string;
+    messageMap: Map<string, MessageEntry>;
+    toolCallMap: Map<string, ToolCallEntry>;
+    textLengthMap: Map<string, number>;
+    orderCounter: number;
+    _userMessageIds: Set<string>;
+    _pendingUserMessage: string[];
+}
+export interface SessionMetricsState {
+    sessionId: string;
+    startTime: number;
+    endTime: number;
+    rounds: RoundSnapshot[];
+    tokens: TokenUsage;
+    tools: {
+        totalCalls: number;
+        invalidCalls: number;
+        completedCalls: number;
+        errorCalls: number;
+        distribution: Map<string, ToolStats>;
+        slowestCall: {
+            tool: string;
+            duration: number;
+        };
+    };
+    agent: {
+        current: string;
+        switches: number;
+        lastSwitchTime: number;
+        usage: Map<string, number>;
+    };
+    model: {
+        current: string;
+        switches: number;
+        tokenDistribution: Map<string, TokenUsage>;
+    };
+    compactions: number;
+    anomaly: {
+        triggered: boolean;
+        events: string[];
+    };
+    currentStage: StageInfo | null;
+    stages: StageInfo[];
+    lastStageEndTime: number;
+    _stageTokens: TokenUsage;
+    _roundStartTime: number;
+    _firstEventTime: number;
+    _firstTextTime: number;
+    _hasFirstEvent: boolean;
+    _hasTextPart: boolean;
+    _roundTokens: TokenUsage;
+    _roundToolCalls: number;
+    _roundErrors: number;
+    _roundFirstBuildTracked: boolean;
+    _roundIdleProcessed: boolean;
+    _idleFlushed: boolean;
+    messageMap: Map<string, MessageEntry>;
+    toolCallMap: Map<string, ToolCallEntry>;
+    textLengthMap: Map<string, number>;
+    sessionMeta: SessionMeta;
+    compileStats: CompileStats;
+    orderCounter: number;
+    skillCallMap: Map<string, SkillCallEntry>;
+    htmlPreviewMsgId: string | null;
+    skillSearchMap: Map<string, SkillSearchEntry>;
+    _pendingReadChain: {
+        searchCallID: string;
+    } | null;
+    _userMessageIds: Set<string>;
+    _pendingUserMessage: string[];
+    subAgents: Map<string, SubAgentState>;
+    planningCalls: PlanningCall[];
+    systemPrompts: Map<string, string[]>;
+}
+export declare function createTokenUsage(): TokenUsage;
+export declare function createSessionMetrics(sessionId: string): SessionMetricsState;

package/dist/metrics-types.js

@@ -0,0 +1,102 @@
+export const TRACKED_EVENT_TYPES = new Set([
+    "session.created",
+    "session.updated",
+    "session.idle",
+    "session.deleted",
+    "session.compacted",
+    "session.status",
+    "session.error",
+    "message.updated",
+    "message.removed",
+    "message.part.updated",
+    "message.part.removed",
+    "permission.asked",
+    "permission.replied",
+    "command.executed",
+]);
+// ─── Factory Functions ───────────────────────────────────────────────────────
+export function createTokenUsage() {
+    return { input: 0, output: 0, reasoning: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
+}
+export function createSessionMetrics(sessionId) {
+    const now = Date.now();
+    return {
+        sessionId,
+        startTime: now,
+        endTime: now,
+        rounds: [],
+        tokens: createTokenUsage(),
+        tools: {
+            totalCalls: 0,
+            invalidCalls: 0,
+            completedCalls: 0,
+            errorCalls: 0,
+            distribution: new Map(),
+            slowestCall: { tool: "", duration: 0 },
+        },
+        agent: {
+            current: "",
+            switches: 0,
+            lastSwitchTime: now,
+            usage: new Map(),
+        },
+        model: {
+            current: "",
+            switches: 0,
+            tokenDistribution: new Map(),
+        },
+        compactions: 0,
+        anomaly: { triggered: false, events: [] },
+        currentStage: null,
+        stages: [],
+        lastStageEndTime: now,
+        messageMap: new Map(),
+        toolCallMap: new Map(),
+        textLengthMap: new Map(),
+        sessionMeta: {
+            sessionId,
+            workingDirectory: '',
+            startTime: '',
+            model: '',
+            agent: '',
+            agentSwitches: 0,
+            agentUsage: {},
+            modelSwitches: 0,
+            modelTokenDistribution: {},
+        },
+        compileStats: {
+            hvigorwCalls: 0,
+            hvigorwErrors: 0,
+            lastBuildSuccess: false,
+            etsLines: 0,
+            firstBuildPerRound: [],
+            errorCodes: new Map(),
+            fixCycles: [],
+            _pendingFix: null,
+            warnings: new Map(),
+            moduleTimings: new Map(),
+        },
+        orderCounter: 0,
+        skillCallMap: new Map(),
+        htmlPreviewMsgId: null,
+        skillSearchMap: new Map(),
+        _pendingReadChain: null,
+        _userMessageIds: new Set(),
+        _pendingUserMessage: [],
+        subAgents: new Map(),
+        _stageTokens: createTokenUsage(),
+        _roundStartTime: now,
+        _firstEventTime: 0,
+        _firstTextTime: 0,
+        _hasFirstEvent: false,
+        _hasTextPart: false,
+        _roundTokens: createTokenUsage(),
+        _roundToolCalls: 0,
+        _roundErrors: 0,
+        _roundFirstBuildTracked: false,
+        _roundIdleProcessed: false,
+        _idleFlushed: false,
+        planningCalls: [],
+        systemPrompts: new Map(),
+    };
+}