Assistant Mode

[stepandel]

Summary by CodeRabbit

• New Features

  • Introduced Assistant functionality with full CRUD operations for creating, managing, and deleting assistants.
  • Added file upload and management capabilities for assistants with status tracking.
  • Implemented chat interface with real-time streaming and citation support linking to source files.
  • Added mode switcher to toggle between Index and Assistant modes.
  • Introduced file detail panel with download and delete options.

• Tests

  • Added comprehensive e2e test suite covering assistant creation, chat interactions, file management, and mode switching.

[coderabbitai]

Caution

Review failed

The pull request is closed.

📝 Walkthrough

Walkthrough

This PR introduces a comprehensive Assistant mode feature to Pinecone Explorer, enabling users to create and manage AI assistants, upload knowledge files, and interact via streaming chat. The implementation includes a new AssistantService wrapping Pinecone SDK operations, extensive Electron IPC layer expansion for assistant CRUD and file management, dual-mode UI (Index vs Assistant), context-based state management, and complete E2E test coverage across assistant workflows.

Changes

Cohort / File(s)	Summary
Linear Configuration .linear.toml	Added Linear CLI configuration with workspace ID and team settings.
Electron Backend - Assistant Service electron/assistant-service.ts	New AssistantService class wrapping Pinecone SDK with CRUD methods for assistants, file management, chat (streaming and non-streaming), private mapping helpers for model conversion, and comprehensive error handling.
Electron Backend - Integrations electron/connection-store.ts, electron/pinecone-service.ts	Added preferredMode persistence and getter methods in ConnectionStore; integrated AssistantService with lazy initialization and connection lifecycle management in PineconeService.
Electron Backend - IPC & Main Process electron/main.ts	Expanded IPC handlers for profiles (mode preferences), assistants (list/create/describe/update/delete), files (upload/list/describe/delete), chat (streaming with chunk handling and cancellation), dialog file picker, and context menus. Implements streaming lifecycle and per-window cleanup.
Electron Backend - Type Definitions electron/types.ts, electron/preload.ts	Added comprehensive type definitions for assistants, files, chat messages, citations; exposed assistant API surface, context menu actions, dialog, and mode persistence in preload and types.
Electron Backend - Menu electron/menu.ts	Renamed view menu items to "Index Mode" and "Assistant Mode"; added new Assistant menu with creation, editing, deletion, and chat actions (send message, focus input, clear conversation).
Frontend - Context Providers src/context/ModeContext.tsx, src/context/AssistantSelectionContext.tsx, src/context/FileSelectionContext.tsx, src/context/DraftAssistantContext.tsx	New context system for mode persistence (index/assistant), active assistant/file tracking, and draft assistant creation/editing with validation and multi-step save flow.
Frontend - UI Components - Mode & Assistant Management src/components/mode/ModeSwitcher.tsx, src/components/assistants/AssistantsPanel.tsx, src/components/assistants/AssistantConfigView.tsx	ModeSwitcher for dual-mode selection; AssistantsPanel listing, creating, selecting, and deleting assistants with status indicators; AssistantConfigView form for name, instructions, metadata, and region configuration.
Frontend - UI Components - Chat src/components/chat/ChatView.tsx, src/components/chat/ChatMessage.tsx, src/components/chat/CitationPopover.tsx	ChatView with message history, auto-scrolling, model selector, and input handling; ChatMessage with citation inline markers and Markdown rendering; CitationPopover for displaying file sources.
Frontend - UI Components - File Management src/components/files/FilesPanel.tsx, src/components/files/FileDetailPanel.tsx, src/components/files/UploadFileDialog.tsx, src/components/files/index.ts	FilesPanel with upload, search, and file listing; FileDetailPanel showing file metadata, status, and download/delete actions; UploadFileDialog with drag-and-drop, metadata JSON validation, and multimodal toggle for PDFs.
Frontend - Layout & Integration src/components/layout/TopBar.tsx, src/components/layout/MainContent.tsx, src/windows/ConnectionWindow.tsx, src/components/ui/new-button.tsx	TopBar integrated with ModeSwitcher; MainContent branches rendering by mode (assistants/files vs indexes/namespaces); ConnectionWindow adds DraftAssistant, ModeProvider, and selection contexts; NewButton supports data-testid.
Frontend - Hooks src/hooks/useAssistantQueries.ts, src/hooks/useChatStream.ts, src/hooks/useMenuHandlers.ts	useAssistantQueries for React Query-based assistant and file data management with optimistic updates; useChatStream for streaming chat with message accumulation and abort support; useMenuHandlers simplified by removing panel toggle handlers.
Frontend - Constants & Configuration src/constants/keyboard-shortcuts.ts, src/constants/keyboard-shortcuts.test.ts	Expanded keyboard shortcuts to include assistant (New, Edit, Delete) and chat (Send, Focus Input, Clear) categories; updated shortcuts mapping and category grouping; added shortcut matching tests.
Build & Test Configuration package.json, vite.config.js, vitest.config.ts, src/types/electron.d.ts	Added vitest and react-markdown dependencies; removed docker test scripts; configured vitest with path aliases; added Electron API type definitions for renderer process; removed sharp from external modules.
E2E Tests - Core Flows e2e/assistant-mode.spec.ts, e2e/assistant-crud.spec.ts, e2e/assistant-chat.spec.ts, e2e/assistant-integration.spec.ts	Test suites for mode switching with persistence, CRUD operations with UI validation, chat messaging with response streaming, and full integration workflows including error handling and mode transitions.
E2E Tests - Features & Helpers e2e/assistant-citations.spec.ts, e2e/assistant-files.spec.ts, e2e/assistant-file-detail.spec.ts, e2e/assistant-upload.spec.ts, e2e/fixtures/test-document.txt, e2e/helpers/assistant-helpers.ts	Citation rendering and popover interaction tests; file panel and detail panel tests; file upload workflow tests; test document fixture; comprehensive Playwright helpers for mode switching, assistant management, file operations, and chat interactions.
Backend Tests electron/assistant-service.test.ts	Test suite for AssistantService mapping logic, file handling, and citation conversion with mock Pinecone client.

Sequence Diagram(s)

sequenceDiagram
    participant Renderer as Renderer Process
    participant MainElectron as Main Process
    participant PineconeService as PineconeService
    participant AssistantService as AssistantService
    participant PineconeSDK as Pinecone SDK
    participant IPC as IPC Bridge

    Renderer->>IPC: assistant:chat:stream:start(profileId, name, params)
    IPC->>MainElectron: Handle stream:start
    MainElectron->>PineconeService: getAssistantService()
    PineconeService->>AssistantService: new AssistantService(pinecone)
    MainElectron->>AssistantService: chatStream(name, params, onChunk, signal)
    AssistantService->>PineconeSDK: client.assistants.chat.stream()
    PineconeSDK-->>AssistantService: event: message_start
    AssistantService->>MainElectron: onChunk({type: 'message_start', ...})
    MainElectron->>Renderer: assistant:chat:stream:chunk
    Renderer->>Renderer: Update message placeholder
    
    PineconeSDK-->>AssistantService: event: content
    AssistantService->>MainElectron: onChunk({type: 'content', delta})
    MainElectron->>Renderer: assistant:chat:stream:chunk
    Renderer->>Renderer: Append to message
    
    PineconeSDK-->>AssistantService: event: citation
    AssistantService->>MainElectron: onChunk({type: 'citation', ...})
    MainElectron->>Renderer: assistant:chat:stream:chunk
    
    PineconeSDK-->>AssistantService: event: message_end
    AssistantService->>MainElectron: onChunk({type: 'message_end', usage, model})
    MainElectron->>Renderer: assistant:chat:stream:chunk
    Renderer->>Renderer: Finalize message

Loading

sequenceDiagram
    participant User as User
    participant UI as UI Layer
    participant DraftContext as DraftAssistantContext
    participant Mutations as useMutations
    participant MainElectron as Main Process
    participant PineconeSDK as Pinecone SDK

    User->>UI: Click "New Assistant"
    UI->>DraftContext: startCreating()
    DraftContext->>DraftContext: Initialize draft (empty name, instructions, region)
    
    User->>UI: Enter name, instructions, select region
    UI->>DraftContext: updateDraft(field, value)
    DraftContext->>DraftContext: Validate field (name required, lowercase)
    UI->>UI: Show validation error/success
    
    User->>UI: Click "Create"
    UI->>Mutations: useCreateAssistantMutation.mutate(params)
    Mutations->>MainElectron: assistant:create(profileId, params)
    MainElectron->>PineconeSDK: client.assistants.create(...)
    PineconeSDK-->>MainElectron: AssistantModel
    MainElectron->>Mutations: Return {success: true, data: assistant}
    Mutations->>DraftContext: setActiveAssistant(name)
    Mutations->>DraftContext: invalidate queries (refresh list)
    DraftContext->>DraftContext: Clear draft
    UI->>UI: Switch to ChatView

Loading

sequenceDiagram
    participant User as User
    participant FilesPanel as FilesPanel
    participant Dialog as dialog.showOpenDialog
    participant Mutations as useUploadFileMutation
    participant MainElectron as Main Process
    participant PineconeSDK as Pinecone SDK

    User->>FilesPanel: Click "Upload File"
    FilesPanel->>Dialog: electronAPI.dialog.showOpenDialog({filters, properties})
    Dialog-->>FilesPanel: {canceled: false, filePaths: [path]}
    
    User->>Mutations: (Implicit via FilesPanel)
    Mutations->>MainElectron: assistant:files:upload(profileId, assistantName, {filePath, metadata, multimodal})
    MainElectron->>PineconeSDK: client.assistants.files.upload(...)
    PineconeSDK-->>MainElectron: AssistantFile {id, name, status: 'Processing', percentDone: 0}
    MainElectron->>Mutations: Return {success: true, data: file}
    Mutations->>Mutations: Optimistically update cache
    Mutations->>Mutations: Poll file status (refetch every 5s)
    PineconeSDK-->>PineconeSDK: status transitions Processing → Available
    Mutations->>FilesPanel: Update UI with new status
    FilesPanel->>User: Display file with Ready status

Loading

Estimated code review effort

🎯 5 (Critical) | ⏱️ ~120 minutes

Possibly related PRs

• PR #25: Adds Playwright E2E testing infrastructure with overlapping e2e/*, playwright.config.ts, and test script changes in package.json.
• PR #37: Modifies mode-related code paths including ModeContext, ModeSwitcher, TopBar, and IPC/electron type handlers for mode switching.
• PR #38: Adds AssistantService and related IPC/preload/type integrations across electron/assistant-service.ts, pinecone-service.ts, and main.ts.

Poem

🐰 Hops with glee at assistant creation,
Streams chat chunks with pure elation!
Files and modes dance in delight,
Citations bloom where knowledge shines bright. ✨
An explorer's dream, now in sight!

🚥 Pre-merge checks | ✅ 2 | ❌ 1

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 38.64% which is insufficient. The required threshold is 80.00%.	Write docstrings for the functions missing them to satisfy the coverage threshold.

✅ Passed checks (2 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The pull request title 'Assistant Mode' is directly related to the main objective, which introduces a new assistant mode feature alongside the existing index mode, enabling users to switch between two exploration modes.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch feat/assistant-mode

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[claude]

Code review

No issues found. Checked for bugs and CLAUDE.md compliance.

[coderabbitai]

Actionable comments posted: 0

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

electron/pinecone-service.ts (1)

92-98: ⚠️ Potential issue | 🟠 Major

Missing cleanup for assistantService in disconnect().

The disconnect() method resets embeddingService to null but does not reset assistantService. This could cause stale references after reconnection, where getAssistantService() returns a service bound to the old Pinecone client.

🐛 Proposed fix

   disconnect(): void {
     this.client = null
     this.embeddingService = null
+    this.assistantService = null
     this.profile = null
     this.indexCache.clear()
     this.indexInfoCache.clear()
   }

🧹 Nitpick comments (2)

src/components/mode/ModeSwitcher.tsx (1)

11-14: Consider platform-aware keyboard shortcut display.

The shortcuts use the macOS convention (⌘1, ⌘2), but Windows/Linux users would expect Ctrl+1/Ctrl+2. This could cause confusion for non-macOS users.

♻️ Suggested approach

You could detect the platform and display the appropriate modifier:

const isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0

const modes: ModeOption[] = [
  { value: 'index', icon: Database, label: 'Index Explorer', shortcut: isMac ? '⌘1' : 'Ctrl+1' },
  { value: 'assistant', icon: Bot, label: 'Assistant Explorer', shortcut: isMac ? '⌘2' : 'Ctrl+2' },
]

Or move modes inside the component and compute shortcuts dynamically.

src/context/ModeContext.tsx (1)

18-33: Avoid stale mode updates when profile changes.

If getPreferredMode resolves after a profile switch/unmount, it can overwrite the newer mode or set state after unmount. Consider a simple cancellation guard.

Suggested fix

  useEffect(() => {
    if (!currentProfile) return
+    let cancelled = false
+    const profileId = currentProfile.id

-    window.electronAPI.profiles.getPreferredMode(currentProfile.id)
+    window.electronAPI.profiles.getPreferredMode(profileId)
       .then((savedMode) => {
+        if (cancelled) return
         if (savedMode) {
           setModeState(savedMode)
         }
         setIsInitialized(true)
       })
       .catch((err) => {
+        if (cancelled) return
         console.warn('Failed to load saved mode, using default:', err)
         setIsInitialized(true)
       })
+    return () => {
+      cancelled = true
+    }
   }, [currentProfile])

[coderabbitai]

Actionable comments posted: 6

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (2)

electron/menu.ts (1)

276-383: ⚠️ Potential issue | 🟠 Major

New Index accelerator should also disable global registration to match New Assistant.

Both "New Index..." and "New Assistant..." use CmdOrCtrl+Shift+N. The "New Assistant" menu item already has registerAccelerator: false (line 382) to prevent blocking the shortcut in assistant mode, but "New Index..." (line 278) does NOT have this flag. This creates an asymmetry: the New Index accelerator registers globally while New Assistant relies on the renderer's context-aware keyboard shortcut handler.

Add registerAccelerator: false to the "New Index" menu item to match the pattern and ensure both shortcuts are handled consistently by the renderer-side handlers in IndexesPanel.tsx and AssistantsPanel.tsx.

Suggested fix

 {
   label: 'New Index...',
   accelerator: 'CmdOrCtrl+Shift+N',
   click: () => {
     sendToFocusedWindow('menu:new-index')
   },
+  registerAccelerator: false,
 },

electron/preload.ts (1)

173-212: ⚠️ Potential issue | 🟠 Major

Expose file context‑menu APIs used by FilesPanel.

FilesPanel calls window.electronAPI.contextMenu.showFileMenu and onFileAction, but these aren’t exposed here, so the renderer will hit undefined. Add the preload wrappers and wire matching IPC handlers in electron/main.ts.

Suggested preload additions

  contextMenu: {
    showIndexMenu: (indexName: string): void => {
      ipcRenderer.send('context-menu:show-index', indexName)
    },
+    showFileMenu: (assistantName: string, fileId: string, fileName: string): void => {
+      ipcRenderer.send('context-menu:show-file', assistantName, fileId, fileName)
+    },
     showIndexPanelMenu: (): void => {
      ipcRenderer.send('context-menu:show-index-panel')
    },
    onAction: (callback: (action: { action: string; indexName?: string }) => void): (() => void) => {
      const handler = (_event: any, data: { action: string; indexName?: string }) => callback(data)
      ipcRenderer.on('context-menu:action', handler)
      return () => ipcRenderer.removeListener('context-menu:action', handler)
    },
+    onFileAction: (
+      callback: (action: { action: string; fileId?: string; fileName?: string }) => void
+    ): (() => void) => {
+      const handler = (_event: any, data: { action: string; fileId?: string; fileName?: string }) => callback(data)
+      ipcRenderer.on('context-menu:file-action', handler)
+      return () => ipcRenderer.removeListener('context-menu:file-action', handler)
+    },

🤖 Fix all issues with AI agents

In `@src/components/assistants/AssistantsPanel.tsx`:
- Around line 27-56: The status mapping functions getStatusColor and
getStatusTooltip need to treat the AssistantStatus value "InitializationFailed"
as a failure: update both functions' switch statements to add a case
'InitializationFailed' that returns the same failure styling/class as 'Failed'
(e.g., 'bg-red-500') in getStatusColor and the same failure tooltip string
(e.g., 'Failed' or 'Initialization failed') in getStatusTooltip so
initialization failures are rendered and labeled as failures instead of falling
through to the default.

In `@src/components/chat/ChatMessage.tsx`:
- Around line 44-60: The <sup> element in CitationSuperscript is not
keyboard-focusable so keyboard users cannot open the CitationPopover; update the
CitationSuperscript component (the CitationSuperscript function that renders
CitationPopover) to use an accessible trigger: replace the <sup> with a semantic
<button> (or add role="button", tabIndex={0} and key handlers for Enter/Space)
and ensure it forwards onViewFile to CitationPopover; keep the same visual
classes, aria-label (e.g., `aria-label="Open citation ${index+1}"`), and
keyboard activation so the popover can be opened by keyboard and screen readers.

In `@src/components/files/FilesPanel.tsx`:
- Around line 96-103: The effect that opens the download URL (useEffect watching
fileDetail and fileToDownload) calls
window.electronAPI.shell.openExternal(fileDetail.signedUrl) but doesn’t handle
the returned Promise; wrap the call in a try/catch or use .then/.catch so
rejections are handled and only call setFileToDownload(null) after the
openExternal Promise resolves (or in finally if you want to clear on failure
too); update the effect to await or chain the Promise and log or surface errors
rather than letting unhandled rejections occur, referencing useEffect,
fileDetail, fileToDownload, window.electronAPI.shell.openExternal, and
setFileToDownload to locate the change.

In `@src/components/files/UploadFileDialog.tsx`:
- Line 26: The multimodal boolean state (multimodal / setMultimodal) is
collected by the UI but never forwarded to the upload logic; update handleUpload
to include the multimodal flag when calling uploadMutation (or remove the
checkbox if not supported). Specifically, extend the upload payload passed to
uploadMutation to include multimodal, and add an optional multimodal?: boolean
to the UploadAssistantFileParams type in electron/types.ts so the shape matches;
keep the existing checkbox and state as-is and pass multimodal through to
uploadMutation (or delete the checkbox and state if you decide not to support
multimodal yet).

In `@src/constants/keyboard-shortcuts.ts`:
- Around line 236-242: The NEW_ASSISTANT keyboard shortcut conflicts with
NEW_INDEX because both objects (NEW_ASSISTANT and NEW_INDEX) use the same
accelerator 'CmdOrCtrl+Shift+N'; update NEW_ASSISTANT's accelerator value to a
non-conflicting combination (for example 'CmdOrCtrl+Shift+A') so each shortcut
is unique, and ensure the corresponding keys/stub label (keys: '⌘⇧N') is updated
to match if needed (e.g., to '⌘⇧A') to keep displayed hint consistent.

In `@src/hooks/useChatStream.ts`:
- Around line 219-233: The clearMessages logic currently cancels the active
stream and clears state but isn't triggered when the assistant changes, so
messages and streams can leak between assistants; update useChatStream to call
the existing clearMessages (or inline its cancellation/cleanup steps that use
currentStreamIdRef, unsubscribeRef, setMessages, setIsStreaming, setError)
whenever assistantName changes by adding a useEffect that depends on
assistantName and invokes clearMessages, and ensure clearMessages is memoized
(or included in the effect deps) so the cleanup runs reliably when assistantName
updates.

🧹 Nitpick comments (4)

src/components/files/UploadFileDialog.tsx (1)

140-143: Consider adding a type definition for Electron's File path property.

The any cast is necessary because Electron extends the standard File interface with a path property. For better type safety, consider defining this interface extension.

♻️ Proposed type definition

Add to your type definitions (e.g., in src/types/electron.d.ts):

interface ElectronFile extends File {
  path: string
}

Then update the usage:

-      const filePath = (file as any).path
+      const filePath = (file as ElectronFile).path

src/types/electron.d.ts (1)

39-88: Consider consolidating duplicated type definitions.

The Assistant-related types (AssistantModel, AssistantFile, etc.) are defined in both electron/types.ts and here as global declarations. While this pattern is common in Electron apps, you could reduce maintenance burden by exporting types from a shared location and re-exporting them where needed.

src/components/files/FileDetailPanel.tsx (1)

60-87: Optional: clear CopyButton timeout on unmount.

This avoids a possible state update after unmount if the panel changes quickly.

♻️ Suggested change

-import { useState, useCallback } from 'react'
+import { useState, useCallback, useEffect, useRef } from 'react'

 function CopyButton({ text }: { text: string }) {
   const [copied, setCopied] = useState(false)
+  const timeoutRef = useRef<number | null>(null)

   const handleCopy = useCallback(async () => {
     try {
       await navigator.clipboard.writeText(text)
       setCopied(true)
-      setTimeout(() => setCopied(false), 2000)
+      if (timeoutRef.current) {
+        window.clearTimeout(timeoutRef.current)
+      }
+      timeoutRef.current = window.setTimeout(() => setCopied(false), 2000)
     } catch (err) {
       console.error('Failed to copy:', err)
     }
   }, [text])
+
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        window.clearTimeout(timeoutRef.current)
+      }
+    }
+  }, [])

src/components/chat/ChatView.tsx (1)

199-208: Prefer stable message keys to avoid remount churn.

Using array indices as keys can cause unnecessary remounts when messages are appended/removed. If you have an id (or can derive a stable key), prefer that.

Suggested fix

-            {messages.map((message, idx) => (
-              <ChatMessage 
-                key={idx} 
+            {messages.map((message, idx) => (
+              <ChatMessage 
+                key={message.id ?? `${message.role}-${idx}`} 
                 role={message.role}
                 content={message.content}
                 citations={message.citations}
                 isStreaming={message.isStreaming}
               />
             ))}

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@src/components/files/FileDetailPanel.tsx`:
- Around line 68-71: The handleDownload callback currently calls
window.electronAPI.shell.openExternal(file.signedUrl) without validating the
URL; change handleDownload to first safely parse file?.signedUrl (using the URL
constructor inside a try/catch) and only call openExternal when parsing succeeds
and url.protocol === 'https:'. If parsing fails or the protocol is not 'https:',
do not call window.electronAPI.shell.openExternal(file.signedUrl) and instead
surface or log an error (e.g., show a UI error/toast or console.error) so
malformed or dangerous schemes (file:, javascript:, search-ms:, etc.) are never
handed to the OS handler.

🧹 Nitpick comments (1)

src/components/files/FileDetailPanel.tsx (1)

203-211: Disable delete while server-side status is already “Deleting.”
When file.status is Deleting, the button can still trigger another delete request. Disable it to avoid duplicate deletes or noisy errors.

♻️ Suggested tweak

-          <Button
+          <Button
             onClick={handleDelete}
             size="sm"
             variant="destructive"
-            disabled={deleteMutation.isPending}
+            disabled={deleteMutation.isPending || file.status === 'Deleting'}
             className="w-full h-7 text-[11px] gap-1.5"
           >

[coderabbitai]

Actionable comments posted: 5

🤖 Fix all issues with AI agents

In `@electron/menu.ts`:
- Around line 373-427: The assistant menu events are not exposed to the
renderer; update electron/preload.ts to add an electronAPI.menu object that
exposes listener registration functions (e.g., onNewAssistant, onSendMessage,
onFocusChatInput, onClearConversation, onEditAssistant, onDeleteAssistant) which
internally register ipcRenderer.on for the corresponding channels
('menu:new-assistant', 'menu:send-message', 'menu:focus-chat-input',
'menu:clear-conversation', 'menu:edit-assistant', 'menu:delete-assistant') and
call the provided renderer callback; ensure each exposed function follows the
existing pattern used elsewhere in preload.ts (using
contextBridge.exposeInMainWorld/electronAPI and safe callback handling) so the
renderer can subscribe to these menu events.

In `@src/components/assistants/AssistantsPanel.tsx`:
- Around line 111-133: The delete handler can fire multiple times while a
deletion is in-flight; add a pending guard in handleConfirmDelete to return
early when a deletion is already pending (e.g., check deleteMutation.isLoading
or a local isDeleting ref/state) and ensure you set the guard before awaiting
deleteMutation.mutateAsync and clear it in finally; reference
handleConfirmDelete, deleteMutation, assistantToDelete and activeAssistant when
adding the early-return and the finally cleanup so duplicate delete calls are
prevented.

In `@src/context/DraftAssistantContext.tsx`:
- Around line 118-123: The effect that hydrates the draft on edit load
(useEffect watching isEditing, editingAssistant, editingAssistantName)
overwrites any user input when the fetched editingAssistant arrives; change it
to only call setDraftAssistant(createDraftFromAssistant(editingAssistant)) if
the current draft is still pristine (e.g., draftAssistant is null/undefined or
equals the initial empty draft state) so user-typed changes aren't clobbered—use
the existing draft state variable (draftAssistant) to gate hydration and keep
the same dependencies (isEditing, editingAssistant, editingAssistantName).
- Around line 147-156: In updateDraft, the forEach callback used to remove
validation errors returns the value of the delete expression (violating the
linter); change the forEach to use a block-bodied arrow function so the delete
is executed as a statement (e.g., updatedKeys.forEach(key => { delete next[key]
})) inside the setValidationErrors updater, keeping the existing variables
setDraftAssistant, setValidationErrors, updatedKeys and next unchanged.

In `@src/context/ModeContext.tsx`:
- Around line 19-41: When currentProfile changes the effect should reset the
initialization state so the UI doesn't briefly show the previous profile's mode:
inside the useEffect that watches currentProfile (the block calling
window.electronAPI.profiles.getPreferredMode(profileId)), call
setIsInitialized(false) immediately after the early return guard (or at the top
of the effect) before starting the async fetch; keep the cancelled flag and the
existing .then/.catch handlers but ensure you set setIsInitialized(true) only
after the fetch resolves or fails and avoid setting mode when cancelled (use
setModeState(savedMode) as now).

🧹 Nitpick comments (1)

src/components/chat/ChatMessage.tsx (1)

136-188: Consider extracting shared Markdown components configuration.

The Markdown components configuration for pre, code, and a is duplicated between the two render paths (lines 139-179 and 197-236). The only difference is that the citations path overrides p to render as span.

Extracting a shared config object would reduce duplication and make future styling updates easier to maintain.

♻️ Suggested refactor

+const sharedMarkdownComponents = {
+  pre: ({ children, ...props }: React.ComponentPropsWithoutRef<'pre'>) => (
+    <pre
+      className="bg-muted/50 rounded-md p-3 overflow-x-auto text-xs"
+      {...props}
+    >
+      {children}
+    </pre>
+  ),
+  code: ({ className, children, ...props }: React.ComponentPropsWithoutRef<'code'> & { className?: string }) => {
+    const isInline = !className
+    if (isInline) {
+      return (
+        <code className="bg-muted/50 rounded px-1 py-0.5 text-xs font-mono" {...props}>
+          {children}
+        </code>
+      )
+    }
+    return (
+      <code className={cn('text-xs font-mono', className)} {...props}>
+        {children}
+      </code>
+    )
+  },
+  a: ({ children, ...props }: React.ComponentPropsWithoutRef<'a'>) => (
+    <a
+      className="text-primary hover:underline"
+      target="_blank"
+      rel="noopener noreferrer"
+      {...props}
+    >
+      {children}
+    </a>
+  ),
+}

 // Then use in both paths:
-          components={{
-            // Style code blocks
-            pre: ({ children, ...props }) => ( ... ),
-            code: ({ className, children, ...props }) => { ... },
-            a: ({ children, ...props }) => ( ... ),
-          }}
+          components={sharedMarkdownComponents}

 // And for citations path:
+          components={{
+            ...sharedMarkdownComponents,
+            p: ({ children }) => <span>{children}</span>,
+          }}

Also applies to: 191-254

[coderabbitai]

⚠️ Potential issue | 🟠 Major

Avoid overwriting user edits when edit data finishes loading.

The effect resets the draft whenever editingAssistant arrives (Line 119). If a user starts typing before the fetch resolves, their input can be clobbered. Consider only hydrating when the draft is still pristine.

🔧 Suggested fix

 useEffect(() => {
   if (isEditing && editingAssistant && editingAssistantName) {
-    setDraftAssistant(createDraftFromAssistant(editingAssistant))
+    setDraftAssistant((prev) => {
+      if (prev && (prev.instructions || prev.metadata)) return prev
+      if (prev && prev.name !== editingAssistantName) return prev
+      return createDraftFromAssistant(editingAssistant)
+    })
   }
 }, [isEditing, editingAssistant, editingAssistantName])

🤖 Prompt for AI Agents

In `@src/context/DraftAssistantContext.tsx` around lines 118 - 123, The effect
that hydrates the draft on edit load (useEffect watching isEditing,
editingAssistant, editingAssistantName) overwrites any user input when the
fetched editingAssistant arrives; change it to only call
setDraftAssistant(createDraftFromAssistant(editingAssistant)) if the current
draft is still pristine (e.g., draftAssistant is null/undefined or equals the
initial empty draft state) so user-typed changes aren't clobbered—use the
existing draft state variable (draftAssistant) to gate hydration and keep the
same dependencies (isEditing, editingAssistant, editingAssistantName).

[coderabbitai]

⚠️ Potential issue | 🟠 Major

Biome error: avoid returning a value from forEach callback.

delete next[key] returns a boolean, which violates the linter rule (Line 154). Wrap the body in a block to keep it void.

🔧 Suggested fix

-      updatedKeys.forEach(key => delete next[key])
+      updatedKeys.forEach((key) => {
+        delete next[key]
+      })

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	const updateDraft = useCallback((updates: Partial<DraftAssistant>) => {
	setDraftAssistant(prev => prev ? { ...prev, ...updates } : prev)
	// Clear validation errors for updated fields
	const updatedKeys = Object.keys(updates)
	if (updatedKeys.length > 0) {
	setValidationErrors(prev => {
	const next = { ...prev }
	updatedKeys.forEach(key => delete next[key])
	return next
	})
	const updateDraft = useCallback((updates: Partial<DraftAssistant>) => {
	setDraftAssistant(prev => prev ? { ...prev, ...updates } : prev)
	// Clear validation errors for updated fields
	const updatedKeys = Object.keys(updates)
	if (updatedKeys.length > 0) {
	setValidationErrors(prev => {
	const next = { ...prev }
	updatedKeys.forEach((key) => {
	delete next[key]
	})
	return next
	})

🧰 Tools

🪛 Biome (2.3.13)

[error] 154-154: This callback passed to forEach() iterable method should not return a value.

Either remove this return or remove the returned value.

(lint/suspicious/useIterableCallbackReturn)

🤖 Prompt for AI Agents

In `@src/context/DraftAssistantContext.tsx` around lines 147 - 156, In
updateDraft, the forEach callback used to remove validation errors returns the
value of the delete expression (violating the linter); change the forEach to use
a block-bodied arrow function so the delete is executed as a statement (e.g.,
updatedKeys.forEach(key => { delete next[key] })) inside the setValidationErrors
updater, keeping the existing variables setDraftAssistant, setValidationErrors,
updatedKeys and next unchanged.

[coderabbitai]

Actionable comments posted: 1

🤖 Fix all issues with AI agents

In `@electron/assistant-service.ts`:
- Around line 126-134: The uploadFile method in assistant-service.ts is passing
an unsupported multimodal option to the Pinecone SDK (see async uploadFile),
which the v6.1.3/6.1.4 SDK ignores; remove params.multimodal from the call and
stop using the type assertion so you only pass { path: params.filePath,
metadata: params.metadata } to assistant.uploadFile in the uploadFile function
(or, if you need multimodal now, replace this call with a direct REST upload
using the Pinecone Assistant upload endpoint including X-Pinecone-Api-Version:
2025-10 and ?multimodal=true). Ensure mapFileModel(response) still receives the
SDK/REST response shape expected by the rest of the code.

🧹 Nitpick comments (5)

src/components/files/UploadFileDialog.tsx (1)

104-112: File size displays as "Unknown size" when using the file picker.

The file picker sets size: 0 (line 111) since dialog.showOpenDialog doesn't return file size. Consider using Electron's fs module via preload to fetch the actual size, or document this limitation more explicitly in the UI.

src/components/chat/ChatMessage.tsx (1)

140-180: Consider extracting shared Markdown components to reduce duplication.

The Markdown component configurations for pre, code, and a are nearly identical between the two rendering paths. Extract these into a shared markdownComponents object or a reusable wrapper component.

♻️ Example refactor

const markdownComponents = {
  pre: ({ children, ...props }: ComponentPropsWithoutRef<'pre'>) => (
    <pre className="bg-muted/50 rounded-md p-3 overflow-x-auto text-xs" {...props}>
      {children}
    </pre>
  ),
  code: ({ className, children, ...props }: ComponentPropsWithoutRef<'code'>) => {
    const isInline = !className
    if (isInline) {
      return (
        <code className="bg-muted/50 rounded px-1 py-0.5 text-xs font-mono" {...props}>
          {children}
        </code>
      )
    }
    return (
      <code className={cn('text-xs font-mono', className)} {...props}>
        {children}
      </code>
    )
  },
  a: ({ children, ...props }: ComponentPropsWithoutRef<'a'>) => (
    <a className="text-primary hover:underline" target="_blank" rel="noopener noreferrer" {...props}>
      {children}
    </a>
  ),
}

Also applies to: 199-237

src/components/chat/ChatView.tsx (3)

57-62: Consider optimizing auto-scroll during streaming.

The effect runs on every messages array change, which during streaming could be every token update. Using behavior: 'smooth' with high-frequency updates may cause visual jitter.

Consider scrolling immediately (without smooth) when streaming, or debouncing the scroll:

♻️ Potential optimization

 // Auto-scroll to bottom on new messages
 useEffect(() => {
   if (messagesEndRef.current) {
-    messagesEndRef.current.scrollIntoView({ behavior: 'smooth' })
+    // Use instant scroll during streaming to avoid jitter
+    const behavior = isStreaming ? 'instant' : 'smooth'
+    messagesEndRef.current.scrollIntoView({ behavior })
   }
- }, [messages])
+ }, [messages, isStreaming])

---

97-111: Avoid re-subscribing IPC handlers on every message.

Including messages.length in the dependency array causes the effect to re-subscribe on every new message. Use a ref for the current state or move the condition inside stable callbacks.

♻️ Suggested optimization using refs

+ const messagesRef = useRef(messages)
+ const isStreamingRef = useRef(isStreaming)
+ 
+ useEffect(() => {
+   messagesRef.current = messages
+   isStreamingRef.current = isStreaming
+ }, [messages, isStreaming])

  // Listen for menu IPC events
  useEffect(() => {
    const unsubFocus = window.electronAPI.menu.onFocusChatInput(() => {
      textareaRef.current?.focus()
    })
    const unsubClear = window.electronAPI.menu.onClearConversation(() => {
-     if (messages.length > 0 && !isStreaming) {
+     if (messagesRef.current.length > 0 && !isStreamingRef.current) {
        clearMessages()
      }
    })

    return () => {
      unsubFocus()
      unsubClear()
    }
- }, [messages.length, isStreaming, clearMessages])
+ }, [clearMessages])

---

137-142: IPC send listener re-subscribes on every input change.

Since handleSubmit depends on inputValue, this effect re-subscribes on every keystroke. Consider using a ref pattern similar to the suggestion above.

[coderabbitai]

⚠️ Potential issue | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

git ls-files | grep -E "(package\.json|tsconfig|electron)" | head -20

Repository: stepandel/pinecone-explorer

Length of output: 564

---

🏁 Script executed:

find . -name "package.json" -type f | head -5

Repository: stepandel/pinecone-explorer

Length of output: 85

---

🏁 Script executed:

fd "assistant-service" --type f

Repository: stepandel/pinecone-explorer

Length of output: 100

---

🏁 Script executed:

cat package.json | grep -A 5 -B 5 "pinecone"

Repository: stepandel/pinecone-explorer

Length of output: 937

---

🏁 Script executed:

head -50 electron/assistant-service.ts

Repository: stepandel/pinecone-explorer

Length of output: 1317

---

🏁 Script executed:

rg "UploadAssistantFileParams" --type ts

Repository: stepandel/pinecone-explorer

Length of output: 729

---

🏁 Script executed:

rg "export interface UploadAssistantFileParams" -A 15 electron/types.ts

Repository: stepandel/pinecone-explorer

Length of output: 364

---

🏁 Script executed:

cat -n electron/types.ts | head -100

Repository: stepandel/pinecone-explorer

Length of output: 3743

---

🏁 Script executed:

cat -n electron/assistant-service.ts | sed -n '120,150p'

Repository: stepandel/pinecone-explorer

Length of output: 1179

---

🏁 Script executed:

rg "uploadFile" electron/assistant-service.ts -B 2 -A 8

Repository: stepandel/pinecone-explorer

Length of output: 720

---

🌐 Web query:

Pinecone SDK @pinecone-database/pinecone v6.1.3 uploadFile multimodal parameter

💡 Result:

In @pinecone-database/pinecone v6.1.3, assistant.uploadFile(...) does not expose a multimodal option—UploadFileOptions only includes:

• path: string
• metadata?: Record<string, string>  [1]

And the v6.1.3 release notes mention only a Assistant.listFiles() filter bugfix (no uploadFile change) [2].

If you need multimodal PDF processing, that capability is controlled by the Assistant “upload file” API via the multimodal query parameter (true|false, default false, PDFs only) [3][4]—so with v6.1.3 you must call the HTTP endpoint directly (or upgrade to a newer SDK version that adds first-class support, if/when available).

Sources:
[1] TypeScript SDK UploadFileOptions (v6.1.1 docs; same API surface for v6.1.x) https://sdk.pinecone.io/typescript/interfaces/UploadFileOptions.html
[2] Pinecone release notes: Node.js SDK v6.1.3 https://docs.pinecone.io/release-notes/2025
[3] Assistant Upload File API (latest): multimodal query param https://docs.pinecone.io/reference/api/latest/assistant/upload_file
[4] Multimodal assistants guide (PDFs; multimodal=true) https://docs.pinecone.io/guides/assistant/multimodal

---

🌐 Web query:

@pinecone-database/pinecone uploadFile multimodal parameter support latest version

💡 Result:

As of @pinecone-database/pinecone latest = 6.1.4 (published Jan 22, 2026), the Node/TypeScript SDK’s assistant.uploadFile(...) does not expose a multimodal option—UploadFileOptions only includes path and optional metadata. [1][2]

Pinecone’s multimodal file processing for Assistants is available via the API 2025-10 upload_file endpoint using the multimodal=true query parameter (PDFs only), but SDKs targeting API 2025-10 “will be available soon” (so the Node SDK pinned to 2025-04 doesn’t yet surface it). [3][4]

Workarounds:

• Call the REST endpoint with X-Pinecone-Api-Version: 2025-10 and ?multimodal=true. [3]
• Or use an SDK that already supports a multimodal flag for file upload (documented for Python). [5]

Sources: [1] Yarn package page, [2] TS SDK UploadFileOptions, [3] API 2025-10 upload_file reference, [4] Pinecone SDKs versioning page, [5] Pinecone multimodal assistants guide.

---

The multimodal parameter is not supported by the Pinecone SDK v6.1.3 in use.

The type assertion masks an actual incompatibility: UploadFileOptions in SDK v6.1.3 (and latest v6.1.4) only accepts path and metadata—the multimodal parameter will be silently ignored at runtime.

Pinecone's API supports multimodal PDF processing via the multimodal query parameter in API version 2025-10, but the Node SDK is currently pinned to 2025-04 and doesn't yet expose this option.

Workarounds:

• Remove the multimodal parameter until the SDK adds support, or
• Call the Pinecone Assistant upload file REST endpoint directly with X-Pinecone-Api-Version: 2025-10 header and ?multimodal=true query parameter.

🤖 Prompt for AI Agents

In `@electron/assistant-service.ts` around lines 126 - 134, The uploadFile method
in assistant-service.ts is passing an unsupported multimodal option to the
Pinecone SDK (see async uploadFile), which the v6.1.3/6.1.4 SDK ignores; remove
params.multimodal from the call and stop using the type assertion so you only
pass { path: params.filePath, metadata: params.metadata } to
assistant.uploadFile in the uploadFile function (or, if you need multimodal now,
replace this call with a direct REST upload using the Pinecone Assistant upload
endpoint including X-Pinecone-Api-Version: 2025-10 and ?multimodal=true). Ensure
mapFileModel(response) still receives the SDK/REST response shape expected by
the rest of the code.

[coderabbitai]

Actionable comments posted: 2

🤖 Fix all issues with AI agents

In `@src/components/assistants/AssistantsPanel.tsx`:
- Around line 87-95: The right-click handler handleAssistantContextMenu calls
window.electronAPI.contextMenu.showAssistantMenu (and elsewhere code uses
contextMenu.onAssistantAction) but those APIs may not exist on the preload
surface; either add showAssistantMenu and onAssistantAction to the preload
exports in electron/preload.ts and declare them in src/types/electron.d.ts, or
defensively guard the calls in AssistantsPanel.tsx by checking
window.electronAPI?.contextMenu?.showAssistantMenu (and similarly for
onAssistantAction) before invoking and failing silently or logging a warning;
update both usages (the handleAssistantContextMenu and the other
assistant-context handlers around the later assistant action code) so they use
the same guarded access or the new declared preload methods.

In `@src/types/electron.d.ts`:
- Around line 85-88: The UploadAssistantFileParams interface in
src/types/electron.d.ts is missing the multimodal property and is out of sync
with the electron/types.ts definition; update UploadAssistantFileParams to
include multimodal?: boolean (or the exact type used in electron/types.ts) and
any related docs/comments so renderer callers can pass that option and the types
remain consistent with the electron/types.ts declaration.