@defai.digital/ax-cli 3.6.1 → 3.6.2

package/packages/schemas/dist/public/core/brand-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"brand-types.d.ts","sourceRoot":"","sources":["../../../src/public/core/brand-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,CAAC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,GAAG;IAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAEhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAC3C,MAAM,EAAE,OAAO,GACd,MAAM,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAIvB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAElE;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE5E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE;IAAE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAC;IAAC,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,EACxH,SAAS,EAAE,CAAC;IAGV;;OAEG;;uBAEc,OAAO,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;2BAIjB,OAAO,KAAG;YAAE,OAAO,EAAE,IAAI,CAAC;YAAC,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;SAAE,GAAG;YAAE,OAAO,EAAE,KAAK,CAAC;YAAC,KAAK,EAAE,OAAO,CAAA;SAAE;;IASxG;;;OAGG;mBACY,OAAO,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAKpC;;OAEG;gBACS,OAAO,KAAG,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IAK1C;;OAEG;;EAGN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG"}

package/packages/schemas/dist/public/core/brand-types.js

@@ -1,243 +0,0 @@
-/**
- * Brand Types Utilities for @ax-cli/schemas
- *
- * CRITICAL SECURITY WARNING:
- * =========================
- * Brand types are COMPILE-TIME ONLY markers. They provide ZERO runtime validation.
- *
- * **YOU MUST VALIDATE ALL INPUTS AT SYSTEM BOUNDARIES**
- *
- * Unsafe usage (WILL FAIL IN PRODUCTION):
- * ```typescript
- * const tenantId = userInput as TenantId; // ❌ NO RUNTIME VALIDATION!
- * ```
- *
- * Safe usage (REQUIRED):
- * ```typescript
- * const result = TenantId.parse(userInput); // ✅ Validates with Zod
- * if (result.success) {
- *   const tenantId = result.data; // Type-safe AND runtime-safe
- * }
- * ```
- *
- * WHEN TO USE BRAND TYPES:
- * - Preventing ID mixing at compile time (ApiKeyId vs TenantId)
- * - Enforcing domain boundaries in function signatures
- * - Type-level documentation of intent
- *
- * WHEN TO VALIDATE:
- * - API boundaries (HTTP requests, MCP inputs)
- * - File I/O (reading configs, user settings)
- * - Database queries (WHERE clauses with user IDs)
- * - Environment variables
- * - Command-line arguments
- *
- * PERFORMANCE:
- * Brand types have ZERO runtime cost. They are erased during compilation.
- *
- * @module brand-types
- * @see {@link https://github.com/microsoft/TypeScript/issues/4895|TypeScript Nominal Types}
- */
-/**
- * Creates a branded value.
- *
- * WARNING: This function performs NO VALIDATION. It is a type-level assertion only.
- *
- * Use this ONLY in trusted contexts after validation:
- * - Inside schema .transform() after Zod validation
- * - After database queries that return validated data
- * - In test fixtures with known-good values
- *
- * DO NOT use with user input directly:
- * ```typescript
- * // ❌ UNSAFE - No validation!
- * const userId = brand<string, 'UserId'>(req.body.userId);
- *
- * // ✅ SAFE - Validated first
- * const result = UserIdSchema.safeParse(req.body.userId);
- * if (result.success) {
- *   const userId = result.data; // Already branded by schema
- * }
- * ```
- *
- * @template T - The base type
- * @template B - The brand identifier
- * @param value - The value to brand
- * @returns The same value, but with a brand type
- *
- * @example
- * ```typescript
- * // Safe usage in tests
- * const mockTenantId = brand<string, 'TenantId'>("test-tenant-123");
- *
- * // Safe usage after validation
- * const schema = z.string().uuid().transform(v => brand<string, 'TenantId'>(v));
- * const tenantId = schema.parse(userInput); // Validated AND branded
- * ```
- */
-export function brand(value) {
-    return value;
-}
-/**
- * Type guard to check if a value is already branded with a specific brand.
- *
- * NOTE: This only works if the value was created using the brand() function.
- * It CANNOT detect fake brands created with `as` casts.
- *
- * @template T - The base type
- * @template B - The brand identifier
- * @param value - The value to check
- * @returns true if the value has the correct brand (compile-time only)
- *
- * @example
- * ```typescript
- * const value: string | TenantId = getTenantId();
- *
- * if (isBranded<string, 'TenantId'>(value)) {
- *   const tenantId: TenantId = value; // TypeScript knows it's branded
- * }
- * ```
- */
-export function isBranded(_value) {
-    // At runtime, branded types are indistinguishable from their base type
-    // This function exists only for type narrowing
-    return true;
-}
-/**
- * Removes the brand from a branded type, returning the base type.
- *
- * Use this when you need to pass a branded value to a function that
- * expects the base type (e.g., logging, serialization).
- *
- * @template T - The base type
- * @template B - The brand identifier
- * @param value - The branded value
- * @returns The same value, but with the brand removed
- *
- * @example
- * ```typescript
- * const tenantId: TenantId = getTenantId();
- *
- * // Pass to function expecting plain string
- * console.log(unbrand(tenantId)); // string, not TenantId
- *
- * // Serialize to JSON
- * const json = JSON.stringify({ id: unbrand(tenantId) });
- * ```
- */
-export function unbrand(value) {
-    return value;
-}
-/**
- * Creates a type-safe brand factory with validation.
- *
- * This is the RECOMMENDED way to create brand types with runtime validation.
- *
- * @template T - The base type
- * @template B - The brand identifier
- * @param schema - Zod schema for validation
- * @param brandName - The brand identifier
- * @returns Object with parse, create, and is methods
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- *
- * const TenantId = createBrandFactory(
- *   z.string().uuid(),
- *   'TenantId'
- * );
- *
- * // Type-safe parsing with validation
- * const result = TenantId.parse(userInput);
- * if (result.success) {
- *   const tenantId = result.data; // Brand<string, 'TenantId'>
- * }
- *
- * // Create new ID
- * const newId = TenantId.create(); // Generates UUID
- *
- * // Type guard
- * if (TenantId.is(value)) {
- *   // value is Brand<string, 'TenantId'>
- * }
- * ```
- */
-export function createBrandFactory(schema, brandName) {
-    return {
-        /**
-         * The Zod schema with brand transformation.
-         */
-        schema: {
-            parse: (input) => {
-                const validated = schema.parse(input);
-                return brand(validated);
-            },
-            safeParse: (input) => {
-                const result = schema.safeParse(input);
-                if (result.success) {
-                    return { success: true, data: brand(result.data) };
-                }
-                return { success: false, error: result.error };
-            },
-        },
-        /**
-         * Parse and validate input, returning branded value.
-         * Throws on validation failure.
-         */
-        parse: (input) => {
-            const validated = schema.parse(input);
-            return brand(validated);
-        },
-        /**
-         * Type guard to check if a value is this brand.
-         */
-        is: (value) => {
-            const result = schema.safeParse(value);
-            return result.success;
-        },
-        /**
-         * Brand name identifier.
-         */
-        brandName,
-    };
-}
-/**
- * BEST PRACTICES SUMMARY:
- * =======================
- *
- * 1. ALWAYS validate at boundaries:
- *    - API inputs: Use Zod schemas
- *    - Database outputs: Use Zod schemas
- *    - File I/O: Use Zod schemas
- *    - CLI args: Use Zod schemas
- *
- * 2. NEVER cast to brand types:
- *    ❌ const id = userInput as TenantId;
- *    ✅ const id = TenantIdSchema.parse(userInput);
- *
- * 3. Use createBrandFactory for all brand types:
- *    - Provides validation
- *    - Provides type guards
- *    - Centralizes brand creation
- *
- * 4. Document which functions validate:
- *    ```typescript
- *    // @validates TenantId - performs Zod validation
- *    function parseTenantId(input: string): TenantId {
- *      return TenantIdSchema.parse(input);
- *    }
- *
- *    // @assumes TenantId - no validation, requires validated input
- *    function formatTenantId(id: TenantId): string {
- *      return `tenant:${unbrand(id)}`;
- *    }
- *    ```
- *
- * 5. Test brand type enforcement:
- *    ```typescript
- *    // Should fail to compile
- *    const apiKey: ApiKeyId = getTenantId(); // ❌
- *    ```
- */
-//# sourceMappingURL=brand-types.js.map

package/packages/schemas/dist/public/core/brand-types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"brand-types.js","sourceRoot":"","sources":["../../../src/public/core/brand-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAuDH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,KAAK,CAAsB,KAAQ;IACjD,OAAO,KAAoB,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,SAAS,CACvB,MAAe;IAEf,uEAAuE;IACvE,+CAA+C;IAC/C,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,OAAO,CAAsB,KAAkB;IAC7D,OAAO,KAAU,CAAC;AACpB,CAAC;AA4BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAwH,EACxH,SAAY;IAEZ,OAAO;QACL;;WAEG;QACH,MAAM,EAAE;YACN,KAAK,EAAE,CAAC,KAAc,EAAe,EAAE;gBACrC,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACtC,OAAO,KAAK,CAAO,SAAS,CAAC,CAAC;YAChC,CAAC;YACD,SAAS,EAAE,CAAC,KAAc,EAA6E,EAAE;gBACvG,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;gBACvC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;oBACnB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAO,MAAM,CAAC,IAAS,CAAC,EAAE,CAAC;gBAChE,CAAC;gBACD,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;YACjD,CAAC;SACF;QAED;;;WAGG;QACH,KAAK,EAAE,CAAC,KAAc,EAAe,EAAE;YACrC,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACtC,OAAO,KAAK,CAAO,SAAS,CAAC,CAAC;QAChC,CAAC;QAED;;WAEG;QACH,EAAE,EAAE,CAAC,KAAc,EAAwB,EAAE;YAC3C,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACvC,OAAO,MAAM,CAAC,OAAO,CAAC;QACxB,CAAC;QAED;;WAEG;QACH,SAAS;KACV,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG"}

package/packages/schemas/dist/public/core/enums.d.ts

@@ -1,227 +0,0 @@
-/**
- * Centralized Enums for @ax-cli/schemas
- *
- * This file contains all enumeration types used across the ax-cli ecosystem.
- * Using Zod enums provides:
- * - Runtime validation
- * - TypeScript type inference
- * - Exhaustiveness checking
- * - Auto-completion support
- *
- * SECURITY: Always validate enum values at system boundaries (API, file I/O, CLI args).
- *
- * @module enums
- */
-import { z } from 'zod';
-/**
- * Message Role Enum - Roles for chat messages in AI conversations
- *
- * Used in:
- * - GrokMessageSchema (src/grok/types.ts)
- * - Chat message payloads
- * - Message history tracking
- *
- * @security MUST validate at API boundaries when accepting message objects
- *
- * @example
- * ```typescript
- * const roleResult = MessageRoleEnum.safeParse(userInput);
- * if (roleResult.success) {
- *   const role = roleResult.data; // 'system' | 'user' | 'assistant' | 'tool'
- * }
- * ```
- */
-export declare const MessageRoleEnum: z.ZodEnum<["system", "user", "assistant", "tool"]>;
-/**
- * Extract the TypeScript type from MessageRoleEnum
- */
-export type MessageRole = z.infer<typeof MessageRoleEnum>;
-/**
- * Finish Reason Enum - Reasons why an AI response completed
- *
- * Used in:
- * - GrokResponseSchema (src/grok/types.ts)
- * - API response tracking
- * - Usage analytics
- *
- * Values:
- * - `stop`: Natural completion (model decided to stop)
- * - `length`: Stopped due to max token limit
- * - `tool_calls`: Stopped to execute tool calls
- * - `content_filter`: Stopped due to content policy violation
- *
- * @security MUST validate at API boundaries
- *
- * @example
- * ```typescript
- * const result = FinishReasonEnum.safeParse(response.finish_reason);
- * if (result.success) {
- *   switch (result.data) {
- *     case 'stop':
- *       // Natural completion
- *       break;
- *     case 'length':
- *       // Truncated response
- *       break;
- *     case 'tool_calls':
- *       // Need to execute tools
- *       break;
- *     case 'content_filter':
- *       // Content policy violation
- *       break;
- *   }
- * }
- * ```
- */
-export declare const FinishReasonEnum: z.ZodEnum<["stop", "length", "tool_calls", "content_filter"]>;
-/**
- * Extract the TypeScript type from FinishReasonEnum
- */
-export type FinishReason = z.infer<typeof FinishReasonEnum>;
-/**
- * Transport Enum - Communication protocols for MCP servers
- *
- * Used in:
- * - MCPServerConfigSchema (src/mcp/config.ts)
- * - MCP server initialization
- * - Transport layer selection
- *
- * Values:
- * - `stdio`: Standard input/output (for local processes)
- * - `http`: HTTP protocol (for remote servers)
- * - `sse`: Server-Sent Events (for streaming)
- *
- * @security MUST validate at MCP configuration boundaries
- *
- * @example
- * ```typescript
- * const config = {
- *   transport: TransportEnum.parse('stdio'),
- *   command: 'node',
- *   args: ['server.js']
- * };
- * ```
- */
-export declare const TransportEnum: z.ZodEnum<["stdio", "http", "sse"]>;
-/**
- * Extract the TypeScript type from TransportEnum
- */
-export type Transport = z.infer<typeof TransportEnum>;
-/**
- * Editor Command Enum - Commands for text editor tool
- *
- * Used in:
- * - EditorCommand interface (src/tools/text-editor.ts)
- * - Text editing operations
- * - Command validation
- *
- * Values:
- * - `view`: View file contents (read-only)
- * - `str_replace`: Replace string in file (search and replace)
- * - `create`: Create new file with content
- * - `insert`: Insert content at specific line
- * - `undo_edit`: Undo the last edit operation
- *
- * @security MUST validate at tool execution boundaries
- * @security Command execution should be sandboxed to prevent file system abuse
- *
- * @example
- * ```typescript
- * const command = EditorCommandEnum.parse('str_replace');
- * switch (command) {
- *   case 'view':
- *     return viewFile(path);
- *   case 'str_replace':
- *     return replaceString(path, oldStr, newStr);
- *   case 'create':
- *     return createFile(path, content);
- *   case 'insert':
- *     return insertContent(path, line, content);
- *   case 'undo_edit':
- *     return undoLastEdit();
- * }
- * ```
- */
-export declare const EditorCommandEnum: z.ZodEnum<["view", "str_replace", "create", "insert", "undo_edit"]>;
-/**
- * Extract the TypeScript type from EditorCommandEnum
- */
-export type EditorCommand = z.infer<typeof EditorCommandEnum>;
-/**
- * EXHAUSTIVENESS CHECKING EXAMPLES
- *
- * Zod enums enable TypeScript exhaustiveness checking via switch statements:
- *
- * ```typescript
- * function handleFinishReason(reason: FinishReason): string {
- *   switch (reason) {
- *     case 'stop':
- *       return 'Completed successfully';
- *     case 'length':
- *       return 'Reached token limit';
- *     case 'tool_calls':
- *       return 'Executing tools';
- *     case 'content_filter':
- *       return 'Content filtered';
- *     // TypeScript will error if any case is missing!
- *   }
- * }
- * ```
- *
- * VALIDATION AT BOUNDARIES
- *
- * Always validate enum values from external sources:
- *
- * ```typescript
- * // API endpoint
- * app.post('/api/message', (req, res) => {
- *   const roleResult = MessageRoleEnum.safeParse(req.body.role);
- *   if (!roleResult.success) {
- *     return res.status(400).json({
- *       error: 'Invalid message role',
- *       details: roleResult.error
- *     });
- *   }
- *
- *   // Safe to use - validated
- *   const message = createMessage(roleResult.data, req.body.content);
- * });
- * ```
- *
- * MIGRATION FROM STRING LITERALS
- *
- * Before (unsafe):
- * ```typescript
- * type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
- * const role: MessageRole = userInput as MessageRole; // No runtime validation!
- * ```
- *
- * After (safe):
- * ```typescript
- * const roleResult = MessageRoleEnum.safeParse(userInput);
- * if (roleResult.success) {
- *   const role: MessageRole = roleResult.data; // Validated!
- * }
- * ```
- */
-/**
- * BEST PRACTICES SUMMARY
- *
- * 1. **Always validate at boundaries:**
- *    - Use `.safeParse()` for user input
- *    - Use `.parse()` when you want to throw on invalid input
- *
- * 2. **Use exhaustive switch statements:**
- *    - TypeScript will warn if you miss a case
- *    - Helps catch bugs when enums are extended
- *
- * 3. **Document enum usage:**
- *    - List where each enum is used
- *    - Explain what each value means
- *    - Note security implications
- *
- * 4. **Never cast to enum types:**
- *    - ❌ `const role = userInput as MessageRole`
- *    - ✅ `const role = MessageRoleEnum.parse(userInput)`
- */
-//# sourceMappingURL=enums.d.ts.map

package/packages/schemas/dist/public/core/enums.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../src/public/core/enums.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,oDAAkD,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,gBAAgB,+DAK3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,aAAa,qCAAmC,CAAC;AAE9D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,iBAAiB,qEAM5B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG"}

package/packages/schemas/dist/public/core/enums.js

@@ -1,222 +0,0 @@
-/**
- * Centralized Enums for @ax-cli/schemas
- *
- * This file contains all enumeration types used across the ax-cli ecosystem.
- * Using Zod enums provides:
- * - Runtime validation
- * - TypeScript type inference
- * - Exhaustiveness checking
- * - Auto-completion support
- *
- * SECURITY: Always validate enum values at system boundaries (API, file I/O, CLI args).
- *
- * @module enums
- */
-import { z } from 'zod';
-/**
- * Message Role Enum - Roles for chat messages in AI conversations
- *
- * Used in:
- * - GrokMessageSchema (src/grok/types.ts)
- * - Chat message payloads
- * - Message history tracking
- *
- * @security MUST validate at API boundaries when accepting message objects
- *
- * @example
- * ```typescript
- * const roleResult = MessageRoleEnum.safeParse(userInput);
- * if (roleResult.success) {
- *   const role = roleResult.data; // 'system' | 'user' | 'assistant' | 'tool'
- * }
- * ```
- */
-export const MessageRoleEnum = z.enum(['system', 'user', 'assistant', 'tool']);
-/**
- * Finish Reason Enum - Reasons why an AI response completed
- *
- * Used in:
- * - GrokResponseSchema (src/grok/types.ts)
- * - API response tracking
- * - Usage analytics
- *
- * Values:
- * - `stop`: Natural completion (model decided to stop)
- * - `length`: Stopped due to max token limit
- * - `tool_calls`: Stopped to execute tool calls
- * - `content_filter`: Stopped due to content policy violation
- *
- * @security MUST validate at API boundaries
- *
- * @example
- * ```typescript
- * const result = FinishReasonEnum.safeParse(response.finish_reason);
- * if (result.success) {
- *   switch (result.data) {
- *     case 'stop':
- *       // Natural completion
- *       break;
- *     case 'length':
- *       // Truncated response
- *       break;
- *     case 'tool_calls':
- *       // Need to execute tools
- *       break;
- *     case 'content_filter':
- *       // Content policy violation
- *       break;
- *   }
- * }
- * ```
- */
-export const FinishReasonEnum = z.enum([
-    'stop',
-    'length',
-    'tool_calls',
-    'content_filter',
-]);
-/**
- * Transport Enum - Communication protocols for MCP servers
- *
- * Used in:
- * - MCPServerConfigSchema (src/mcp/config.ts)
- * - MCP server initialization
- * - Transport layer selection
- *
- * Values:
- * - `stdio`: Standard input/output (for local processes)
- * - `http`: HTTP protocol (for remote servers)
- * - `sse`: Server-Sent Events (for streaming)
- *
- * @security MUST validate at MCP configuration boundaries
- *
- * @example
- * ```typescript
- * const config = {
- *   transport: TransportEnum.parse('stdio'),
- *   command: 'node',
- *   args: ['server.js']
- * };
- * ```
- */
-export const TransportEnum = z.enum(['stdio', 'http', 'sse']);
-/**
- * Editor Command Enum - Commands for text editor tool
- *
- * Used in:
- * - EditorCommand interface (src/tools/text-editor.ts)
- * - Text editing operations
- * - Command validation
- *
- * Values:
- * - `view`: View file contents (read-only)
- * - `str_replace`: Replace string in file (search and replace)
- * - `create`: Create new file with content
- * - `insert`: Insert content at specific line
- * - `undo_edit`: Undo the last edit operation
- *
- * @security MUST validate at tool execution boundaries
- * @security Command execution should be sandboxed to prevent file system abuse
- *
- * @example
- * ```typescript
- * const command = EditorCommandEnum.parse('str_replace');
- * switch (command) {
- *   case 'view':
- *     return viewFile(path);
- *   case 'str_replace':
- *     return replaceString(path, oldStr, newStr);
- *   case 'create':
- *     return createFile(path, content);
- *   case 'insert':
- *     return insertContent(path, line, content);
- *   case 'undo_edit':
- *     return undoLastEdit();
- * }
- * ```
- */
-export const EditorCommandEnum = z.enum([
-    'view',
-    'str_replace',
-    'create',
-    'insert',
-    'undo_edit',
-]);
-/**
- * EXHAUSTIVENESS CHECKING EXAMPLES
- *
- * Zod enums enable TypeScript exhaustiveness checking via switch statements:
- *
- * ```typescript
- * function handleFinishReason(reason: FinishReason): string {
- *   switch (reason) {
- *     case 'stop':
- *       return 'Completed successfully';
- *     case 'length':
- *       return 'Reached token limit';
- *     case 'tool_calls':
- *       return 'Executing tools';
- *     case 'content_filter':
- *       return 'Content filtered';
- *     // TypeScript will error if any case is missing!
- *   }
- * }
- * ```
- *
- * VALIDATION AT BOUNDARIES
- *
- * Always validate enum values from external sources:
- *
- * ```typescript
- * // API endpoint
- * app.post('/api/message', (req, res) => {
- *   const roleResult = MessageRoleEnum.safeParse(req.body.role);
- *   if (!roleResult.success) {
- *     return res.status(400).json({
- *       error: 'Invalid message role',
- *       details: roleResult.error
- *     });
- *   }
- *
- *   // Safe to use - validated
- *   const message = createMessage(roleResult.data, req.body.content);
- * });
- * ```
- *
- * MIGRATION FROM STRING LITERALS
- *
- * Before (unsafe):
- * ```typescript
- * type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
- * const role: MessageRole = userInput as MessageRole; // No runtime validation!
- * ```
- *
- * After (safe):
- * ```typescript
- * const roleResult = MessageRoleEnum.safeParse(userInput);
- * if (roleResult.success) {
- *   const role: MessageRole = roleResult.data; // Validated!
- * }
- * ```
- */
-/**
- * BEST PRACTICES SUMMARY
- *
- * 1. **Always validate at boundaries:**
- *    - Use `.safeParse()` for user input
- *    - Use `.parse()` when you want to throw on invalid input
- *
- * 2. **Use exhaustive switch statements:**
- *    - TypeScript will warn if you miss a case
- *    - Helps catch bugs when enums are extended
- *
- * 3. **Document enum usage:**
- *    - List where each enum is used
- *    - Explain what each value means
- *    - Note security implications
- *
- * 4. **Never cast to enum types:**
- *    - ❌ `const role = userInput as MessageRole`
- *    - ✅ `const role = MessageRoleEnum.parse(userInput)`
- */
-//# sourceMappingURL=enums.js.map