@guidemode/types 0.1.43

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 GuideAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @guidemode/types
+
+> **Shared TypeScript types for the GuideMode ecosystem.**
+
+Type definitions used across all GuideMode packages for type safety and consistency.
+
+## Installation
+
+```bash
+npm install @guidemode/types
+```
+
+## Usage
+
+```typescript
+import type { AgentSession, SessionMetrics } from '@guidemode/types'
+
+const session: AgentSession = {
+  sessionId: 'session-123',
+  provider: 'claude-code',
+  startTime: new Date(),
+  // ...
+}
+```
+
+## What's Included
+
+- **Session Types** - AgentSession, ParsedMessage, SessionPhase
+- **Metrics Types** - Performance, Usage, Quality, Engagement, Error metrics
+- **API Types** - Request/response shapes for all endpoints
+- **Database Types** - Schema types matching database models
+- **Auth Types** - OAuth, sessions, permissions
+- **Canonical Format Types** - Universal message format for all providers
+
+## Key Features
+
+- ✅ **Dual Module Support** - ESM and CommonJS
+- ✅ **Full Type Safety** - Strict TypeScript compilation
+- ✅ **Canonical Format** - Unified types for all AI providers
+- ✅ **Runtime Validation** - Zod schemas for provider data
+
+## For Developers
+
+### Build from Source
+
+```bash
+git clone https://github.com/guidemode/types.git
+cd types
+pnpm install
+pnpm build
+```
+
+**See [CLAUDE.md](CLAUDE.md) for:**
+- Complete type catalog
+- Semantic organization structure
+- How to add new types
+
+## Related Packages
+
+- [@guidemode/desktop](https://github.com/guidemode/desktop) - Desktop app
+- [@guidemode/session-processing](https://github.com/guidemode/session-processing) - Analytics engine
+- [@guidemode/cli](https://github.com/guidemode/cli) - CLI tool
+
+## License
+
+MIT License - see [LICENSE](LICENSE)
+
+## Support
+
+- 💬 [**Discussions**](https://github.com/orgs/guidemode/discussions) - Ask questions, share ideas
+- 🐛 [**Issues**](https://github.com/guidemode/desktop/issues) - Report bugs, request features
+- 📧 **Email**: support@guidemode.dev

package/dist/cjs/auth.d.ts

@@ -0,0 +1,44 @@
+import type { User } from './domain/users.js';
+export type { User };
+export interface AuthContext {
+    tenantId: string;
+    permissions: string[];
+    apiKey?: string;
+    userId?: string;
+    user?: User;
+}
+/**
+ * Subscription tier for per-team pricing (new model)
+ * - free: 1 team limit (default)
+ * - starter: 3 teams
+ * - scaleUp: 10 teams
+ * - enterprise: unlimited teams
+ * - unlimited: admin-created special tier
+ */
+export type SubscriptionTier = 'free' | 'starter' | 'scaleUp' | 'enterprise' | 'unlimited';
+export interface SubscriptionInfo {
+    status: 'active' | 'canceled' | 'paused' | 'trialing' | 'past_due';
+    isActive: boolean;
+    tier?: SubscriptionTier;
+    teamLimit?: number | null;
+    plan?: 'individual' | 'smallTeam' | 'largeTeam' | 'enterprise';
+    paddleCustomerId?: string;
+    paddleSubscriptionId?: string;
+    billingCycle?: string;
+}
+export interface SessionContext {
+    tenantId: string;
+    userId?: string;
+    permissions: string[];
+    user?: User;
+    subscription?: SubscriptionInfo;
+    tenantUser?: {
+        role: 'owner' | 'admin' | 'member';
+        tenantId: string;
+        userId: string;
+    };
+    tenant?: {
+        id: string;
+    };
+}
+//# sourceMappingURL=auth.d.ts.map

package/dist/cjs/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAK7C,YAAY,EAAE,IAAI,EAAE,CAAA;AAEpB,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,IAAI,CAAA;CACZ;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,CAAA;AAE1F,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;IAClE,QAAQ,EAAE,OAAO,CAAA;IAGjB,IAAI,CAAC,EAAE,gBAAgB,CAAA;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAGzB,IAAI,CAAC,EAAE,YAAY,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;IAE9D,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,IAAI,CAAC,EAAE,IAAI,CAAA;IACX,YAAY,CAAC,EAAE,gBAAgB,CAAA;IAC/B,UAAU,CAAC,EAAE;QACX,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAA;QAClC,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IACD,MAAM,CAAC,EAAE;QACP,EAAE,EAAE,MAAM,CAAA;KACX,CAAA;CACF"}

package/dist/cjs/auth.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=auth.js.map

package/dist/cjs/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/auth.ts"],"names":[],"mappings":""}

package/dist/cjs/canonical-validation.d.ts

@@ -0,0 +1,370 @@
+/**
+ * Canonical JSONL Format Validation
+ *
+ * Comprehensive Zod-based validation for canonical JSONL format.
+ * Supports tiered validation (critical errors vs warnings) and semantic checks.
+ */
+import { z } from 'zod';
+/**
+ * Union of all content block types
+ */
+declare const ContentBlockSchema: z.ZodDiscriminatedUnion<"type", [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<"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.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.ZodString;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type?: "tool_result";
+    content?: string;
+    tool_use_id?: string;
+    is_error?: boolean;
+}, {
+    type?: "tool_result";
+    content?: string;
+    tool_use_id?: string;
+    is_error?: boolean;
+}>]>;
+/**
+ * Complete canonical message schema
+ *
+ * IMPORTANT: This validates the CANONICAL format (post-conversion)
+ * - Native Claude logs need filtering (remove file-history-snapshot, etc.)
+ * - All converters must add `provider` field
+ * - Only conversational messages (user, assistant, meta) are allowed
+ */
+export declare const CanonicalMessageSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    timestamp: z.ZodEffects<z.ZodString, string, string>;
+    type: z.ZodEnum<["user", "assistant", "meta"]>;
+    sessionId: z.ZodString;
+    provider: z.ZodString;
+    message: z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<"type", [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<"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.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.ZodString;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        }, {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        }>]>, "many">]>;
+        model: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        }, {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        })[];
+        role?: string;
+        model?: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    }, {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        })[];
+        role?: string;
+        model?: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+    gitBranch: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+    parentUuid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    logicalParentUuid: z.ZodOptional<z.ZodString>;
+    isSidechain: z.ZodOptional<z.ZodBoolean>;
+    userType: z.ZodOptional<z.ZodString>;
+    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    isMeta: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
+    toolUseResult: z.ZodOptional<z.ZodUnknown>;
+    level: z.ZodOptional<z.ZodString>;
+    subtype: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    compactMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    toolUseID: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "meta" | "user" | "assistant";
+    message?: {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        })[];
+        role?: string;
+        model?: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    };
+    timestamp?: string;
+    content?: string;
+    uuid?: string;
+    version?: string;
+    sessionId?: string;
+    provider?: string;
+    cwd?: string;
+    gitBranch?: string;
+    parentUuid?: string;
+    logicalParentUuid?: string;
+    isSidechain?: boolean;
+    userType?: string;
+    providerMetadata?: Record<string, unknown>;
+    isMeta?: boolean;
+    requestId?: string;
+    toolUseResult?: unknown;
+    level?: string;
+    subtype?: string;
+    compactMetadata?: Record<string, unknown>;
+    toolUseID?: string;
+}, {
+    type?: "meta" | "user" | "assistant";
+    message?: {
+        content?: string | ({
+            type?: "text";
+            text?: string;
+        } | {
+            type?: "thinking";
+            thinking?: string;
+            signature?: string;
+        } | {
+            input?: Record<string, unknown>;
+            name?: string;
+            type?: "tool_use";
+            id?: string;
+        } | {
+            type?: "tool_result";
+            content?: string;
+            tool_use_id?: string;
+            is_error?: boolean;
+        })[];
+        role?: string;
+        model?: string;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    };
+    timestamp?: string;
+    content?: string;
+    uuid?: string;
+    version?: string;
+    sessionId?: string;
+    provider?: string;
+    cwd?: string;
+    gitBranch?: string;
+    parentUuid?: string;
+    logicalParentUuid?: string;
+    isSidechain?: boolean;
+    userType?: string;
+    providerMetadata?: Record<string, unknown>;
+    isMeta?: boolean;
+    requestId?: string;
+    toolUseResult?: unknown;
+    level?: string;
+    subtype?: string;
+    compactMetadata?: Record<string, unknown>;
+    toolUseID?: string;
+}>;
+export type CanonicalMessage = z.infer<typeof CanonicalMessageSchema>;
+export type ContentBlock = z.infer<typeof ContentBlockSchema>;
+export type ValidationSeverity = 'error' | 'warning';
+export interface ValidationIssue {
+    severity: ValidationSeverity;
+    code: string;
+    message: string;
+    path?: string;
+    line?: number;
+    details?: unknown;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+    messageCount: number;
+    validCount: number;
+}
+/**
+ * Validate a single canonical message
+ */
+export declare function validateCanonicalMessage(message: unknown, line?: number): ValidationResult;
+export interface SessionValidationResult extends ValidationResult {
+    sessionId: string;
+    provider: string | undefined;
+    startTime?: string;
+    endTime?: string;
+    duration?: number;
+    toolChainIssues: ValidationIssue[];
+}
+/**
+ * Validates tool use/result matching across a session
+ * IMPORTANT: tool_use can exist without tool_result (waiting for result)
+ * BUT tool_result MUST have a corresponding tool_use (no orphans)
+ */
+export declare function validateToolChain(messages: CanonicalMessage[]): ValidationIssue[];
+/**
+ * Validates UUID uniqueness across messages
+ * CRITICAL: Each message must have a unique UUID
+ */
+export declare function validateUUIDUniqueness(messages: CanonicalMessage[]): ValidationIssue[];
+/**
+ * Validates timestamp ordering across messages
+ */
+export declare function validateTimestampOrdering(messages: CanonicalMessage[]): ValidationIssue[];
+/**
+ * Validates a complete session (array of messages)
+ */
+export declare function validateSession(messages: CanonicalMessage[]): SessionValidationResult;
+export {};
+//# sourceMappingURL=canonical-validation.d.ts.map

package/dist/cjs/canonical-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-validation.d.ts","sourceRoot":"","sources":["../../src/canonical-validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsFvB;;GAEG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKtB,CAAA;AAiBF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BjC,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAM7D,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB;AAqPD;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAuD1F;AAMD,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,EAAE,eAAe,EAAE,CAAA;CACnC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,eAAe,EAAE,CA8EjF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,eAAe,EAAE,CA+BtF;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,eAAe,EAAE,CAiDzF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,uBAAuB,CAoErF"}