@codemieai/code 0.4.1 → 0.5.0

package/dist/agents/plugins/kimi/kimi.session.js

@@ -0,0 +1,191 @@
+/**
+ * Kimi Session Adapter
+ *
+ * Parses Kimi Code `wire.jsonl` session transcripts into the unified
+ * ParsedSession format used by CodeMie processors.
+ *
+ * Wire file path:
+ *   ${KIMI_CODE_HOME}/sessions/{workDirKey}/{sessionId}/agents/main/wire.jsonl
+ */
+import { readJSONLTolerant } from '../../core/session/utils/jsonl-reader.js';
+import { logger } from '../../../utils/logger.js';
+import { KimiMetricsProcessor } from './session/processors/kimi.metrics-processor.js';
+export class KimiSessionAdapter {
+    metadata;
+    agentName = 'kimi';
+    processors = [];
+    constructor(metadata) {
+        this.metadata = metadata;
+        // Register processors now, but execution is currently orchestrated externally
+        // until processSession is implemented.
+        this.initializeProcessors();
+    }
+    initializeProcessors() {
+        this.registerProcessor(new KimiMetricsProcessor());
+        logger.debug(`[kimi-adapter] Initialized ${this.processors.length} processors`);
+    }
+    registerProcessor(processor) {
+        this.processors.push(processor);
+        this.processors.sort((a, b) => a.priority - b.priority);
+        logger.debug(`[kimi-adapter] Registered processor: ${processor.name} (priority: ${processor.priority})`);
+    }
+    /**
+     * Discover native Kimi sessions (placeholder).
+     */
+    async discoverSessions(_options) {
+        logger.debug('[kimi-adapter] discoverSessions is not implemented yet');
+        return [];
+    }
+    /**
+     * Parse a Kimi `wire.jsonl` file into the unified ParsedSession format.
+     */
+    async parseSessionFile(filePath, sessionId) {
+        try {
+            const events = await readJSONLTolerant(filePath, '[kimi-adapter]');
+            if (events.length === 0) {
+                logger.debug(`[kimi-adapter] Session file is empty or unreadable: ${filePath}`);
+                return this.createMinimalSession(sessionId);
+            }
+            const model = this.extractModel(events);
+            const { createdAt, updatedAt } = this.extractTimestamps(events);
+            logger.debug(`[kimi-adapter] Parsed session ${sessionId}: ${events.length} events, ` +
+                `model=${model ?? 'unknown'}`);
+            const metadata = {
+                projectPath: filePath,
+                createdAt,
+                updatedAt,
+                model,
+            };
+            return {
+                sessionId,
+                agentName: this.metadata.displayName || 'Kimi Code',
+                metadata,
+                messages: events,
+            };
+        }
+        catch (error) {
+            logger.warn(`[kimi-adapter] Failed to parse session file ${filePath}:`, error);
+            return this.createMinimalSession(sessionId);
+        }
+    }
+    /**
+     * Process a Kimi session file with all registered processors.
+     *
+     * Parses the wire.jsonl file once, runs each registered processor in priority
+     * order, and returns an aggregated result. This is the entry point used by
+     * `codemie hook` during incremental sync.
+     */
+    async processSession(filePath, sessionId, context) {
+        try {
+            logger.debug(`[kimi-adapter] Processing session ${sessionId} with ${this.processors.length} processor${this.processors.length !== 1 ? 's' : ''}`);
+            const parsedSession = await this.parseSessionFile(filePath, sessionId);
+            // Enrich parsed session with hook-time context that is not in the native transcript.
+            if (context.gitBranch) {
+                parsedSession.metadata = {
+                    ...parsedSession.metadata,
+                    gitBranch: context.gitBranch,
+                };
+            }
+            const processorResults = {};
+            const failedProcessors = [];
+            let totalRecords = 0;
+            for (const processor of this.processors) {
+                try {
+                    if (!processor.shouldProcess(parsedSession)) {
+                        logger.debug(`[kimi-adapter] Processor ${processor.name} skipped (shouldProcess returned false)`);
+                        continue;
+                    }
+                    logger.debug(`[kimi-adapter] Running processor: ${processor.name}`);
+                    const result = await processor.process(parsedSession, context);
+                    processorResults[processor.name] = {
+                        success: result.success,
+                        message: result.message,
+                        recordsProcessed: result.metadata?.recordsProcessed,
+                    };
+                    if (!result.success) {
+                        failedProcessors.push(processor.name);
+                        logger.warn(`[kimi-adapter] Processor ${processor.name} failed: ${result.message}`);
+                    }
+                    else {
+                        logger.debug(`[kimi-adapter] Processor ${processor.name} succeeded: ${result.message}`);
+                    }
+                    const recordsProcessed = result.metadata?.recordsProcessed;
+                    if (typeof recordsProcessed === 'number') {
+                        totalRecords += recordsProcessed;
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    logger.error(`[kimi-adapter] Processor ${processor.name} threw error:`, error);
+                    processorResults[processor.name] = {
+                        success: false,
+                        message: errorMessage,
+                    };
+                    failedProcessors.push(processor.name);
+                }
+            }
+            const result = {
+                success: failedProcessors.length === 0,
+                processors: processorResults,
+                totalRecords,
+                failedProcessors,
+            };
+            logger.debug(`[kimi-adapter] Processing complete: ${result.success ? 'SUCCESS' : 'FAILED'} ` +
+                `(${totalRecords} records, ${failedProcessors.length} failed processors)`);
+            return result;
+        }
+        catch (error) {
+            logger.error(`[kimi-adapter] Session processing failed:`, error);
+            throw error;
+        }
+    }
+    createMinimalSession(sessionId) {
+        const metadata = {
+            createdAt: undefined,
+            updatedAt: undefined,
+            model: undefined,
+        };
+        return {
+            sessionId,
+            agentName: this.metadata.displayName || 'Kimi Code',
+            metadata,
+            messages: [],
+        };
+    }
+    extractModel(events) {
+        for (const event of events) {
+            if (event.type === 'config.update' && event.modelAlias) {
+                return event.modelAlias;
+            }
+        }
+        for (const event of events) {
+            if (event.type === 'usage.record' && event.model) {
+                return event.model;
+            }
+        }
+        return undefined;
+    }
+    extractTimestamps(events) {
+        let createdAt;
+        let updatedAt;
+        for (const event of events) {
+            if (typeof event.time === 'number') {
+                createdAt = new Date(event.time).toISOString();
+                break;
+            }
+            if (typeof event.created_at === 'number') {
+                createdAt = new Date(event.created_at).toISOString();
+                break;
+            }
+        }
+        for (let i = events.length - 1; i >= 0; i--) {
+            const event = events[i];
+            if (typeof event.time === 'number') {
+                updatedAt = new Date(event.time).toISOString();
+                break;
+            }
+        }
+        return { createdAt, updatedAt };
+    }
+}
+//# sourceMappingURL=kimi.session.js.map

package/dist/agents/plugins/kimi/kimi.session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kimi.session.js","sourceRoot":"","sources":["../../../../src/agents/plugins/kimi/kimi.session.ts"],"names":[],"mappings":"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"}

package/dist/agents/plugins/kimi/session/processors/kimi.metrics-processor.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Kimi Metrics Processor
+ *
+ * Extracts metrics from Kimi Code session wire events and writes them as
+ * incremental MetricDelta records to the shared session metrics JSONL store.
+ *
+ * Unlike the previous one-delta-per-session implementation, this processor emits
+ * one delta per completed assistant step, matching the per-message granularity
+ * used by the Claude metrics processor. The shared analytics aggregator sums
+ * these deltas into session/branch/project totals.
+ *
+ * Responsibilities:
+ * - Detect Kimi Code sessions
+ * - Emit one MetricDelta per completed step (identified by step.end event uuid)
+ * - Count tool calls and results within each step
+ * - Track file operations from display metadata nested inside loop events
+ * - Capture user prompts, skill/agent invocations, and branch info
+ * - Write incremental metric deltas to ~/.codemie/sessions/{sessionId}_metrics.jsonl
+ */
+import type { SessionProcessor, ProcessingContext, ProcessingResult } from '../../../../core/session/BaseProcessor.js';
+import type { ParsedSession } from '../../../../core/session/BaseSessionAdapter.js';
+export declare class KimiMetricsProcessor implements SessionProcessor {
+    readonly name = "kimi-metrics";
+    readonly priority = 1;
+    shouldProcess(session: ParsedSession): boolean;
+    process(session: ParsedSession, context: ProcessingContext): Promise<ProcessingResult>;
+    private extractSteps;
+    private extractTurnPrompts;
+    private turnPromptToArray;
+    private buildStepMetrics;
+    private buildStepNamedInvocations;
+    private buildStepCommandInvocations;
+    private inferAgentType;
+    private extractTextContent;
+    private extractTextContentFromMessage;
+    private extractSlashCommand;
+    private resolveDisplay;
+    private deriveLanguage;
+    private deriveFormat;
+    private computeLineChanges;
+    private splitLines;
+}
+//# sourceMappingURL=kimi.metrics-processor.d.ts.map

package/dist/agents/plugins/kimi/session/processors/kimi.metrics-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kimi.metrics-processor.d.ts","sourceRoot":"","sources":["../../../../../../src/agents/plugins/kimi/session/processors/kimi.metrics-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,2CAA2C,CAAC;AACvH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAepF,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,QAAQ,CAAC,QAAQ,KAAK;IAEtB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO;IAIxC,OAAO,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqH5F,OAAO,CAAC,YAAY;IAuEpB,OAAO,CAAC,kBAAkB;IA+B1B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;IA6ExB,OAAO,CAAC,yBAAyB;IA6BjC,OAAO,CAAC,2BAA2B;IAanC,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;IAY1B,OAAO,CAAC,6BAA6B;IAerC,OAAO,CAAC,mBAAmB;IAK3B,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,cAAc;IA4BtB,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,UAAU;CAOnB"}

package/dist/agents/plugins/kimi/session/processors/kimi.metrics-processor.js

@@ -0,0 +1,421 @@
+/**
+ * Kimi Metrics Processor
+ *
+ * Extracts metrics from Kimi Code session wire events and writes them as
+ * incremental MetricDelta records to the shared session metrics JSONL store.
+ *
+ * Unlike the previous one-delta-per-session implementation, this processor emits
+ * one delta per completed assistant step, matching the per-message granularity
+ * used by the Claude metrics processor. The shared analytics aggregator sums
+ * these deltas into session/branch/project totals.
+ *
+ * Responsibilities:
+ * - Detect Kimi Code sessions
+ * - Emit one MetricDelta per completed step (identified by step.end event uuid)
+ * - Count tool calls and results within each step
+ * - Track file operations from display metadata nested inside loop events
+ * - Capture user prompts, skill/agent invocations, and branch info
+ * - Write incremental metric deltas to ~/.codemie/sessions/{sessionId}_metrics.jsonl
+ */
+import { logger } from '../../../../../utils/logger.js';
+export class KimiMetricsProcessor {
+    name = 'kimi-metrics';
+    priority = 1;
+    shouldProcess(session) {
+        return session.agentName === 'Kimi Code';
+    }
+    async process(session, context) {
+        try {
+            const messages = session.messages;
+            if (messages.length === 0) {
+                logger.debug(`[${this.name}] No wire events to process for session ${session.sessionId}`);
+                return { success: true, message: 'No wire events to process' };
+            }
+            const { MetricsWriter } = await import('../../../../../providers/plugins/sso/session/processors/metrics/MetricsWriter.js');
+            const writer = new MetricsWriter(session.sessionId);
+            let existingDeltas = [];
+            try {
+                existingDeltas = await writer.readAll();
+            }
+            catch (error) {
+                logger.debug(`[${this.name}] Could not read existing deltas: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const processedStepUuids = new Set(existingDeltas.map((d) => d.recordId));
+            const steps = this.extractSteps(messages);
+            const turnPrompts = this.extractTurnPrompts(messages);
+            const sessionModel = session.metadata.model;
+            const gitBranch = session.metadata?.gitBranch ?? session.metadata?.branch;
+            const newDeltas = [];
+            const promptedTurns = new Set();
+            for (const step of steps) {
+                if (processedStepUuids.has(step.uuid)) {
+                    continue;
+                }
+                const { tools, toolStatus, fileOperations } = this.buildStepMetrics(step);
+                const isFirstStepOfTurn = !promptedTurns.has(step.turnId);
+                const userPrompts = isFirstStepOfTurn
+                    ? this.turnPromptToArray(turnPrompts.get(step.turnId))
+                    : [];
+                if (userPrompts.length > 0) {
+                    promptedTurns.add(step.turnId);
+                }
+                const { skillInvocations, agentInvocations } = this.buildStepNamedInvocations(step);
+                const commandInvocations = isFirstStepOfTurn
+                    ? this.buildStepCommandInvocations(step, turnPrompts.get(step.turnId))
+                    : {};
+                const delta = {
+                    recordId: step.uuid,
+                    sessionId: session.sessionId,
+                    agentSessionId: context.agentSessionId || session.sessionId,
+                    timestamp: step.timestamp,
+                    ...(gitBranch && { gitBranch }),
+                    ...(Object.keys(tools).length > 0 && { tools }),
+                    ...(Object.keys(toolStatus).length > 0 && { toolStatus }),
+                    ...(fileOperations.length > 0 && { fileOperations }),
+                    ...(userPrompts.length > 0 && { userPrompts }),
+                    ...(Object.keys(skillInvocations).length > 0 && { skillInvocations }),
+                    ...(Object.keys(agentInvocations).length > 0 && { agentInvocations }),
+                    ...(Object.keys(commandInvocations).length > 0 && { commandInvocations }),
+                    ...(sessionModel && { models: [sessionModel] }),
+                };
+                newDeltas.push(delta);
+            }
+            for (const delta of newDeltas) {
+                await writer.appendDelta(delta);
+            }
+            // Preserve in-memory summary of the latest step for callers/tests.
+            const lastStep = steps[steps.length - 1];
+            if (lastStep) {
+                const { tools, toolStatus, fileOperations } = this.buildStepMetrics(lastStep);
+                const lastIsFirstStepOfTurn = lastStep.step === Math.min(...steps.filter((s) => s.turnId === lastStep.turnId).map((s) => s.step));
+                session.metrics = {
+                    tools,
+                    toolStatus,
+                    fileOperations,
+                    userPrompts: lastIsFirstStepOfTurn ? this.turnPromptToArray(turnPrompts.get(lastStep.turnId)) : [],
+                    ...this.buildStepNamedInvocations(lastStep),
+                    commandInvocations: lastIsFirstStepOfTurn
+                        ? this.buildStepCommandInvocations(lastStep, turnPrompts.get(lastStep.turnId))
+                        : {},
+                };
+            }
+            logger.info(`[${this.name}] Wrote ${newDeltas.length} metric delta(s) for session ${session.sessionId}`);
+            logger.debug(`[${this.name}] Metrics file: ${writer.getFilePath()}`);
+            return {
+                success: true,
+                message: `Generated ${newDeltas.length} delta(s)`,
+                metadata: {
+                    recordsProcessed: messages.length,
+                    deltasWritten: newDeltas.length,
+                    syncUpdates: {
+                        metrics: {
+                            processedRecordIds: newDeltas.map((d) => d.recordId),
+                            lastProcessedTimestamp: Date.now(),
+                            totalDeltas: newDeltas.length
+                        }
+                    }
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logger.error(`[${this.name}] Processing failed:`, error);
+            return {
+                success: false,
+                message: `Metrics processing failed: ${errorMessage}`
+            };
+        }
+    }
+    extractSteps(events) {
+        const stepEnds = [];
+        const toolCalls = [];
+        const toolResults = [];
+        const displays = [];
+        const stepBeginUuids = new Map();
+        for (const event of events) {
+            if (event.type !== 'context.append_loop_event' || !event.event) {
+                continue;
+            }
+            const ev = event.event;
+            if (ev.type === 'step.begin' && typeof ev.uuid === 'string') {
+                stepBeginUuids.set(ev.uuid, { turnId: String(ev.turnId ?? '0'), step: Number(ev.step ?? 0) });
+            }
+            if (ev.type === 'tool.call' &&
+                typeof ev.toolCallId === 'string' &&
+                typeof ev.name === 'string') {
+                toolCalls.push(event);
+            }
+            if (ev.type === 'tool.result' && ev.result) {
+                toolResults.push(event);
+            }
+            const display = this.resolveDisplay(event);
+            if (display) {
+                displays.push({ stepUuid: ev.stepUuid, display });
+            }
+        }
+        // Build buckets from step.end events, matching related events by stepUuid.
+        for (const event of events) {
+            if (event.type !== 'context.append_loop_event' ||
+                event.event?.type !== 'step.end' ||
+                typeof event.event.uuid !== 'string') {
+                continue;
+            }
+            const stepUuid = event.event.uuid;
+            const beginInfo = stepBeginUuids.get(stepUuid);
+            const turnId = beginInfo?.turnId ?? String(event.event.turnId ?? '0');
+            const stepNumber = beginInfo?.step ?? Number(event.event.step ?? 0);
+            const bucket = {
+                uuid: stepUuid,
+                turnId,
+                step: stepNumber,
+                timestamp: typeof event.time === 'number' ? event.time : Date.now(),
+                toolCalls: toolCalls.filter((tc) => tc.event.stepUuid === stepUuid),
+                toolResults: toolResults.filter((tr) => tr.event?.stepUuid === stepUuid),
+                displays: displays
+                    .filter((d) => d.stepUuid === stepUuid)
+                    .map((d) => d.display),
+            };
+            stepEnds.push(bucket);
+        }
+        // Preserve chronological order by timestamp.
+        stepEnds.sort((a, b) => a.timestamp - b.timestamp);
+        return stepEnds;
+    }
+    extractTurnPrompts(events) {
+        const map = new Map();
+        let currentTurnId = '0';
+        for (const event of events) {
+            if (event.type === 'turn.prompt') {
+                if (typeof event.event?.turnId === 'string') {
+                    currentTurnId = event.event.turnId;
+                }
+                const text = this.extractTextContent(event);
+                if (text) {
+                    map.set(currentTurnId, text);
+                }
+            }
+            if (event.type === 'context.append_message' && event.message?.role === 'user') {
+                const origin = event.message.origin;
+                if (origin?.kind === 'user') {
+                    const text = this.extractTextContentFromMessage(event.message);
+                    if (text) {
+                        // Prefer the explicit turnId on the message when available.
+                        const turnId = event.event?.turnId ? String(event.event.turnId) : currentTurnId;
+                        map.set(turnId, text);
+                    }
+                }
+            }
+        }
+        return map;
+    }
+    turnPromptToArray(text) {
+        return text ? [{ count: 1, text }] : [];
+    }
+    buildStepMetrics(step) {
+        const tools = {};
+        const toolStatus = {};
+        const fileOperations = [];
+        const toolCallById = new Map();
+        for (const toolCall of step.toolCalls) {
+            const toolName = toolCall.event.name;
+            tools[toolName] = (tools[toolName] || 0) + 1;
+            if (!toolStatus[toolName]) {
+                toolStatus[toolName] = { success: 0, failure: 0 };
+            }
+            toolCallById.set(toolCall.event.toolCallId, toolCall);
+            if (typeof toolCall.event.uuid === 'string') {
+                toolCallById.set(toolCall.event.uuid, toolCall);
+            }
+        }
+        for (const resultEvent of step.toolResults) {
+            const ev = resultEvent.event;
+            if (!ev)
+                continue;
+            const matchedToolCall = (typeof ev.toolCallId === 'string' && toolCallById.get(ev.toolCallId)) ||
+                (typeof ev.parentUuid === 'string' && toolCallById.get(ev.parentUuid));
+            if (!matchedToolCall) {
+                continue;
+            }
+            const toolName = matchedToolCall.event.name;
+            const isError = ev.result?.isError === true;
+            if (isError) {
+                toolStatus[toolName].failure++;
+            }
+            else {
+                toolStatus[toolName].success++;
+            }
+        }
+        for (const display of step.displays) {
+            if (display.kind !== 'file_io') {
+                continue;
+            }
+            const operation = display.operation;
+            if (operation !== 'read' && operation !== 'write' && operation !== 'edit' && operation !== 'delete') {
+                continue;
+            }
+            const fileOp = {
+                type: operation,
+                path: typeof display.path === 'string' ? display.path : undefined,
+            };
+            if (fileOp.path) {
+                const language = this.deriveLanguage(fileOp.path);
+                const format = this.deriveFormat(fileOp.path);
+                if (language)
+                    fileOp.language = language;
+                if (format)
+                    fileOp.format = format;
+            }
+            if (typeof display.before === 'string' && typeof display.after === 'string') {
+                const lineStats = this.computeLineChanges(display.before, display.after);
+                fileOp.linesAdded = lineStats.linesAdded;
+                fileOp.linesRemoved = lineStats.linesRemoved;
+                fileOp.linesModified = lineStats.linesModified;
+            }
+            fileOperations.push(fileOp);
+        }
+        return { tools, toolStatus, fileOperations };
+    }
+    buildStepNamedInvocations(step) {
+        const skillInvocations = {};
+        const agentInvocations = {};
+        for (const toolCall of step.toolCalls) {
+            const args = toolCall.event.args;
+            if (!args || typeof args !== 'object') {
+                continue;
+            }
+            const toolName = toolCall.event.name;
+            if (toolName === 'Skill' && typeof args.skill === 'string') {
+                skillInvocations[args.skill] = (skillInvocations[args.skill] || 0) + 1;
+            }
+            else if ((toolName === 'Agent' || toolName === 'AgentSwarm') && typeof args.subagent_type === 'string') {
+                agentInvocations[args.subagent_type] = (agentInvocations[args.subagent_type] || 0) + 1;
+            }
+            else if (toolName === 'Agent' && typeof args.description === 'string') {
+                const agentType = this.inferAgentType(args.description);
+                if (agentType) {
+                    agentInvocations[agentType] = (agentInvocations[agentType] || 0) + 1;
+                }
+            }
+        }
+        return { skillInvocations, agentInvocations };
+    }
+    buildStepCommandInvocations(step, turnPrompt) {
+        const commandInvocations = {};
+        if (turnPrompt) {
+            const command = this.extractSlashCommand(turnPrompt);
+            if (command) {
+                commandInvocations[command] = (commandInvocations[command] || 0) + 1;
+            }
+        }
+        return commandInvocations;
+    }
+    inferAgentType(description) {
+        const lower = description.toLowerCase();
+        if (lower.includes('explore'))
+            return 'explore';
+        if (lower.includes('plan'))
+            return 'plan';
+        if (lower.includes('coder'))
+            return 'coder';
+        if (lower.includes('review'))
+            return 'review';
+        return undefined;
+    }
+    extractTextContent(event) {
+        const input = event.input;
+        if (Array.isArray(input)) {
+            for (const part of input) {
+                if (part && part.type === 'text' && typeof part.text === 'string') {
+                    return part.text;
+                }
+            }
+        }
+        return undefined;
+    }
+    extractTextContentFromMessage(message) {
+        const content = message.content;
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                if (part && part.type === 'text' && typeof part.text === 'string') {
+                    return part.text;
+                }
+            }
+        }
+        if (typeof content === 'string') {
+            return content;
+        }
+        return undefined;
+    }
+    extractSlashCommand(text) {
+        const match = text.trim().match(/^\/([a-zA-Z0-9_-]+)/);
+        return match ? match[1] : undefined;
+    }
+    resolveDisplay(event) {
+        return event.event?.display ?? event.display;
+    }
+    deriveLanguage(path) {
+        const ext = path.split('.').pop()?.toLowerCase();
+        switch (ext) {
+            case 'ts': return 'typescript';
+            case 'tsx': return 'typescript';
+            case 'js': return 'javascript';
+            case 'jsx': return 'javascript';
+            case 'py': return 'python';
+            case 'go': return 'go';
+            case 'rs': return 'rust';
+            case 'java': return 'java';
+            case 'kt': return 'kotlin';
+            case 'rb': return 'ruby';
+            case 'php': return 'php';
+            case 'c': return 'c';
+            case 'cpp':
+            case 'cc':
+            case 'cxx': return 'cpp';
+            case 'h':
+            case 'hpp': return 'cpp';
+            case 'cs': return 'csharp';
+            case 'swift': return 'swift';
+            case 'md': return 'markdown';
+            case 'json': return 'json';
+            case 'yaml':
+            case 'yml': return 'yaml';
+            case 'toml': return 'toml';
+            case 'sh': return 'shell';
+            default: return undefined;
+        }
+    }
+    deriveFormat(path) {
+        const ext = path.split('.').pop()?.toLowerCase();
+        return ext || undefined;
+    }
+    computeLineChanges(before, after) {
+        const beforeLines = this.splitLines(before);
+        const afterLines = this.splitLines(after);
+        const maxLen = Math.max(beforeLines.length, afterLines.length);
+        let linesAdded = 0;
+        let linesRemoved = 0;
+        let linesModified = 0;
+        for (let i = 0; i < maxLen; i++) {
+            const b = beforeLines[i];
+            const a = afterLines[i];
+            if (b === undefined && a !== undefined) {
+                linesAdded++;
+            }
+            else if (b !== undefined && a === undefined) {
+                linesRemoved++;
+            }
+            else if (b !== a) {
+                linesModified++;
+            }
+        }
+        return { linesAdded, linesRemoved, linesModified };
+    }
+    splitLines(text) {
+        const lines = text.split('\n');
+        if (lines.length > 0 && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+        return lines;
+    }
+}
+//# sourceMappingURL=kimi.metrics-processor.js.map