feat: add Codex CLI detection and model management APIs

- Implemented IPC handlers for checking Codex CLI installation status, retrieving available models, and checking provider statuses.
- Enhanced the SettingsView to include OpenAI API key management and connection testing.
- Updated the feature executor to support multiple model providers (Claude and Codex), allowing for improved flexibility in feature execution.
- Introduced utility functions to determine model types and support for thinking controls.

This update enhances the application's capabilities by integrating Codex CLI support and improving model management, providing users with a more robust experience.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

app/src/lib/electron.ts

@@ -42,7 +42,7 @@ export interface StatResult {
 }
 
 // Auto Mode types - Import from electron.d.ts to avoid duplication
-import type { AutoModeEvent } from "@/types/electron";
+import type { AutoModeEvent, ModelDefinition, ProviderStatus } from "@/types/electron";
 
 export interface AutoModeAPI {
   start: (projectPath: string) => Promise<{ success: boolean; error?: string }>;
@@ -94,6 +94,39 @@ export interface ElectronAPI {
     };
     error?: string;
   }>;
+  checkCodexCli?: () => Promise<{
+    success: boolean;
+    status?: string;
+    method?: string;
+    version?: string;
+    path?: string;
+    hasApiKey?: boolean;
+    recommendation?: string;
+    installCommands?: {
+      macos?: string;
+      windows?: string;
+      linux?: string;
+      npm?: string;
+    };
+    error?: string;
+  }>;
+  model?: {
+    getAvailable: () => Promise<{
+      success: boolean;
+      models?: ModelDefinition[];
+      error?: string;
+    }>;
+    checkProviders: () => Promise<{
+      success: boolean;
+      providers?: Record<string, ProviderStatus>;
+      error?: string;
+    }>;
+  };
+  testOpenAIConnection?: (apiKey?: string) => Promise<{
+    success: boolean;
+    message?: string;
+    error?: string;
+  }>;
 }
 
 declare global {
@@ -359,6 +392,28 @@ export const getElectronAPI = (): ElectronAPI => {
       return { success: true, path: tempFilePath };
     },
 
+    checkClaudeCli: async () => ({
+      success: false,
+      status: "not_installed",
+      recommendation: "Claude CLI checks are unavailable in the web preview.",
+    }),
+
+    checkCodexCli: async () => ({
+      success: false,
+      status: "not_installed",
+      recommendation: "Codex CLI checks are unavailable in the web preview.",
+    }),
+
+    model: {
+      getAvailable: async () => ({ success: true, models: [] }),
+      checkProviders: async () => ({ success: true, providers: {} }),
+    },
+
+    testOpenAIConnection: async () => ({
+      success: false,
+      error: "OpenAI connection test is only available in the Electron app.",
+    }),
+
     // Mock Auto Mode API
     autoMode: createMockAutoModeAPI(),
   };

app/src/lib/log-parser.ts

@@ -29,7 +29,27 @@ export interface LogEntry {
   };
 }
 
-const generateId = () => Math.random().toString(36).substring(2, 9);
+/**
+ * Generates a deterministic ID based on content and position
+ * This ensures the same log entry always gets the same ID,
+ * preserving expanded/collapsed state when new logs stream in
+ *
+ * Uses only the first 200 characters of content to ensure stability
+ * even when entries are merged (which appends content at the end)
+ */
+const generateDeterministicId = (content: string, lineIndex: number): string => {
+  // Use first 200 chars to ensure stability when entries are merged
+  const stableContent = content.slice(0, 200);
+  // Simple hash function for the content
+  let hash = 0;
+  const str = stableContent + '|' + lineIndex.toString();
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash; // Convert to 32bit integer
+  }
+  return 'log_' + Math.abs(hash).toString(36);
+};
 
 /**
  * Detects the type of log entry based on content patterns
@@ -165,24 +185,32 @@ export function parseLogOutput(rawOutput: string): LogEntry[] {
   const entries: LogEntry[] = [];
   const lines = rawOutput.split("\n");
 
-  let currentEntry: LogEntry | null = null;
+  let currentEntry: Omit<LogEntry, 'id'> & { id?: string } | null = null;
   let currentContent: string[] = [];
+  let entryStartLine = 0; // Track the starting line for deterministic ID generation
 
   const finalizeEntry = () => {
     if (currentEntry && currentContent.length > 0) {
       currentEntry.content = currentContent.join("\n").trim();
       if (currentEntry.content) {
-        entries.push(currentEntry);
+        // Generate deterministic ID based on content and position
+        const entryWithId: LogEntry = {
+          ...currentEntry as Omit<LogEntry, 'id'>,
+          id: generateDeterministicId(currentEntry.content, entryStartLine),
+        };
+        entries.push(entryWithId);
       }
     }
     currentContent = [];
   };
 
+  let lineIndex = 0;
   for (const line of lines) {
     const trimmedLine = line.trim();
 
     // Skip empty lines at the beginning
     if (!trimmedLine && !currentEntry) {
+      lineIndex++;
       continue;
     }
 
@@ -204,9 +232,11 @@ export function parseLogOutput(rawOutput: string): LogEntry[] {
       // Finalize previous entry
       finalizeEntry();
 
-      // Start new entry
+      // Track starting line for deterministic ID
+      entryStartLine = lineIndex;
+
+      // Start new entry (ID will be generated when finalizing)
       currentEntry = {
-        id: generateId(),
         type: lineType,
         title: generateTitle(lineType, trimmedLine),
         content: "",
@@ -220,15 +250,18 @@ export function parseLogOutput(rawOutput: string): LogEntry[] {
       // Continue current entry
       currentContent.push(line);
     } else {
+      // Track starting line for deterministic ID
+      entryStartLine = lineIndex;
+
       // No current entry, create a default info entry
       currentEntry = {
-        id: generateId(),
         type: "info",
         title: "Info",
         content: "",
       };
       currentContent.push(line);
     }
+    lineIndex++;
   }
 
   // Finalize last entry
@@ -248,6 +281,7 @@ function mergeConsecutiveEntries(entries: LogEntry[]): LogEntry[] {
 
   const merged: LogEntry[] = [];
   let current: LogEntry | null = null;
+  let mergeIndex = 0;
 
   for (const entry of entries) {
     if (
@@ -255,13 +289,15 @@ function mergeConsecutiveEntries(entries: LogEntry[]): LogEntry[] {
       (current.type === "debug" || current.type === "info") &&
       current.type === entry.type
     ) {
-      // Merge into current
+      // Merge into current - regenerate ID based on merged content
       current.content += "\n\n" + entry.content;
+      current.id = generateDeterministicId(current.content, mergeIndex);
     } else {
       if (current) {
         merged.push(current);
       }
       current = { ...entry };
+      mergeIndex = merged.length;
     }
   }
 

app/src/lib/utils.ts

@@ -1,6 +1,55 @@
 import { clsx, type ClassValue } from "clsx"
 import { twMerge } from "tailwind-merge"
+import type { AgentModel } from "@/store/app-store"
 
 export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs))
 }
+
+/**
+ * Check if a model is a Codex/OpenAI model (doesn't support thinking)
+ */
+export function isCodexModel(model?: AgentModel | string): boolean {
+  if (!model) return false;
+  const codexModels: string[] = [
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex",
+    "gpt-5.1-codex-mini",
+    "gpt-5.1",
+    "o3",
+    "o3-mini",
+    "o4-mini",
+    "gpt-4o",
+    "gpt-4o-mini",
+  ];
+  return codexModels.includes(model);
+}
+
+/**
+ * Determine if the current model supports extended thinking controls
+ */
+export function modelSupportsThinking(model?: AgentModel | string): boolean {
+  if (!model) return true;
+  return !isCodexModel(model);
+}
+
+/**
+ * Get display name for a model
+ */
+export function getModelDisplayName(model: AgentModel | string): string {
+  const displayNames: Record<string, string> = {
+    haiku: "Claude Haiku",
+    sonnet: "Claude Sonnet",
+    opus: "Claude Opus",
+    "gpt-5.1-codex-max": "GPT-5.1 Codex Max",
+    "gpt-5.1-codex": "GPT-5.1 Codex",
+    "gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",
+    "gpt-5.1": "GPT-5.1",
+    o3: "OpenAI O3",
+    "o3-mini": "OpenAI O3 Mini",
+    "o4-mini": "OpenAI O4 Mini",
+    "gpt-4o": "GPT-4o",
+    "gpt-4o-mini": "GPT-4o Mini",
+  };
+  return displayNames[model] || model;
+}