chore: clean up mini-chat debug logs and remove DevTools auto-open

This commit removes temporary debugging code from the mini-chat implementation
to keep the codebase clean and improve production performance.

## Changes

### Removed Debug Logs
- **MiniChatContainer.tsx**: Removed verbose logging from onFinish callback and message rendering
- **MiniChatRichMessage.tsx**: Removed part processing logs and transfer logs
- **MiniChatHeader.tsx**: Removed provider switching log
- **MiniChatInput.tsx**: Removed message sending logs

### DevTools Auto-Open Removed
- **miniChatWindow.ts**: Removed automatic DevTools opening in development mode
- Mini-chat window now opens without DevTools for cleaner UX

### Kept Error Logging
- ✅ console.error calls retained for actual error tracking
- ✅ Critical error paths still logged for debugging production issues

## Impact
- Cleaner console output in development
- Better performance without excessive logging
- More professional production behavior
- Easier debugging with focused error messages

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: 2 people

src/main/windows/miniChatWindow.ts

@@ -118,12 +118,6 @@ export function createMiniChatWindow(): BrowserWindow {
     return { action: 'deny' };
   });
 
-  // Open DevTools in development mode for debugging
-  if (process.env.NODE_ENV === 'development') {
-    miniChatWindow.webContents.openDevTools({ mode: 'detach' });
-    logger.core.debug('Mini chat DevTools opened for debugging');
-  }
-
   logger.core.info('Mini chat window created');
   return miniChatWindow;
 }

src/renderer/components/mini-chat/MiniChatContainer.tsx

@@ -69,25 +69,6 @@ export function MiniChatContainer() {
 
     // Persist messages after AI finishes
     onFinish: async ({ message }) => {
-      const messageContent = getMessageContent(message);
-      console.log('[MiniChat onFinish] AI response finished', {
-        messageId: message.id,
-        role: message.role,
-        hasContent: !!messageContent,
-        contentType: typeof messageContent,
-        hasParts: !!message.parts,
-        partsCount: message.parts?.length,
-        partsTypes: message.parts?.map((p: any) => typeof p),
-        partsDetail: message.parts?.map((p: any, i: number) => ({
-          index: i,
-          type: typeof p,
-          isObject: p && typeof p === 'object',
-          hasTypeKey: p && typeof p === 'object' && 'type' in p,
-          typeValue: p && typeof p === 'object' && 'type' in p ? p.type : 'N/A',
-          value: p
-        }))
-      });
-
       // Get latest session ID from store (avoid closure issue)
       const sessionId = useMiniChatStore.getState().currentSessionId;
 
@@ -99,42 +80,20 @@ export function MiniChatContainer() {
       // Persist the AI response using the same logic as main chat
       try {
         // Extract text content from parts (with type validation)
-        console.log('[MiniChat onFinish] Extracting text parts...');
         const textParts = message.parts?.filter((p: any) => {
-          const isValid = p && typeof p === 'object' && p.type === 'text';
-          console.log('[MiniChat onFinish] Checking part for text:', {
-            isValid,
-            partType: typeof p,
-            partTypeValue: p && typeof p === 'object' ? p.type : 'N/A',
-            part: p
-          });
-          return isValid;
+          return p && typeof p === 'object' && p.type === 'text';
         }) || [];
 
-        console.log('[MiniChat onFinish] Text parts found:', textParts.length);
-
         let content = textParts
           .map((p: any) => p.text)
           .join('\n')
           .trim();
 
-        console.log('[MiniChat onFinish] Extracted content:', content);
-
         // Extract tool calls from parts (with type validation)
-        console.log('[MiniChat onFinish] Extracting tool call parts...');
         const toolCallParts = message.parts?.filter((p: any) => {
-          const isValid = p && typeof p === 'object' && typeof p.type === 'string' && p.type.startsWith('tool-');
-          console.log('[MiniChat onFinish] Checking part for tool call:', {
-            isValid,
-            partType: typeof p,
-            partTypeValue: p && typeof p === 'object' && typeof p.type === 'string' ? p.type : 'N/A',
-            part: p
-          });
-          return isValid;
+          return p && typeof p === 'object' && typeof p.type === 'string' && p.type.startsWith('tool-');
         }) || [];
 
-        console.log('[MiniChat onFinish] Tool call parts found:', toolCallParts.length);
-
         let toolCallsData = null;
         if (toolCallParts.length > 0) {
           toolCallsData = toolCallParts.map((part: any) => ({
@@ -157,13 +116,7 @@ export function MiniChatContainer() {
           reasoningText: null,
         });
 
-        if (result.success) {
-          console.log('Mini-chat message persisted:', {
-            messageId: message.id,
-            sessionId,
-            role: message.role,
-          });
-        } else {
+        if (!result.success) {
           console.error('Failed to persist mini-chat message:', result.error);
         }
       } catch (error) {
@@ -210,29 +163,13 @@ export function MiniChatContainer() {
       {hasContent && (
         <StreamingProvider>
           <div ref={messagesRef} className="mini-chat-messages">
-            {messages.map((msg) => {
-              const msgContent = getMessageContent(msg);
-              console.log('[MiniChat] Rendering message:', {
-                id: msg.id,
-                role: msg.role,
-                hasContent: !!msgContent,
-                contentType: typeof msgContent,
-                contentLength: msgContent?.length,
-                hasParts: !!msg.parts,
-                partsLength: msg.parts?.length,
-                partsTypes: msg.parts?.map((p: any) => typeof p),
-                firstPartSample: msg.parts?.[0],
-                allPartsRaw: msg.parts
-              });
-
-              return (
-                <MiniChatMessage
-                  key={msg.id}
-                  message={msg}
-                  isStreaming={isStreaming && msg.id === messages[messages.length - 1]?.id}
-                />
-              );
-            })}
+            {messages.map((msg) => (
+              <MiniChatMessage
+                key={msg.id}
+                message={msg}
+                isStreaming={isStreaming && msg.id === messages[messages.length - 1]?.id}
+              />
+            ))}
 
             {isStreaming && messages.length === 0 && (
               <div className="mini-chat-message assistant">

src/renderer/components/mini-chat/MiniChatHeader.tsx

@@ -69,10 +69,6 @@ export function MiniChatHeader({ onClearMessages }: MiniChatHeaderProps = {}) {
 
     // Automatically switch provider if necessary
     if (newProviderId && activeProvider && newProviderId !== activeProvider.id) {
-      console.log('Mini-chat: Switching provider', {
-        from: activeProvider.id,
-        to: newProviderId
-      });
       await modelService.setActiveProvider(newProviderId);
     }
 

src/renderer/components/mini-chat/MiniChatInput.tsx

@@ -38,12 +38,6 @@ export function MiniChatInput({ sendMessage, isStreaming, stop }: MiniChatInputP
     setInputValue(''); // Clear input immediately
     setError(null);
 
-    console.log('[MiniChatInput] Sending message:', {
-      userContent,
-      selectedModel,
-      currentSessionId
-    });
-
     try {
       // Generate ID once and use it for both persistence and useChat
       const messageId = `user-${Date.now()}`;
@@ -88,14 +82,11 @@ export function MiniChatInput({ sendMessage, isStreaming, stop }: MiniChatInputP
       }
 
       // Send message to AI
-      // Use the same structure as ChatPage: object with parts array
-      console.log('[MiniChatInput] Calling sendMessage with:', { messageId, userContent });
       await sendMessage({
         id: messageId,  // ← Same ID as persisted in DB
         role: 'user',
         parts: [{ type: 'text', text: userContent }],
       });
-      console.log('[MiniChatInput] sendMessage completed');
     } catch (error) {
       console.error('Error sending mini-chat message:', error);
       setError(error instanceof Error ? error.message : 'Failed to send message');

src/renderer/components/mini-chat/MiniChatRichMessage.tsx

@@ -95,26 +95,6 @@ export function MiniChatRichMessage({ message, isStreaming }: MiniChatRichMessag
   const { parts } = message;
   const content = getMessageContent(message);
 
-  // DEBUGGING: Log message structure
-  console.log('[MiniChatRichMessage] Processing message:', {
-    id: message.id,
-    role: message.role,
-    hasContent: !!content,
-    contentType: typeof content,
-    contentValue: content,
-    hasParts: !!parts,
-    partsLength: parts?.length,
-    partsDetail: parts?.map((p, i) => ({
-      index: i,
-      type: typeof p,
-      value: p,
-      isObject: p && typeof p === 'object',
-      hasType: p && typeof p === 'object' && 'type' in p,
-      typeValue: p && typeof p === 'object' && 'type' in p ? p.type : undefined,
-      keys: p && typeof p === 'object' ? Object.keys(p) : []
-    }))
-  });
-
   // Filter out empty JSON objects/arrays from parts
   const isEmptyJSON = (part: any): boolean => {
     if (!part || typeof part !== 'object') return false;
@@ -130,17 +110,10 @@ export function MiniChatRichMessage({ message, isStreaming }: MiniChatRichMessag
       const { selectedModel, currentSessionId } = miniChatStore.useMiniChatStore.getState();
 
       if (!currentSessionId) {
-        console.warn('No session ID available - cannot transfer to main window');
         return;
       }
 
-      console.log('Transferring conversation to main window', {
-        model: selectedModel,
-        sessionId: currentSessionId,
-      });
-
       // Call IPC to transfer conversation
-      // Now we only pass sessionId - messages are already in DB
       const result = await window.levante.miniChat.openInMainWindow({
         messages: [], // Empty - not needed anymore
         model: selectedModel,
@@ -171,23 +144,13 @@ export function MiniChatRichMessage({ message, isStreaming }: MiniChatRichMessag
       <div className="mini-chat-message-content mini-chat-response">
         {parts.map((part, index) => {
           try {
-            console.log(`[MiniChatRichMessage] Processing part ${index}:`, {
-              partType: typeof part,
-              partValue: part,
-              isObject: part && typeof part === 'object',
-              hasTypeKey: part && typeof part === 'object' && 'type' in part,
-              typeValue: part && typeof part === 'object' && 'type' in part ? part.type : 'N/A'
-            });
-
             // Skip empty JSON objects
             if (isEmptyJSON(part)) {
-              console.log(`[MiniChatRichMessage] Skipping empty JSON at index ${index}`);
               return null;
             }
 
             // Validate that part is an object before accessing properties
             if (!part || typeof part !== 'object') {
-              console.warn('[MiniChatRichMessage] Invalid part type:', typeof part, part);
               return null;
             }
 
@@ -228,7 +191,6 @@ export function MiniChatRichMessage({ message, isStreaming }: MiniChatRichMessag
         }
 
             // Unknown part type - skip
-            console.log(`[MiniChatRichMessage] Unknown part type at index ${index}:`, part.type);
             return null;
           } catch (partError) {
             console.error(`[MiniChatRichMessage] Error rendering part ${index}:`, {