popeye-cli 2.0.0 → 2.2.0

package/src/pipeline/skills/generator.ts

@@ -0,0 +1,287 @@
+/**
+ * Project-specific skill generation.
+ * Uses a single AI call to generate tailored system prompts for active roles,
+ * then writes them as .md files with YAML frontmatter to the project's skills/ dir.
+ * Falls back to defaults with project-specific constraints on AI failure.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+
+import type { PipelineRole } from '../types.js';
+import type { ArtifactManager } from '../artifact-manager.js';
+import { DEFAULT_SKILLS } from './defaults.js';
+import { inferTechStack, getTemplateConstraints } from './role-map.js';
+import type { SkillGenerationContext, SkillsGenerationMarker, TechStack } from './types.js';
+
+// ─── Constants ──────────────────────────────────────────
+
+const PIPELINE_VERSION = '1.0';
+const MARKER_FILENAME = '.popeye-skills-generated.json';
+
+/** Zod schema for validating AI-generated skill prompts */
+const SkillPromptsResponseSchema = z.record(z.string(), z.string());
+
+// ─── Public API ─────────────────────────────────────────
+
+/**
+ * Generate project-specific skill .md files for all active roles.
+ * Skips roles that already have a .md file in the skills directory.
+ * Stores the raw AI response as a skill_generation_log artifact.
+ *
+ * @param context - Skill generation context with project details
+ * @param artifactManager - Optional artifact manager for logging
+ */
+export async function generateProjectSkills(
+  context: SkillGenerationContext,
+  artifactManager?: ArtifactManager,
+): Promise<void> {
+  const { activeRoles, skillsDir } = context;
+
+  // Ensure skills directory exists
+  if (!existsSync(skillsDir)) {
+    mkdirSync(skillsDir, { recursive: true });
+  }
+
+  // Determine which roles need generation
+  const rolesToGenerate = activeRoles.filter((role) => shouldGenerateSkill(skillsDir, role));
+
+  if (rolesToGenerate.length === 0) {
+    return;
+  }
+
+  // Infer tech stack
+  const techStack = inferTechStack(context.language, context.snapshot, context.expandedSpec);
+
+  // Attempt AI generation
+  let aiPrompts: Record<string, string> = {};
+  let aiGenerated = false;
+
+  try {
+    const prompt = buildSkillGenPrompt(context, rolesToGenerate, techStack);
+    const { createClient } = await import('../../adapters/openai.js');
+    const client = await createClient();
+
+    const completion = await client.chat.completions.create({
+      model: 'gpt-4.1',
+      messages: [{ role: 'user', content: prompt }],
+      temperature: 0.4,
+      max_tokens: 4096,
+    });
+
+    const rawResponse = completion.choices[0]?.message?.content ?? '';
+
+    // Store raw AI response as artifact
+    if (artifactManager) {
+      artifactManager.createAndStoreText(
+        'skill_generation_log',
+        rawResponse,
+        'INTAKE',
+      );
+    }
+
+    aiPrompts = parseSkillPrompts(rawResponse, rolesToGenerate);
+    aiGenerated = Object.keys(aiPrompts).length > 0;
+  } catch {
+    // AI failure is non-fatal — fall through to defaults with project constraints
+    aiGenerated = false;
+  }
+
+  // Write skill files
+  for (const role of rolesToGenerate) {
+    const defaultSkill = DEFAULT_SKILLS[role];
+    const systemPrompt = aiPrompts[role] ?? defaultSkill?.systemPrompt ?? '';
+    const constraints = getTemplateConstraints(role, techStack);
+    const allConstraints = [
+      ...(defaultSkill?.constraints ?? []),
+      ...constraints,
+    ];
+    // Deduplicate constraints
+    const uniqueConstraints = [...new Set(allConstraints)];
+    const dependsOn = defaultSkill?.depends_on ?? [];
+    const requiredOutputs = defaultSkill?.required_outputs ?? [];
+
+    const markdown = renderSkillMarkdown(
+      role,
+      systemPrompt,
+      uniqueConstraints,
+      requiredOutputs,
+      dependsOn,
+    );
+
+    const filePath = join(skillsDir, `${role}.md`);
+    writeFileSync(filePath, markdown, 'utf-8');
+  }
+
+  // Write generation marker
+  const marker: SkillsGenerationMarker = {
+    timestamp: new Date().toISOString(),
+    pipelineVersion: PIPELINE_VERSION,
+    activeRoles: activeRoles.map(String),
+    techStack,
+    aiGenerated,
+  };
+  writeGenerationMarker(skillsDir, marker);
+}
+
+// ─── Skip Logic ─────────────────────────────────────────
+
+/**
+ * Check if a skill file should be generated for a role.
+ * Returns false if the role already has a .md file (hand-written or prior run).
+ *
+ * @param skillsDir - Path to the skills directory
+ * @param role - Pipeline role to check
+ * @returns true if the role needs a generated skill file
+ */
+export function shouldGenerateSkill(skillsDir: string, role: PipelineRole): boolean {
+  const mdPath = join(skillsDir, `${role}.md`);
+  return !existsSync(mdPath);
+}
+
+// ─── Prompt Building ────────────────────────────────────
+
+/**
+ * Build the AI prompt that requests system prompts for all roles at once.
+ *
+ * @param context - Generation context
+ * @param roles - Roles needing prompts
+ * @param techStack - Inferred tech stack
+ * @returns Formatted prompt string
+ */
+export function buildSkillGenPrompt(
+  context: SkillGenerationContext,
+  roles: PipelineRole[],
+  techStack: TechStack,
+): string {
+  const techDesc = Object.entries(techStack)
+    .filter(([, v]) => v)
+    .map(([k, v]) => `- ${k}: ${v}`)
+    .join('\n');
+
+  const roleDescriptions = roles.map((role) => {
+    const defaultSkill = DEFAULT_SKILLS[role];
+    return `- ${role}: ${defaultSkill?.systemPrompt.slice(0, 100) ?? 'Pipeline role'}...`;
+  }).join('\n');
+
+  return `You are generating project-specific skill definitions for an AI pipeline.
+
+## Project: ${context.projectName}
+## Tech Stack:
+${techDesc}
+
+## Expanded Specification (summary):
+${context.expandedSpec.slice(0, 3000)}
+
+${context.sessionGuidance ? `## Session Guidance:\n${context.sessionGuidance.slice(0, 1000)}\n` : ''}
+## Roles needing prompts:
+${roleDescriptions}
+
+## Instructions:
+Generate a tailored system prompt for each role listed above. Each prompt should:
+1. Reference the specific tech stack (e.g., "FastAPI async endpoints" not "API endpoints")
+2. Reference the project name
+3. Be 3-6 sentences
+4. Focus on the role's responsibilities in this specific project context
+
+Respond with ONLY a JSON object mapping role names to their system prompts. Example:
+{"BACKEND_PROGRAMMER": "You are the Backend Programmer for ProjectName. You implement..."}
+
+JSON response:`;
+}
+
+// ─── Response Parsing ───────────────────────────────────
+
+/**
+ * Parse and validate the AI response as a JSON record of role prompts.
+ * Falls back per-role: missing or invalid entries are excluded.
+ *
+ * @param response - Raw AI response text
+ * @param expectedRoles - Roles we requested prompts for
+ * @returns Validated record of role -> system prompt
+ */
+export function parseSkillPrompts(
+  response: string,
+  expectedRoles: PipelineRole[],
+): Record<string, string> {
+  try {
+    // Extract JSON from response (may be wrapped in markdown code fences)
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return {};
+
+    const parsed = JSON.parse(jsonMatch[0]);
+    const validated = SkillPromptsResponseSchema.parse(parsed);
+
+    // Filter to only expected roles with non-empty prompts
+    const result: Record<string, string> = {};
+    for (const role of expectedRoles) {
+      if (validated[role] && validated[role].trim().length > 10) {
+        result[role] = validated[role].trim();
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// ─── Markdown Rendering ─────────────────────────────────
+
+/**
+ * Render a skill definition as a Markdown file with YAML frontmatter.
+ * Format matches what the SkillLoader's parseSkillMarkdown() expects.
+ *
+ * @param role - Pipeline role
+ * @param systemPrompt - The system prompt body
+ * @param constraints - Combined constraint identifiers
+ * @param requiredOutputs - Required output types
+ * @param dependsOn - Upstream role dependencies
+ * @returns Complete markdown string
+ */
+export function renderSkillMarkdown(
+  role: PipelineRole,
+  systemPrompt: string,
+  constraints: string[],
+  requiredOutputs: string[],
+  dependsOn: PipelineRole[],
+): string {
+  const lines: string[] = [
+    '---',
+    `role: ${role}`,
+    'version: 1.0-project',
+    'required_outputs:',
+    ...requiredOutputs.map((o) => `  - ${o}`),
+    'constraints:',
+    ...constraints.map((c) => `  - ${c}`),
+  ];
+
+  if (dependsOn.length > 0) {
+    lines.push('depends_on:');
+    for (const dep of dependsOn) {
+      lines.push(`  - ${dep}`);
+    }
+  }
+
+  lines.push('---');
+  lines.push(systemPrompt);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ─── Marker File ────────────────────────────────────────
+
+/**
+ * Write the generation marker file to track what was generated.
+ *
+ * @param skillsDir - Path to the skills directory
+ * @param marker - Marker data to persist
+ */
+export function writeGenerationMarker(
+  skillsDir: string,
+  marker: SkillsGenerationMarker,
+): void {
+  const markerPath = join(skillsDir, MARKER_FILENAME);
+  writeFileSync(markerPath, JSON.stringify(marker, null, 2), 'utf-8');
+}

package/src/pipeline/skills/role-map.ts

@@ -0,0 +1,248 @@
+/**
+ * Shared role mapping and tech stack inference.
+ * Extracted from migration.ts to be the single source of truth for
+ * language-to-role mapping and tech stack detection.
+ */
+
+import type { OutputLanguage } from '../../types/project.js';
+import type { PipelineRole, RepoSnapshot } from '../types.js';
+import type { TechStack } from './types.js';
+
+// ─── Role Categories ────────────────────────────────────
+
+/** Roles that always participate regardless of language */
+export const SUPPORT_ROLES: PipelineRole[] = [
+  'DISPATCHER',
+  'ARCHITECT',
+  'QA_TESTER',
+  'REVIEWER',
+  'ARBITRATOR',
+  'DEBUGGER',
+  'AUDITOR',
+  'JOURNALIST',
+  'RELEASE_MANAGER',
+];
+
+/** Language-specific implementation role sets */
+const IMPLEMENTATION_ROLE_MAP: Record<OutputLanguage, PipelineRole[]> = {
+  python: ['DB_EXPERT', 'BACKEND_PROGRAMMER'],
+  typescript: ['FRONTEND_PROGRAMMER', 'UI_UX_SPECIALIST'],
+  fullstack: ['DB_EXPERT', 'BACKEND_PROGRAMMER', 'FRONTEND_PROGRAMMER', 'UI_UX_SPECIALIST'],
+  website: ['WEBSITE_PROGRAMMER', 'UI_UX_SPECIALIST', 'MARKETING_EXPERT', 'SOCIAL_EXPERT'],
+  all: [
+    'DB_EXPERT', 'BACKEND_PROGRAMMER', 'FRONTEND_PROGRAMMER',
+    'WEBSITE_PROGRAMMER', 'UI_UX_SPECIALIST', 'MARKETING_EXPERT', 'SOCIAL_EXPERT',
+  ],
+};
+
+/** All possible implementation roles across all languages */
+export const IMPLEMENTATION_ROLES: PipelineRole[] = [
+  'DB_EXPERT', 'BACKEND_PROGRAMMER', 'FRONTEND_PROGRAMMER',
+  'WEBSITE_PROGRAMMER', 'UI_UX_SPECIALIST', 'MARKETING_EXPERT', 'SOCIAL_EXPERT',
+];
+
+// ─── Active Role Selection ──────────────────────────────
+
+/**
+ * Determine the active roles for a given language.
+ *
+ * @param language - The project's output language
+ * @returns All roles (support + implementation) active for this language
+ */
+export function getActiveRoles(language: OutputLanguage): PipelineRole[] {
+  const implRoles = IMPLEMENTATION_ROLE_MAP[language] ?? ['BACKEND_PROGRAMMER'];
+  return [...SUPPORT_ROLES, ...implRoles];
+}
+
+// ─── Tech Stack Inference ───────────────────────────────
+
+/** Framework detection patterns for snapshot config key_fields */
+const FRAMEWORK_PATTERNS: Record<string, Partial<TechStack>> = {
+  fastapi: { backend: 'FastAPI' },
+  django: { backend: 'Django' },
+  flask: { backend: 'Flask' },
+  express: { backend: 'Express' },
+  nestjs: { backend: 'NestJS' },
+  'next': { frontend: 'Next.js' },
+  nuxt: { frontend: 'Nuxt' },
+  react: { frontend: 'React' },
+  vue: { frontend: 'Vue' },
+  svelte: { frontend: 'SvelteKit' },
+  angular: { frontend: 'Angular' },
+  sqlalchemy: { orm: 'SQLAlchemy' },
+  prisma: { orm: 'Prisma' },
+  drizzle: { orm: 'Drizzle' },
+  typeorm: { orm: 'TypeORM' },
+  sequelize: { orm: 'Sequelize' },
+  postgresql: { database: 'PostgreSQL' },
+  postgres: { database: 'PostgreSQL' },
+  mysql: { database: 'MySQL' },
+  sqlite: { database: 'SQLite' },
+  mongodb: { database: 'MongoDB' },
+  mongoose: { database: 'MongoDB' },
+  pytest: { testing: 'Pytest' },
+  vitest: { testing: 'Vitest' },
+  jest: { testing: 'Jest' },
+  mocha: { testing: 'Mocha' },
+};
+
+/** Language-based defaults when no signals are available */
+const LANGUAGE_DEFAULTS: Record<OutputLanguage, TechStack> = {
+  python: {
+    language: 'Python 3.11+',
+    backend: 'FastAPI',
+    database: 'PostgreSQL',
+    orm: 'SQLAlchemy',
+    testing: 'Pytest',
+  },
+  typescript: {
+    language: 'TypeScript 5.x',
+    frontend: 'React + Vite',
+    testing: 'Vitest',
+  },
+  fullstack: {
+    language: 'TypeScript 5.x / Python 3.11+',
+    backend: 'FastAPI',
+    frontend: 'React + Vite',
+    database: 'PostgreSQL',
+    orm: 'SQLAlchemy',
+    testing: 'Vitest + Pytest',
+  },
+  website: {
+    language: 'TypeScript 5.x',
+    frontend: 'Next.js',
+    testing: 'Vitest',
+  },
+  all: {
+    language: 'TypeScript 5.x / Python 3.11+',
+    backend: 'FastAPI',
+    frontend: 'React + Vite',
+    database: 'PostgreSQL',
+    orm: 'SQLAlchemy',
+    testing: 'Vitest + Pytest',
+  },
+};
+
+/**
+ * Infer the project's tech stack from available signals.
+ * Priority: snapshot deps > spec mentions > language defaults.
+ *
+ * @param language - The project's output language
+ * @param snapshot - Optional repo snapshot with config file data
+ * @param expandedSpec - Optional expanded specification text
+ * @returns Inferred tech stack
+ */
+export function inferTechStack(
+  language: OutputLanguage,
+  snapshot?: RepoSnapshot,
+  expandedSpec?: string,
+): TechStack {
+  const defaults = LANGUAGE_DEFAULTS[language] ?? LANGUAGE_DEFAULTS.python;
+  const detected: TechStack = { language: defaults.language };
+
+  // 1. Scan snapshot config_files key_fields for dependency signals
+  //    Only set each field once — first match wins per field.
+  if (snapshot?.config_files) {
+    for (const configFile of snapshot.config_files) {
+      const keyFieldsStr = JSON.stringify(configFile.key_fields).toLowerCase();
+      for (const [pattern, stack] of Object.entries(FRAMEWORK_PATTERNS)) {
+        if (keyFieldsStr.includes(pattern)) {
+          for (const [key, value] of Object.entries(stack)) {
+            if (!detected[key as keyof TechStack]) {
+              (detected as Record<string, string>)[key] = value;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // 2. Use snapshot test_framework / build_tool if available
+  if (snapshot?.test_framework) {
+    const tfLower = snapshot.test_framework.toLowerCase();
+    for (const [pattern, stack] of Object.entries(FRAMEWORK_PATTERNS)) {
+      if (tfLower.includes(pattern) && stack.testing) {
+        detected.testing = stack.testing;
+      }
+    }
+  }
+
+  // 3. Scan expandedSpec for framework mentions
+  if (expandedSpec) {
+    const specLower = expandedSpec.toLowerCase();
+    for (const [pattern, stack] of Object.entries(FRAMEWORK_PATTERNS)) {
+      if (specLower.includes(pattern)) {
+        // Only fill in gaps — snapshot deps take priority
+        for (const [key, value] of Object.entries(stack)) {
+          if (!detected[key as keyof TechStack]) {
+            (detected as Record<string, string>)[key] = value;
+          }
+        }
+      }
+    }
+  }
+
+  // 4. Fill remaining gaps with language defaults
+  for (const [key, value] of Object.entries(defaults)) {
+    if (!detected[key as keyof TechStack] && value) {
+      (detected as Record<string, string>)[key] = value;
+    }
+  }
+
+  return detected;
+}
+
+// ─── Template Constraints ───────────────────────────────
+
+/** Governance constraints added to every generated skill */
+const GOVERNANCE_CONSTRAINTS = [
+  'must_follow_master_plan',
+  'must_follow_architecture',
+  'conflicts_require_change_request',
+];
+
+/** Tech-stack-specific constraints per role */
+const TECH_CONSTRAINTS: Record<string, (ts: TechStack) => string[]> = {
+  BACKEND_PROGRAMMER: (ts) => {
+    const c: string[] = [];
+    if (ts.backend?.includes('FastAPI')) c.push('fastapi_async_required', 'pydantic_validation');
+    if (ts.backend?.includes('Django')) c.push('django_orm_required');
+    if (ts.backend?.includes('Express')) c.push('express_middleware_pattern');
+    if (ts.testing?.includes('Pytest')) c.push('pytest_testing');
+    if (ts.testing?.includes('Vitest') || ts.testing?.includes('Jest')) c.push('unit_test_required');
+    return c;
+  },
+  FRONTEND_PROGRAMMER: (ts) => {
+    const c: string[] = [];
+    if (ts.frontend?.includes('React')) c.push('react_component_pattern');
+    if (ts.frontend?.includes('Next')) c.push('nextjs_app_router');
+    if (ts.testing?.includes('Vitest') || ts.testing?.includes('Jest')) c.push('component_testing');
+    return c;
+  },
+  DB_EXPERT: (ts) => {
+    const c: string[] = [];
+    if (ts.database?.includes('PostgreSQL')) c.push('postgresql_best_practices');
+    if (ts.orm?.includes('SQLAlchemy')) c.push('sqlalchemy_migrations');
+    if (ts.orm?.includes('Prisma')) c.push('prisma_schema');
+    return c;
+  },
+  WEBSITE_PROGRAMMER: (ts) => {
+    const c: string[] = [];
+    if (ts.frontend?.includes('Next')) c.push('nextjs_ssg_ssr');
+    c.push('seo_required', 'responsive_design');
+    return c;
+  },
+};
+
+/**
+ * Get deterministic template constraints for a role based on tech stack.
+ *
+ * @param role - Pipeline role
+ * @param techStack - Inferred tech stack
+ * @returns Array of constraint identifiers
+ */
+export function getTemplateConstraints(role: PipelineRole, techStack: TechStack): string[] {
+  const techFn = TECH_CONSTRAINTS[role];
+  const techConstraints = techFn ? techFn(techStack) : [];
+  return [...GOVERNANCE_CONSTRAINTS, ...techConstraints];
+}

package/src/pipeline/skills/types.ts

@@ -0,0 +1,53 @@
+/**
+ * Type definitions for project-specific skill and constitution generation.
+ */
+
+import type { OutputLanguage } from '../../types/project.js';
+import type { PipelineRole, RepoSnapshot } from '../types.js';
+
+// ─── Tech Stack ─────────────────────────────────────────
+
+export interface TechStack {
+  backend?: string;
+  frontend?: string;
+  database?: string;
+  orm?: string;
+  testing?: string;
+  language?: string;
+}
+
+// ─── Skill Generation Context ───────────────────────────
+
+export interface SkillGenerationContext {
+  language: OutputLanguage;
+  expandedSpec: string;
+  snapshot: RepoSnapshot;
+  userDocs?: string;
+  sessionGuidance?: string;
+  brandContext?: { logoPath?: string; primaryColor?: string };
+  activeRoles: PipelineRole[];
+  skillsDir: string;
+  projectName: string;
+}
+
+// ─── Constitution Context ───────────────────────────────
+
+export interface ConstitutionContext {
+  language: OutputLanguage;
+  projectName: string;
+  techStack: TechStack;
+  expandedSpec: string;
+  sessionGuidance?: string;
+  brandContext?: { logoPath?: string; primaryColor?: string };
+  skillsDir: string;
+}
+
+// ─── Marker File ────────────────────────────────────────
+
+export interface SkillsGenerationMarker {
+  timestamp: string;
+  pipelineVersion: string;
+  activeRoles: string[];
+  techStack: TechStack;
+  aiGenerated: boolean;
+}

package/src/pipeline/type-defs/artifacts.ts

@@ -32,6 +32,8 @@ export const ArtifactTypeSchema = z.enum([
   'resolved_commands',
   'constitution',
   'change_request',
+  'additional_context',
+  'skill_generation_log',
 ]);
 export type ArtifactType = z.infer<typeof ArtifactTypeSchema>;
 

package/src/pipeline/type-defs/state.ts

@@ -97,6 +97,8 @@ export const PipelineStateSchema = z.object({
   resolvedCommands: ResolvedCommandsSchema.optional(),
   /** Tracks which phase failed, for recovery routing */
   failedPhase: PipelinePhaseSchema.optional(),
+  /** Session guidance: user steering, upgrade context, or resume instructions */
+  sessionGuidance: z.string().optional(),
   /** Pending change requests that force re-routing to consensus phases (v1.1) */
   pendingChangeRequests: z.array(z.object({
     cr_id: z.string(),

package/src/types/consensus.ts

@@ -101,8 +101,8 @@ export interface ConsensusConfig {
 export const DEFAULT_CONSENSUS_CONFIG: Omit<ConsensusConfig, 'openaiKey' | 'geminiKey' | 'grokKey'> = {
   threshold: 95,
   maxIterations: 10,
-  openaiModel: 'gpt-4o',
-  geminiModel: 'gemini-2.0-flash',
+  openaiModel: 'gpt-4.1',
+  geminiModel: 'gemini-2.5-flash',
   grokModel: DEFAULT_GROK_MODEL,
   reviewer: 'openai',
   arbitrator: 'gemini',
@@ -122,7 +122,19 @@ export const AIProviderSchema = z.enum(['openai', 'gemini', 'grok']);
 /**
  * Known Gemini models (used for suggestions and display, not strict validation)
  */
-export const KNOWN_GEMINI_MODELS = ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'] as const;
+export const KNOWN_GEMINI_MODELS = [
+  'gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite',
+  'gemini-2.0-flash', 'gemini-2.0-pro',
+  'gemini-1.5-pro', 'gemini-1.5-flash',
+] as const;
+
+/**
+ * Known Grok models (used for suggestions and display, not strict validation)
+ */
+export const KNOWN_GROK_MODELS = [
+  'grok-4-0709', 'grok-3', 'grok-3-mini',
+  'grok-3-fast', 'grok-3-mini-fast', 'grok-2',
+] as const;
 
 /**
  * Zod schema for Gemini model - accepts any non-empty string to support new models
@@ -144,7 +156,7 @@ export const ConsensusConfigSchema = z.object({
   geminiKey: z.string().optional(),
   grokKey: z.string().optional(),
   openaiModel: OpenAIModelSchema,
-  geminiModel: GeminiModelSchema.default('gemini-2.0-flash'),
+  geminiModel: GeminiModelSchema.default('gemini-2.5-flash'),
   grokModel: GrokModelSchema.default(DEFAULT_GROK_MODEL),
   reviewer: AIProviderSchema.default('openai'),
   arbitrator: AIProviderSchema.default('gemini'),

package/src/types/index.ts

@@ -58,6 +58,7 @@ export {
   DEFAULT_GROK_MODEL,
   AIProviderSchema,
   KNOWN_GEMINI_MODELS,
+  KNOWN_GROK_MODELS,
   GeminiModelSchema,
   GrokModelSchema,
   type AIProvider,