@guidemode/types 0.1.43

package/dist/cjs/providers/copilot/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * GitHub Copilot provider types and schemas
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pairToolCallWithResult = exports.isInfoEntry = exports.isToolResultEntry = exports.isToolCallEntry = exports.isCopilotEntry = exports.isUserEntry = exports.isTimelineEntry = exports.CopilotSessionSchema = exports.TimelineEntrySchema = exports.ToolCallResultSchema = exports.TimelineEntryTypeSchema = void 0;
+var entries_js_1 = require("./entries.js");
+Object.defineProperty(exports, "TimelineEntryTypeSchema", { enumerable: true, get: function () { return entries_js_1.TimelineEntryTypeSchema; } });
+Object.defineProperty(exports, "ToolCallResultSchema", { enumerable: true, get: function () { return entries_js_1.ToolCallResultSchema; } });
+Object.defineProperty(exports, "TimelineEntrySchema", { enumerable: true, get: function () { return entries_js_1.TimelineEntrySchema; } });
+Object.defineProperty(exports, "CopilotSessionSchema", { enumerable: true, get: function () { return entries_js_1.CopilotSessionSchema; } });
+Object.defineProperty(exports, "isTimelineEntry", { enumerable: true, get: function () { return entries_js_1.isTimelineEntry; } });
+Object.defineProperty(exports, "isUserEntry", { enumerable: true, get: function () { return entries_js_1.isUserEntry; } });
+Object.defineProperty(exports, "isCopilotEntry", { enumerable: true, get: function () { return entries_js_1.isCopilotEntry; } });
+Object.defineProperty(exports, "isToolCallEntry", { enumerable: true, get: function () { return entries_js_1.isToolCallEntry; } });
+Object.defineProperty(exports, "isToolResultEntry", { enumerable: true, get: function () { return entries_js_1.isToolResultEntry; } });
+Object.defineProperty(exports, "isInfoEntry", { enumerable: true, get: function () { return entries_js_1.isInfoEntry; } });
+Object.defineProperty(exports, "pairToolCallWithResult", { enumerable: true, get: function () { return entries_js_1.pairToolCallWithResult; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/providers/copilot/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/providers/copilot/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,2CAYqB;AAXnB,qHAAA,uBAAuB,OAAA;AACvB,kHAAA,oBAAoB,OAAA;AACpB,iHAAA,mBAAmB,OAAA;AACnB,kHAAA,oBAAoB,OAAA;AACpB,6GAAA,eAAe,OAAA;AACf,yGAAA,WAAW,OAAA;AACX,4GAAA,cAAc,OAAA;AACd,6GAAA,eAAe,OAAA;AACf,+GAAA,iBAAiB,OAAA;AACjB,yGAAA,WAAW,OAAA;AACX,oHAAA,sBAAsB,OAAA"}

package/dist/cjs/providers/gemini/entries.d.ts

@@ -0,0 +1,319 @@
+/**
+ * Gemini provider type definitions
+ * Gemini extends Claude's message format with additional thinking and token tracking
+ */
+import { z } from 'zod';
+/**
+ * Gemini thought structure (extended thinking)
+ */
+export declare const ThoughtSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodString;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp?: string;
+    description?: string;
+    subject?: string;
+}, {
+    timestamp?: string;
+    description?: string;
+    subject?: string;
+}>;
+export type Thought = z.infer<typeof ThoughtSchema>;
+/**
+ * Gemini token metrics
+ * Provides granular breakdown of token usage
+ */
+export declare const TokenMetricsSchema: z.ZodObject<{
+    input: z.ZodNumber;
+    output: z.ZodNumber;
+    cached: z.ZodOptional<z.ZodNumber>;
+    thoughts: z.ZodOptional<z.ZodNumber>;
+    tool: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    input?: number;
+    total?: number;
+    output?: number;
+    cached?: number;
+    thoughts?: number;
+    tool?: number;
+}, {
+    input?: number;
+    total?: number;
+    output?: number;
+    cached?: number;
+    thoughts?: number;
+    tool?: number;
+}>;
+export type TokenMetrics = z.infer<typeof TokenMetricsSchema>;
+/**
+ * Gemini message entry (extends Claude format)
+ */
+export declare const GeminiMessageSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    timestamp: z.ZodString;
+    type: z.ZodEnum<["user", "assistant", "summary", "system"]>;
+    message: z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type?: "text";
+            text?: string;
+        }, {
+            type?: "text";
+            text?: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        }, {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnknown;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        }, {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"thinking">;
+            thinking: z.ZodOptional<z.ZodString>;
+            signature: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        }, {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        }>, z.ZodObject<{
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>]>, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role?: string;
+    }, {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role?: string;
+    }>;
+    thoughts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        subject: z.ZodString;
+        description: z.ZodString;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: string;
+        description?: string;
+        subject?: string;
+    }, {
+        timestamp?: string;
+        description?: string;
+        subject?: string;
+    }>, "many">>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        input?: number;
+        total?: number;
+        output?: number;
+        cached?: number;
+        thoughts?: number;
+        tool?: number;
+    }, {
+        input?: number;
+        total?: number;
+        output?: number;
+        cached?: number;
+        thoughts?: number;
+        tool?: number;
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodString;
+    parentUuid: z.ZodOptional<z.ZodString>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type?: "summary" | "user" | "assistant" | "system";
+    message?: {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | z.objectOutputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role?: string;
+    };
+    timestamp?: string;
+    uuid?: string;
+    model?: string;
+    sessionId?: string;
+    parentUuid?: string;
+    isMeta?: boolean;
+    thoughts?: {
+        timestamp?: string;
+        description?: string;
+        subject?: string;
+    }[];
+    tokens?: {
+        input?: number;
+        total?: number;
+        output?: number;
+        cached?: number;
+        thoughts?: number;
+        tool?: number;
+    };
+}, {
+    type?: "summary" | "user" | "assistant" | "system";
+    message?: {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: unknown;
+            tool_use_id?: string;
+            is_error?: boolean;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | z.objectInputType<{
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">)[];
+        role?: string;
+    };
+    timestamp?: string;
+    uuid?: string;
+    model?: string;
+    sessionId?: string;
+    parentUuid?: string;
+    isMeta?: boolean;
+    thoughts?: {
+        timestamp?: string;
+        description?: string;
+        subject?: string;
+    }[];
+    tokens?: {
+        input?: number;
+        total?: number;
+        output?: number;
+        cached?: number;
+        thoughts?: number;
+        tool?: number;
+    };
+}>;
+export type GeminiMessage = z.infer<typeof GeminiMessageSchema>;
+/**
+ * Gemini metadata extension for ParsedMessage
+ */
+export interface GeminiMetadata {
+    thoughts?: Thought[];
+    thoughtCount?: number;
+    hasThoughts: boolean;
+    tokens?: TokenMetrics;
+    hasCachedTokens: boolean;
+    hasThinkingTokens: boolean;
+    cacheHitRate?: number;
+    thinkingOverhead?: number;
+    model?: string;
+}
+/**
+ * Type guards
+ */
+export declare function isGeminiMessage(entry: unknown): entry is GeminiMessage;
+export declare function hasGeminiThoughts(message: GeminiMessage): boolean;
+export declare function hasGeminiTokens(message: GeminiMessage): boolean;
+/**
+ * Helper to calculate cache hit rate
+ */
+export declare function calculateCacheHitRate(tokens: TokenMetrics): number;
+/**
+ * Helper to calculate thinking overhead
+ */
+export declare function calculateThinkingOverhead(tokens: TokenMetrics): number;
+//# sourceMappingURL=entries.d.ts.map

package/dist/cjs/providers/gemini/entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../../../src/providers/gemini/entries.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;EAIxB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEnD;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAuC7D;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkB9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,OAAO,CAAA;IACpB,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,eAAe,EAAE,OAAO,CAAA;IACxB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAGtE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAEjE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAE/D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAGlE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAGtE"}

package/dist/cjs/providers/gemini/entries.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Gemini provider type definitions
+ * Gemini extends Claude's message format with additional thinking and token tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiMessageSchema = exports.TokenMetricsSchema = exports.ThoughtSchema = void 0;
+exports.isGeminiMessage = isGeminiMessage;
+exports.hasGeminiThoughts = hasGeminiThoughts;
+exports.hasGeminiTokens = hasGeminiTokens;
+exports.calculateCacheHitRate = calculateCacheHitRate;
+exports.calculateThinkingOverhead = calculateThinkingOverhead;
+const zod_1 = require("zod");
+/**
+ * Gemini thought structure (extended thinking)
+ */
+exports.ThoughtSchema = zod_1.z.object({
+    subject: zod_1.z.string(),
+    description: zod_1.z.string(),
+    timestamp: zod_1.z.string(),
+});
+/**
+ * Gemini token metrics
+ * Provides granular breakdown of token usage
+ */
+exports.TokenMetricsSchema = zod_1.z.object({
+    input: zod_1.z.number(),
+    output: zod_1.z.number(),
+    cached: zod_1.z.number().optional(),
+    thoughts: zod_1.z.number().optional(), // Thinking token overhead
+    tool: zod_1.z.number().optional(),
+    total: zod_1.z.number(),
+});
+/**
+ * Content block schema (reuses shared types at runtime)
+ */
+const ContentBlockSchema = zod_1.z.union([
+    // Text
+    zod_1.z.object({
+        type: zod_1.z.literal('text'),
+        text: zod_1.z.string(),
+    }),
+    // Tool use
+    zod_1.z.object({
+        type: zod_1.z.literal('tool_use'),
+        id: zod_1.z.string(),
+        name: zod_1.z.string(),
+        input: zod_1.z.record(zod_1.z.unknown()),
+    }),
+    // Tool result
+    zod_1.z.object({
+        type: zod_1.z.literal('tool_result'),
+        tool_use_id: zod_1.z.string(),
+        content: zod_1.z.unknown(),
+        is_error: zod_1.z.boolean().optional(),
+    }),
+    // Thinking
+    zod_1.z.object({
+        type: zod_1.z.literal('thinking'),
+        thinking: zod_1.z.string().optional(),
+        signature: zod_1.z.string().optional(),
+    }),
+    // Unknown (catch-all)
+    zod_1.z
+        .object({
+        type: zod_1.z.string(),
+    })
+        .passthrough(),
+]);
+/**
+ * Gemini message entry (extends Claude format)
+ */
+exports.GeminiMessageSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    timestamp: zod_1.z.string(),
+    type: zod_1.z.enum(['user', 'assistant', 'summary', 'system']),
+    message: zod_1.z.object({
+        role: zod_1.z.string(),
+        content: zod_1.z.union([zod_1.z.string(), zod_1.z.array(ContentBlockSchema)]),
+    }),
+    // Gemini-specific fields
+    thoughts: zod_1.z.array(exports.ThoughtSchema).optional(),
+    tokens: exports.TokenMetricsSchema.optional(),
+    model: zod_1.z.string().optional(),
+    // Standard fields
+    sessionId: zod_1.z.string(),
+    parentUuid: zod_1.z.string().optional(),
+    isMeta: zod_1.z.boolean().optional(),
+});
+/**
+ * Type guards
+ */
+function isGeminiMessage(entry) {
+    const result = exports.GeminiMessageSchema.safeParse(entry);
+    return result.success;
+}
+function hasGeminiThoughts(message) {
+    return !!message.thoughts && message.thoughts.length > 0;
+}
+function hasGeminiTokens(message) {
+    return !!message.tokens;
+}
+/**
+ * Helper to calculate cache hit rate
+ */
+function calculateCacheHitRate(tokens) {
+    if (!tokens.cached || tokens.total === 0)
+        return 0;
+    return (tokens.cached / tokens.total) * 100;
+}
+/**
+ * Helper to calculate thinking overhead
+ */
+function calculateThinkingOverhead(tokens) {
+    if (!tokens.thoughts || tokens.output === 0)
+        return 0;
+    return tokens.thoughts / tokens.output;
+}
+//# sourceMappingURL=entries.js.map

package/dist/cjs/providers/gemini/entries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entries.js","sourceRoot":"","sources":["../../../../src/providers/gemini/entries.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA8GH,0CAGC;AAED,8CAEC;AAED,0CAEC;AAKD,sDAGC;AAKD,8DAGC;AAvID,6BAAuB;AAEvB;;GAEG;AACU,QAAA,aAAa,GAAG,OAAC,CAAC,MAAM,CAAC;IACpC,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;IACnB,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE;IACvB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAA;AAIF;;;GAGG;AACU,QAAA,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IACzC,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;IACjB,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE;IAClB,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,0BAA0B;IAC3D,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE;CAClB,CAAC,CAAA;AAIF;;GAEG;AACH,MAAM,kBAAkB,GAAG,OAAC,CAAC,KAAK,CAAC;IACjC,OAAO;IACP,OAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACvB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;KACjB,CAAC;IACF,WAAW;IACX,OAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAC3B,EAAE,EAAE,OAAC,CAAC,MAAM,EAAE;QACd,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;QAChB,KAAK,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC;KAC7B,CAAC;IACF,cAAc;IACd,OAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,aAAa,CAAC;QAC9B,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE;QACvB,OAAO,EAAE,OAAC,CAAC,OAAO,EAAE;QACpB,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC;IACF,WAAW;IACX,OAAC,CAAC,MAAM,CAAC;QACP,IAAI,EAAE,OAAC,CAAC,OAAO,CAAC,UAAU,CAAC;QAC3B,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC/B,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KACjC,CAAC;IACF,sBAAsB;IACtB,OAAC;SACE,MAAM,CAAC;QACN,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;KACjB,CAAC;SACD,WAAW,EAAE;CACjB,CAAC,CAAA;AAEF;;GAEG;AACU,QAAA,mBAAmB,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1C,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;IAChB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,IAAI,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;IACxD,OAAO,EAAE,OAAC,CAAC,MAAM,CAAC;QAChB,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;QAChB,OAAO,EAAE,OAAC,CAAC,KAAK,CAAC,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,OAAC,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,CAAC;KAC5D,CAAC;IAEF,yBAAyB;IACzB,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,qBAAa,CAAC,CAAC,QAAQ,EAAE;IAC3C,MAAM,EAAE,0BAAkB,CAAC,QAAQ,EAAE;IACrC,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAE5B,kBAAkB;IAClB,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE;IACrB,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,MAAM,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAA;AAmBF;;GAEG;AACH,SAAgB,eAAe,CAAC,KAAc;IAC5C,MAAM,MAAM,GAAG,2BAAmB,CAAC,SAAS,CAAC,KAAK,CAAC,CAAA;IACnD,OAAO,MAAM,CAAC,OAAO,CAAA;AACvB,CAAC;AAED,SAAgB,iBAAiB,CAAC,OAAsB;IACtD,OAAO,CAAC,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAA;AAC1D,CAAC;AAED,SAAgB,eAAe,CAAC,OAAsB;IACpD,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAA;AACzB,CAAC;AAED;;GAEG;AACH,SAAgB,qBAAqB,CAAC,MAAoB;IACxD,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,KAAK,KAAK,CAAC;QAAE,OAAO,CAAC,CAAA;IAClD,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,GAAG,CAAA;AAC7C,CAAC;AAED;;GAEG;AACH,SAAgB,yBAAyB,CAAC,MAAoB;IAC5D,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAA;IACrD,OAAO,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAA;AACxC,CAAC"}

package/dist/cjs/providers/gemini/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gemini provider types and schemas
+ */
+export { ThoughtSchema, TokenMetricsSchema, GeminiMessageSchema, isGeminiMessage, hasGeminiThoughts, hasGeminiTokens, calculateCacheHitRate, calculateThinkingOverhead, } from './entries.js';
+export type { Thought, TokenMetrics, GeminiMessage, GeminiMetadata, } from './entries.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/providers/gemini/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/providers/gemini/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,cAAc,CAAA;AAErB,YAAY,EACV,OAAO,EACP,YAAY,EACZ,aAAa,EACb,cAAc,GACf,MAAM,cAAc,CAAA"}

package/dist/cjs/providers/gemini/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Gemini provider types and schemas
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateThinkingOverhead = exports.calculateCacheHitRate = exports.hasGeminiTokens = exports.hasGeminiThoughts = exports.isGeminiMessage = exports.GeminiMessageSchema = exports.TokenMetricsSchema = exports.ThoughtSchema = void 0;
+var entries_js_1 = require("./entries.js");
+Object.defineProperty(exports, "ThoughtSchema", { enumerable: true, get: function () { return entries_js_1.ThoughtSchema; } });
+Object.defineProperty(exports, "TokenMetricsSchema", { enumerable: true, get: function () { return entries_js_1.TokenMetricsSchema; } });
+Object.defineProperty(exports, "GeminiMessageSchema", { enumerable: true, get: function () { return entries_js_1.GeminiMessageSchema; } });
+Object.defineProperty(exports, "isGeminiMessage", { enumerable: true, get: function () { return entries_js_1.isGeminiMessage; } });
+Object.defineProperty(exports, "hasGeminiThoughts", { enumerable: true, get: function () { return entries_js_1.hasGeminiThoughts; } });
+Object.defineProperty(exports, "hasGeminiTokens", { enumerable: true, get: function () { return entries_js_1.hasGeminiTokens; } });
+Object.defineProperty(exports, "calculateCacheHitRate", { enumerable: true, get: function () { return entries_js_1.calculateCacheHitRate; } });
+Object.defineProperty(exports, "calculateThinkingOverhead", { enumerable: true, get: function () { return entries_js_1.calculateThinkingOverhead; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/providers/gemini/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/providers/gemini/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,2CASqB;AARnB,2GAAA,aAAa,OAAA;AACb,gHAAA,kBAAkB,OAAA;AAClB,iHAAA,mBAAmB,OAAA;AACnB,6GAAA,eAAe,OAAA;AACf,+GAAA,iBAAiB,OAAA;AACjB,6GAAA,eAAe,OAAA;AACf,mHAAA,qBAAqB,OAAA;AACrB,uHAAA,yBAAyB,OAAA"}

package/dist/cjs/providers/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Provider-specific type schemas
+ *
+ * Each provider (Claude Code, Cursor, Windsurf, etc.) has its own
+ * JSONL entry format. This module provides Zod schemas and TypeScript
+ * types for runtime validation and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { Claude } from '@guidemode/types/providers';
+ *
+ * // Parse JSONL entry
+ * const entry = Claude.AnyEntrySchema.parse(jsonData);
+ *
+ * // Type-safe access
+ * if (Claude.isUserEntry(entry)) {
+ *   console.log(entry.message.content);
+ * }
+ * ```
+ */
+export * as Claude from './claude/index.js';
+export * as Codex from './codex/index.js';
+export * as OpenCode from './opencode/index.js';
+export * as Gemini from './gemini/index.js';
+export * as Copilot from './copilot/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,KAAK,MAAM,kBAAkB,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAA"}

package/dist/cjs/providers/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Provider-specific type schemas
+ *
+ * Each provider (Claude Code, Cursor, Windsurf, etc.) has its own
+ * JSONL entry format. This module provides Zod schemas and TypeScript
+ * types for runtime validation and type safety.
+ *
+ * @example
+ * ```typescript
+ * import { Claude } from '@guidemode/types/providers';
+ *
+ * // Parse JSONL entry
+ * const entry = Claude.AnyEntrySchema.parse(jsonData);
+ *
+ * // Type-safe access
+ * if (Claude.isUserEntry(entry)) {
+ *   console.log(entry.message.content);
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Copilot = exports.Gemini = exports.OpenCode = exports.Codex = exports.Claude = void 0;
+// Export provider namespaces as they are added
+exports.Claude = require("./claude/index.js");
+exports.Codex = require("./codex/index.js");
+exports.OpenCode = require("./opencode/index.js");
+exports.Gemini = require("./gemini/index.js");
+exports.Copilot = require("./copilot/index.js");
+// export * as Cursor from './cursor/index.js';
+// export * as Windsurf from './windsurf/index.js';
+//# sourceMappingURL=index.js.map

package/dist/cjs/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/providers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;AAEH,+CAA+C;AAC/C,8CAA2C;AAC3C,4CAAyC;AACzC,kDAA+C;AAC/C,8CAA2C;AAC3C,gDAA6C;AAC7C,+CAA+C;AAC/C,mDAAmD"}