@pheem49/mint 1.14.0 → 1.15.0

package/src/renderer/shared/conversation/coordinator.ts

@@ -0,0 +1,82 @@
+import type { AgentProgress, ChatResponse, DocumentAttachment } from '../types'
+import { reduceLiveAgentProgressBatch } from '../agentProgress'
+
+export interface ImageAttachment { dataUri: string; name: string; previewDataUri?: string; objectUrl?: string }
+export interface VideoAttachment { dataUri: string; name: string }
+
+export interface ConversationState {
+  workspacePath: string
+  message: string
+  imageAttachments: ImageAttachment[]
+  videoAttachments: VideoAttachment[]
+  documentAttachment: DocumentAttachment | null
+  sending: boolean
+  sendingMessage: string
+  sendingImageCount: number
+  sendingVideoCount: number
+  streamedReply: string
+  streamedResponse: ChatResponse | null
+  agentProgress: AgentProgress[]
+  pendingApproval: any | null
+}
+
+export type ConversationEvent =
+  | { type: 'compose'; message: string }
+  | { type: 'workspace_selected'; path: string }
+  | { type: 'image_attached'; image: ImageAttachment }
+  | { type: 'image_removed'; index: number }
+  | { type: 'video_attached'; video: VideoAttachment }
+  | { type: 'video_removed'; index: number }
+  | { type: 'document_attached'; document: DocumentAttachment | null }
+  | { type: 'composer_cleared' }
+  | { type: 'run_started'; message: string; imageCount: number; videoCount: number }
+  | { type: 'chunk_received'; chunk: string }
+  | { type: 'response_received'; response: ChatResponse }
+  | { type: 'progress_received'; progress: AgentProgress[] }
+  | { type: 'progress_cleared' }
+  | { type: 'stream_cleared' }
+  | { type: 'approval_requested'; approval: unknown }
+  | { type: 'approval_resolved' }
+  | { type: 'run_finished' }
+  | { type: 'run_cancelled' }
+  | { type: 'session_switched'; draft: string }
+
+export function initialConversationState(initial: Partial<ConversationState> = {}): ConversationState {
+  return {
+    workspacePath: '', message: '', imageAttachments: [], videoAttachments: [],
+    documentAttachment: null, sending: false, sendingMessage: '', sendingImageCount: 0,
+    sendingVideoCount: 0, streamedReply: '', streamedResponse: null, agentProgress: [],
+    pendingApproval: null, ...initial,
+  }
+}
+
+export function transitionConversation(state: ConversationState, event: ConversationEvent): ConversationState {
+  switch (event.type) {
+    case 'compose': return { ...state, message: event.message }
+    case 'workspace_selected': return { ...state, workspacePath: event.path }
+    case 'image_attached': return state.imageAttachments.some((item) => item.name === event.image.name && item.dataUri === event.image.dataUri)
+      ? state : { ...state, imageAttachments: [...state.imageAttachments, event.image] }
+    case 'image_removed': return { ...state, imageAttachments: state.imageAttachments.filter((_, index) => index !== event.index) }
+    case 'video_attached': return state.videoAttachments.some((item) => item.name === event.video.name && item.dataUri === event.video.dataUri)
+      ? state : { ...state, videoAttachments: [...state.videoAttachments, event.video] }
+    case 'video_removed': return { ...state, videoAttachments: state.videoAttachments.filter((_, index) => index !== event.index) }
+    case 'document_attached': return { ...state, documentAttachment: event.document }
+    case 'composer_cleared': return { ...state, message: '', imageAttachments: [], videoAttachments: [], documentAttachment: null }
+    case 'run_started': return { ...state, sending: true, sendingMessage: event.message,
+      sendingImageCount: event.imageCount, sendingVideoCount: event.videoCount,
+      streamedReply: '', streamedResponse: null, agentProgress: [] }
+    case 'chunk_received': return { ...state, streamedReply: state.streamedReply + event.chunk }
+    case 'response_received': return { ...state, streamedResponse: event.response }
+    case 'progress_received': return { ...state, agentProgress: reduceLiveAgentProgressBatch(state.agentProgress, event.progress) }
+    case 'progress_cleared': return { ...state, agentProgress: [] }
+    case 'stream_cleared': return { ...state, streamedReply: '', streamedResponse: null }
+    case 'approval_requested': return { ...state, pendingApproval: event.approval }
+    case 'approval_resolved': return { ...state, pendingApproval: null }
+    case 'run_finished': return { ...state, sending: false, sendingMessage: '', sendingImageCount: 0, sendingVideoCount: 0 }
+    case 'run_cancelled': return { ...state, sending: false, sendingMessage: '', sendingImageCount: 0,
+      sendingVideoCount: 0, streamedReply: '', streamedResponse: null, agentProgress: [], pendingApproval: null }
+    case 'session_switched': return { ...state, message: event.draft, imageAttachments: [], videoAttachments: [],
+      documentAttachment: null, sending: false, sendingMessage: '', sendingImageCount: 0,
+      sendingVideoCount: 0, streamedReply: '', streamedResponse: null, agentProgress: [], pendingApproval: null }
+  }
+}

package/src/renderer/shared/conversation/syncView.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest'
+import { attachActivityToTurn, matchesActiveRun, matchesActiveSession, mergeVisibleHistory, visibleInteractionsDuringRun } from './syncView'
+
+describe('shared conversation view reconciliation', () => {
+  it('ignores history arriving out of order after A to B to C navigation', () => {
+    const active = { chatId: 'C', generation: 2 }
+    expect(matchesActiveSession({ chatId: 'A', generation: 0 }, active)).toBe(false)
+    expect(matchesActiveSession({ chatId: 'B', generation: 1 }, active)).toBe(false)
+    expect(matchesActiveSession(active, active)).toBe(true)
+  })
+
+  it('rejects late runs after A to B to A navigation or a newer run', () => {
+    const original = { chatId: 'A', sessionGeneration: 0, runGeneration: 1 }
+    expect(matchesActiveRun(original, original)).toBe(true)
+    expect(matchesActiveRun(original, { chatId: 'B', sessionGeneration: 1, runGeneration: 2 })).toBe(false)
+    expect(matchesActiveRun(original, { chatId: 'A', sessionGeneration: 2, runGeneration: 3 })).toBe(false)
+    expect(matchesActiveRun(original, { chatId: 'A', sessionGeneration: 0, runGeneration: 2 })).toBe(false)
+  })
+
+  it('keeps the active session unchanged when an earlier session finishes', () => {
+    const current = [{ id: 20, userText: 'session B' }]
+    const fromA = [{ id: 10, userText: 'session A' }]
+    expect(mergeVisibleHistory(current, fromA, false)).toBe(current)
+    expect(mergeVisibleHistory(current, [{ id: 21, userText: 'new B' }], true))
+      .toEqual([{ id: 20, userText: 'session B' }, { id: 21, userText: 'new B' }])
+  })
+
+  it('attaches agent activity by persisted turn ID when prompts are identical', () => {
+    const turns = [
+      { id: 10, userText: 'same prompt', agentActivity: [] as string[] },
+      { id: 11, userText: 'same prompt', agentActivity: [] as string[] },
+    ]
+    const updated = attachActivityToTurn(turns, 10, ['tool call'])
+    expect(updated[0].agentActivity).toEqual(['tool call'])
+    expect(updated[1]).toBe(turns[1])
+  })
+
+  it('hides only the initiating turn, never a matching remote prompt', () => {
+    const turns = [
+      { id: 10, userText: 'same prompt' },
+      { id: 11, userText: 'same prompt' },
+    ]
+    expect(visibleInteractionsDuringRun(turns, true, null)).toBe(turns)
+    expect(visibleInteractionsDuringRun(turns, true, 11)).toEqual([turns[0]])
+  })
+})

package/src/renderer/shared/conversation/syncView.ts

@@ -0,0 +1,43 @@
+export interface SessionIdentity {
+  chatId: string
+  generation: number
+}
+
+export function matchesActiveSession(origin: SessionIdentity, active: SessionIdentity): boolean {
+  return origin.chatId === active.chatId && origin.generation === active.generation
+}
+
+export interface RunIdentity {
+  chatId: string
+  sessionGeneration: number
+  runGeneration: number
+}
+
+export function matchesActiveRun(origin: RunIdentity, active: RunIdentity): boolean {
+  return origin.chatId === active.chatId
+    && origin.sessionGeneration === active.sessionGeneration
+    && origin.runGeneration === active.runGeneration
+}
+
+export function mergeVisibleHistory<T extends { id: number }>(
+  current: T[], incoming: T[], isCurrentSession: boolean,
+): T[] {
+  if (!isCurrentSession) return current
+  const byId = new Map([...current, ...incoming].map((interaction) => [interaction.id, interaction]))
+  return Array.from(byId.values()).sort((a, b) => a.id - b.id)
+}
+
+export function attachActivityToTurn<T extends { id: number; agentActivity?: A }, A>(
+  interactions: T[], turnId: number, activity: A,
+): T[] {
+  return interactions.map((interaction) => interaction.id === turnId
+    ? { ...interaction, agentActivity: activity }
+    : interaction)
+}
+
+export function visibleInteractionsDuringRun<T extends { id: number }>(
+  interactions: T[], sending: boolean, sendingTurnId: number | null | undefined,
+): T[] {
+  if (!sending || sendingTurnId == null) return interactions
+  return interactions.filter((interaction) => interaction.id !== sendingTurnId)
+}

package/src/renderer/shared/conversation/useConversationCoordinator.ts

@@ -0,0 +1,106 @@
+import { useEffect, useMemo, useReducer, useRef } from 'react'
+import type { ConversationState } from './coordinator'
+import { initialConversationState, transitionConversation } from './coordinator'
+import type { AgentProgress, ChatResponse } from '../types'
+
+interface CoordinatorOptions {
+  conversationId: string
+  draftKeyPrefix: string
+  workspaceStorageKey: string
+}
+
+export function useConversationCoordinator(
+  initial: Partial<ConversationState>,
+  options: CoordinatorOptions,
+) {
+  const [conversation, dispatch] = useReducer(transitionConversation, initial, initialConversationState)
+  const actions = useMemo(() => ({
+    compose: (message: string) => dispatch({ type: 'compose', message }),
+    selectWorkspace: (path: string) => dispatch({ type: 'workspace_selected', path }),
+    attachImage: (image: ConversationState['imageAttachments'][number]) => dispatch({ type: 'image_attached', image }),
+    removeImage: (index: number) => dispatch({ type: 'image_removed', index }),
+    attachVideo: (video: ConversationState['videoAttachments'][number]) => dispatch({ type: 'video_attached', video }),
+    removeVideo: (index: number) => dispatch({ type: 'video_removed', index }),
+    attachDocument: (document: ConversationState['documentAttachment']) => dispatch({ type: 'document_attached', document }),
+    startRun: (message: string, imageCount = 0, videoCount = 0) => dispatch({
+      type: 'run_started', message, imageCount, videoCount,
+    }),
+    receiveChunk: (chunk: string) => dispatch({ type: 'chunk_received', chunk }),
+    receiveProgress: (progress: AgentProgress[]) => dispatch({ type: 'progress_received', progress }),
+    clearProgress: () => dispatch({ type: 'progress_cleared' }),
+    clearStream: () => dispatch({ type: 'stream_cleared' }),
+    requestApproval: (approval: unknown) => dispatch({ type: 'approval_requested', approval }),
+    finishRun: () => dispatch({ type: 'run_finished' }),
+    cancelRun: () => dispatch({ type: 'run_cancelled' }),
+    clearComposer: () => dispatch({ type: 'composer_cleared' }),
+    switchSession: (draft = '') => dispatch({ type: 'session_switched', draft }),
+    executeStream: async (
+      execute: (onChunk: (chunk: string) => void) => Promise<ChatResponse>,
+      shouldApplyResponse: () => boolean = () => true,
+    ) => {
+      // Keep provider streaming internal and reveal only the authoritative
+      // completed response. This avoids partial Markdown/card layouts and
+      // keeps Desktop and Web behavior aligned with the CLI.
+      const response = await execute(() => {})
+      if (shouldApplyResponse()) {
+        dispatch({ type: 'chunk_received', chunk: response.text })
+        dispatch({ type: 'response_received', response })
+      }
+      return response
+    },
+    executeApproval: async (execute: () => Promise<void>) => {
+      try {
+        await execute()
+      } finally {
+        dispatch({ type: 'approval_resolved' })
+      }
+    },
+    executeCancellation: async (execute: () => Promise<void>) => {
+      try {
+        await execute()
+      } finally {
+        dispatch({ type: 'run_cancelled' })
+      }
+    },
+  }), [])
+
+  const loadedConversationRef = useRef(options.conversationId)
+  useEffect(() => {
+    if (loadedConversationRef.current === options.conversationId) return
+    loadedConversationRef.current = options.conversationId
+    let draft = ''
+    try {
+      draft = window.localStorage.getItem(`${options.draftKeyPrefix}${options.conversationId}`) || ''
+    } catch {
+      // Draft persistence is best-effort in private browsing modes.
+    }
+    actions.switchSession(draft)
+  }, [actions, options.conversationId, options.draftKeyPrefix])
+
+  useEffect(() => {
+    const timer = window.setTimeout(() => {
+      try {
+        const key = `${options.draftKeyPrefix}${options.conversationId}`
+        if (conversation.message) window.localStorage.setItem(key, conversation.message)
+        else window.localStorage.removeItem(key)
+      } catch {
+        // Draft persistence is best-effort in private browsing modes.
+      }
+    }, 300)
+    return () => window.clearTimeout(timer)
+  }, [conversation.message, options.conversationId, options.draftKeyPrefix])
+
+  useEffect(() => {
+    try {
+      if (conversation.workspacePath) {
+        window.localStorage.setItem(options.workspaceStorageKey, conversation.workspacePath)
+      } else {
+        window.localStorage.removeItem(options.workspaceStorageKey)
+      }
+    } catch {
+      // Workspace persistence is best-effort in private browsing modes.
+    }
+  }, [conversation.workspacePath, options.workspaceStorageKey])
+
+  return { conversation, actions }
+}

package/src/renderer/shared/css/agent-observability.css

@@ -13,6 +13,9 @@
   padding: 12px 14px;
   margin-bottom: 10px;
   color: var(--text-main, #e8e8ea);
+  min-width: 0;
+  max-width: 100%;
+  overflow: hidden;
 }
 
 .run-summary-header {
@@ -22,6 +25,21 @@
   border-bottom: 1px solid var(--border, rgba(255, 255, 255, 0.08));
   padding-bottom: 8px;
   margin-bottom: 10px;
+  gap: 8px;
+  min-width: 0;
+  flex-wrap: wrap;
+}
+
+.run-summary-title,
+.run-summary-header > div {
+  min-width: 0;
+  max-width: 100%;
+}
+
+.run-summary-title span {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 .run-summary-title {
@@ -63,8 +81,9 @@
 
 .run-kpi-grid {
   display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
+  grid-template-columns: repeat(auto-fit, minmax(min(100%, 150px), 1fr));
   gap: 8px;
+  min-width: 0;
 }
 
 .run-kpi-box {
@@ -75,6 +94,8 @@
   display: flex;
   flex-direction: column;
   gap: 3px;
+  min-width: 0;
+  overflow: hidden;
 }
 
 .run-kpi-label {
@@ -99,12 +120,13 @@
 
 .run-timeline-container {
   margin-top: 12px;
+  min-width: 0;
 }
 
 .run-timeline-title {
   font-size: 0.68rem;
   font-weight: 600;
-  text-transform: uppercase;
+  text-transform: none;
   letter-spacing: 0.05em;
   color: var(--text-muted, #8f8f94);
   margin-bottom: 6px;
@@ -116,6 +138,7 @@
   gap: 4px;
   max-height: 160px;
   overflow-y: auto;
+  min-width: 0;
 }
 
 .run-timeline-item {
@@ -128,6 +151,9 @@
   border: 1px solid var(--border, rgba(255, 255, 255, 0.04));
   font-size: 0.75rem;
   transition: background 0.15s ease;
+  gap: 8px;
+  min-width: 0;
+  overflow: hidden;
 }
 
 .run-timeline-item:hover {
@@ -139,6 +165,8 @@
   align-items: center;
   gap: 8px;
   min-width: 0;
+  flex: 1;
+  overflow: hidden;
 }
 
 .run-timeline-step {
@@ -154,6 +182,8 @@
   overflow: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
+  min-width: 0;
+  flex: 0 1 auto;
 }
 
 .run-timeline-target {
@@ -167,6 +197,8 @@
   text-overflow: ellipsis;
   white-space: nowrap;
   max-width: 220px;
+  min-width: 0;
+  flex: 0 1 auto;
 }
 
 .run-timeline-note-failed {
@@ -250,7 +282,7 @@
 
 .plan-task-item.in-progress {
   background: color-mix(in srgb, var(--accent, #10b981) 12%, transparent);
-  color: var(--accent-hover, #34d399);
+  color: var(--interactive-fg-hover);
 }
 
 .plan-task-item.completed {

package/src/renderer/shared/css/auth-gate.css

@@ -166,7 +166,7 @@
   border-radius: var(--radius-lg);
   border: none;
   background: var(--accent, #10b981);
-  color: #06120c;
+  color: var(--text-on-accent);
   font-weight: 650;
   font-size: 0.92rem;
   cursor: pointer;
@@ -202,5 +202,5 @@
 }
 
 .auth-gate-switch:hover {
-  color: var(--accent, #10b981);
+  color: var(--interactive-fg);
 }