@pheem49/mint 1.16.0 → 1.17.0

package/src/renderer/shared/types.ts

@@ -68,6 +68,41 @@ export interface ToolExecutionRecord {
   retried: boolean
 }
 
+export interface StepTokens {
+  inputTokens: number
+  generatedTokens: number
+}
+
+export interface StandardTrajectoryStep {
+  step: number
+  timestamp: string
+  thought: string
+  action: string
+  input: Record<string, unknown> | unknown
+  observation: string
+  status: string
+  durationMs: number
+  tokens: StepTokens
+}
+
+export interface StandardTrajectoryRun {
+  schemaVersion: string
+  runId: string
+  chatId: string
+  task: string
+  model: string
+  provider: string
+  startedAt: string
+  completedAt: string
+  outcome: string
+  totalSteps: number
+  totalTokens: number
+  durationSecs: number
+  filesCreated: string[]
+  filesModified: string[]
+  trajectory: StandardTrajectoryStep[]
+}
+
 export interface RunTelemetrySummary {
   runId: string
   task: string
@@ -79,15 +114,22 @@ export interface RunTelemetrySummary {
   durationSecs: number
   toolTimeline: ToolExecutionRecord[]
   retriesCount: number
+  trajectory?: StandardTrajectoryRun
 }
 
-export type ToolStatus = 'success' | 'failed' | 'timed_out' | 'cancelled'
+export type ToolStatus = 'success' | 'failed' | 'timed_out' | 'cancelled' | 'running' | 'unknown' | 'skipped'
+export interface ExecutionEvidence {
+  callId: string; command: string; state: 'succeeded' | 'failed' | 'running' | 'cancelled' | 'unknown'
+  exitCode?: number | null; jobId?: string | null; revision: number; check: boolean; conditionVerified?: boolean | null
+}
 export interface McpArtifact {
   id: string; name: string; mimeType: string; kind: 'image' | 'file' | 'link'; size: number
   chatId: string; callId: string; server: string; uri?: string
+  metadata?: { url?: string; capturedAt?: string; width?: number; height?: number; mode?: string; sessionId?: string; tabId?: string }
 }
 
 export type AgentProgress =
+  | { type: 'ExecutionUpdate'; data: { callId: string; executions: ExecutionEvidence[] } }
   | { type: 'ToolDiscovery'; data: { server: string; tool: string; message: string } }
   | { type: 'DeviceState'; data: { callId: string; server: string; tool: string; update: { state: 'accepted' | 'running' | 'verified' | 'failed' | 'unconfirmed'; deviceId?: string | null; operationId?: string | null; target: Record<string, unknown> | null; actual: Record<string, unknown> | null; observationSeq?: number | null; elapsedSecs: number; message: string } } }
   | { type: 'ToolProgress'; data: { callId: string; server: string; tool: string; update: { progress: number; total?: number; message?: string; elapsedSecs: number } } }
@@ -101,6 +143,18 @@ export type AgentProgress =
   | { type: 'ToolEnd'; data: { action: string; input: Record<string, unknown>; result: string; subagent?: string; callId?: string; status?: ToolStatus } }
   | { type: 'PlanUpdated'; data: { plan: ActivePlan } }
   | { type: 'RunCompleted'; data: { summary: RunTelemetrySummary } }
+  | { type: 'SubagentStarted'; data: { subagent: string; profile: string; task: string } }
+  | { type: 'SubagentFinished'; data: { subagent: string; status: 'completed' | 'failed' | 'cancelled'; elapsed_ms?: number; elapsedMs?: number; steps: number; summary_preview?: string; summaryPreview?: string } }
+
+export interface QueuedPrompt {
+  id: string
+  chatId: string
+  text: string
+  imageAttachments?: Array<{ dataUri: string; name: string; previewDataUri?: string }>
+  videoAttachments?: Array<{ dataUri: string; name: string }>
+  documentAttachment?: DocumentAttachment | null
+  createdAt: number
+}
 
 export interface InteractionMemory {
   id: number
@@ -220,6 +274,7 @@ export interface WorkspaceTreeEntry {
   children: WorkspaceTreeEntry[]
 }
 export interface WorkspaceSnapshot { path: string; tree: WorkspaceTreeEntry; git: GitBranchInfo; revision: number }
+export interface WorkspaceMediaSource { url: string; mimeType: string; byteLength?: number; objectUrl?: boolean; range?: boolean }
 export interface WorkspaceOperation { root: string; relativePath: string; revision: number }
 export interface WorkspaceHistoryEntry { id: string; label: string; path: string; kind: string; destination: string | null; expected: string | null; backup: string | null }
 

package/src/renderer/shared/utils/agentActivity.test.ts

@@ -66,10 +66,169 @@ it('shows a readable view_image result instead of raw image bytes while preservi
   expect(view.items[0].result).toContain('[Hook] Checked')
 })
 
-it('keeps viewed image identity stable when earlier text-only activities are trimmed', () => {
-  const earlier: AgentProgress[] = Array.from({ length: 10 }, () => ({ type: 'ToolEnd', data: { action: 'read_file', input: {}, result: 'Read' } }))
-  const image: AgentProgress = { type: 'ToolEnd', data: { action: 'view_image', input: { path: 'image.png' }, result: 'data:image/png;base64,aGVsbG8=' } }
-  const initial = [...earlier, image]
-  const later = Array.from({ length: 40 }, () => ({ type: 'ToolEnd' as const, data: { action: 'read_file', input: {}, result: 'Read' } })).reduce(reduceLiveAgentProgress, initial)
-  expect(viewedImagesFrom(later).map(item => item.id)).toEqual(viewedImagesFrom(initial).map(item => item.id))
+it('attaches viewedImage metadata to successful view_image activities but not failed ones', () => {
+  const failInput = { path: '/tmp/failed.png' }
+  const successInput = { path: '.mint-screenshots/captured.png' }
+  const dataUri = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII='
+
+  const view = activitiesFrom([
+    { type: 'ToolStart', data: { callId: 'call-fail', action: 'view_image', input: failInput } },
+    { type: 'ToolEnd', data: { callId: 'call-fail', action: 'view_image', input: failInput, result: 'Error: file not found', status: 'error' } },
+    {
+      type: 'ToolArtifacts',
+      data: {
+        callId: 'call-success',
+        warnings: [],
+        artifacts: [
+          {
+            id: 'art-captured',
+            name: 'captured.png',
+            mimeType: 'image/png',
+            kind: 'image',
+            size: 1024,
+            chatId: 'chat-1',
+            callId: 'call-success',
+            server: 'view_image',
+          },
+        ],
+      },
+    },
+    { type: 'ToolStart', data: { callId: 'call-success', action: 'view_image', input: successInput } },
+    { type: 'ToolEnd', data: { callId: 'call-success', action: 'view_image', input: successInput, result: 'Image saved: captured.png (artifactId: art-captured)', status: 'success' } },
+  ])
+
+  // Failed activity should not have a viewed image
+  expect(view.items[0].viewedImage).toBeUndefined()
+
+  // Successful activity should have the artifact-backed viewed image
+  expect(view.items[1].viewedImage).toBeDefined()
+  expect(view.items[1].viewedImage?.artifactId).toBe('art-captured')
+  expect(view.items[1].viewedImage?.path).toBe('.mint-screenshots/captured.png')
+  expect(view.items[1].viewedImage?.name).toBe('captured.png')
+})
+
+describe('subagent event isolation', () => {
+  it('excludes subagent ToolStart, ToolEnd, and ContextCompaction from the main activity view', () => {
+    const view = activitiesFrom([
+      { type: 'ToolStart', data: { action: 'dispatch_agents', input: { tasks: [] } } },
+      { type: 'ToolStart', data: { action: 'read_file', input: { path: '/sub/file.rs' }, subagent: 'recon' } },
+      { type: 'ToolEnd', data: { action: 'read_file', input: { path: '/sub/file.rs' }, result: 'content', subagent: 'recon' } },
+      { type: 'ContextCompaction', data: { status: 'completed', message: 'Subagent context compacted', subagent: 'recon' } },
+      { type: 'ToolEnd', data: { action: 'dispatch_agents', input: { tasks: [] }, result: 'all done' } },
+    ])
+    // Only the parent dispatch_agents should be in the main activity view
+    expect(view.items).toHaveLength(1)
+    expect(view.items[0].action).toBe('dispatch_agents')
+    expect(view.timeline?.filter(t => t.kind === 'activity')).toHaveLength(1)
+    expect(view.timeline?.find(t => t.kind === 'thought' && t.thought.includes('Subagent context compacted'))).toBeUndefined()
+  })
 })
+
+describe('fault-tolerant run_shell command extraction', () => {
+  it('extracts command from alias script or code', () => {
+    expect(describeTool('run_shell', { script: 'curl -s https://example.com' }).target).toBe('curl -s https://example.com')
+    expect(describeTool('run_shell', { code: 'pytest tests/' }).target).toBe('pytest tests/')
+  })
+
+  it('unpacks command from stringified arguments', () => {
+    expect(describeTool('run_shell', { arguments: '{"command": "git status"}' }).target).toBe('git status')
+  })
+
+  it('unpacks command from object arguments', () => {
+    expect(describeTool('run_shell', { arguments: { cmd: 'cargo check' } }).target).toBe('cargo check')
+  })
+
+  it('extracts raw string command', () => {
+    expect(describeTool('run_shell', 'echo hello' as unknown as Record<string, unknown>).target).toBe('echo hello')
+  })
+
+  it('falls back to (empty command) when no command is provided anywhere', () => {
+    expect(describeTool('run_shell', {}).target).toBe('(empty command)')
+  })
+
+  it('ignores dummy null/undefined strings and picks real command over path/query for run_shell', () => {
+    expect(
+      describeTool('run_shell', {
+        command: 'cd /tmp && ls -la',
+        path: 'null',
+        query: 'null',
+        name: 'null',
+        title: 'null',
+      }).target
+    ).toBe('cd /tmp && ls -la')
+
+    expect(
+      describeTool('run_shell', {
+        command: 'curl -s https://api.twitter.com',
+        path: 'null',
+        query: 'null',
+      }).target
+    ).toBe('curl -s https://api.twitter.com')
+  })
+
+  it('treats standalone dummy string command as empty and falls back to (empty command)', () => {
+    expect(describeTool('run_shell', { command: 'null' }).target).toBe('(empty command)')
+    expect(describeTool('run_shell', { command: 'undefined' }).target).toBe('(empty command)')
+    expect(describeTool('run_shell', { command: 'None' }).target).toBe('(empty command)')
+  })
+})
+
+describe('action-first target resolution and dummy value stripping', () => {
+  it('prioritizes query for web_search even when dummy path or other keys are present', () => {
+    expect(
+      describeTool('web_search', {
+        query: 'Kuuko W official twitter',
+        path: 'null',
+        command: 'null',
+        name: 'null',
+      }).target
+    ).toBe('Kuuko W official twitter')
+  })
+
+  it('strips dummy query for web_search and falls back to (empty query)', () => {
+    expect(describeTool('web_search', { query: 'null' }).target).toBe('(empty query)')
+    expect(describeTool('web_search', { query: 'undefined' }).target).toBe('(empty query)')
+  })
+
+  it('prioritizes path for read_file even when dummy command or query are present', () => {
+    expect(
+      describeTool('read_file', {
+        path: 'src/main.rs',
+        command: 'null',
+        query: 'null',
+      }).target
+    ).toBe('src/main.rs')
+  })
+})
+
+describe('live progress retention across multi-step turns', () => {
+  it('preserves all tool executions and timeline groups without dropping earlier tools', () => {
+    let progress: AgentProgress[] = []
+    // Simulate 15 shell tool executions interleaved with thoughts
+    for (let i = 0; i < 15; i++) {
+      progress = reduceLiveAgentProgress(progress, {
+        type: 'Thought',
+        data: { thought: `Thinking step ${i}` },
+      })
+      progress = reduceLiveAgentProgress(progress, {
+        type: 'ToolStart',
+        data: { action: 'run_shell', input: { command: `echo step ${i}` }, callId: `call-${i}` },
+      })
+      progress = reduceLiveAgentProgress(progress, {
+        type: 'ToolEnd',
+        data: { action: 'run_shell', input: { command: `echo step ${i}` }, result: `step ${i}`, callId: `call-${i}` },
+      })
+    }
+
+    const view = activitiesFrom(progress)
+    // All 15 tool executions must be preserved
+    expect(view.items).toHaveLength(15)
+    // The very first tool execution must still be present and intact
+    expect(view.items[0].target).toBe('echo step 0')
+    expect(view.items[14].target).toBe('echo step 14')
+    // Timeline must not drop the early groups
+    expect(view.timeline?.length).toBeGreaterThan(15)
+  })
+})
+
+

package/src/renderer/shared/utils/agentActivity.ts

@@ -3,9 +3,9 @@
  * Agent activity parsing and transformation logic.
  * Shared by both Desktop and Web ChatPanel — do NOT duplicate this.
  */
-import type { AgentProgress } from '../types'
+import type { AgentProgress, ActivePlan, RunTelemetrySummary } from '../types'
 import { isInternalCot } from '../agentProgress'
-import { viewedImageDataUri } from './viewedImages'
+import { viewedImageDataUri, viewedImagesFrom, type ViewedImageItem } from './viewedImages'
 
 export interface AgentActivity {
   label: string
@@ -16,6 +16,7 @@ export interface AgentActivity {
   callId?: string
   /** Raw ToolEnd output text, shown when the row is expanded in the UI. */
   result?: string
+  viewedImage?: ViewedImageItem
 }
 
 export interface AgentActivityGroup {
@@ -43,9 +44,28 @@ export interface AgentActivityView {
   timeline?: TimelineItem[]
 }
 
+export function isDummyValue(value: unknown): boolean {
+  if (typeof value !== 'string') return false
+  const lower = value.trim().toLowerCase()
+  return (
+    lower === 'null' ||
+    lower === 'undefined' ||
+    lower === 'none' ||
+    lower === 'nil' ||
+    lower === '(null)' ||
+    lower === '""' ||
+    lower === "''"
+  )
+}
+
 function activityDetail(input: Record<string, unknown>, key: string): string {
+  if (!input || typeof input !== 'object') return ''
   const value = input[key]
-  return typeof value === 'string' && value.trim() ? value : ''
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    return isDummyValue(trimmed) ? '' : trimmed
+  }
+  return ''
 }
 
 export function formatActivityTarget(value: string): string {
@@ -72,9 +92,53 @@ export function describeTool(action: string, input: Record<string, unknown>): Ag
     activityDetail(input, 'prompt') ||
     activityDetail(input, 'searchTerm') ||
     activityDetail(input, 'search_term')
-  const command = activityDetail(input, 'command') || activityDetail(input, 'cmd')
+  let command =
+    activityDetail(input, 'command') ||
+    activityDetail(input, 'cmd') ||
+    activityDetail(input, 'script') ||
+    activityDetail(input, 'exec') ||
+    activityDetail(input, 'code') ||
+    activityDetail(input, 'bash') ||
+    activityDetail(input, 'sh')
+
+  if (!command && input && typeof input === 'object') {
+    if (typeof input.arguments === 'object' && input.arguments !== null) {
+      const nested = input.arguments as Record<string, unknown>
+      command =
+        activityDetail(nested, 'command') ||
+        activityDetail(nested, 'cmd') ||
+        activityDetail(nested, 'script') ||
+        activityDetail(nested, 'exec') ||
+        activityDetail(nested, 'code') ||
+        activityDetail(nested, 'bash') ||
+        activityDetail(nested, 'sh')
+    } else if (typeof input.arguments === 'string') {
+      try {
+        const parsed = JSON.parse(input.arguments)
+        if (parsed && typeof parsed === 'object') {
+          command =
+            activityDetail(parsed, 'command') ||
+            activityDetail(parsed, 'cmd') ||
+            activityDetail(parsed, 'script') ||
+            activityDetail(parsed, 'exec') ||
+            activityDetail(parsed, 'code') ||
+            activityDetail(parsed, 'bash') ||
+            activityDetail(parsed, 'sh')
+        }
+      } catch {
+        // best-effort
+      }
+    }
+  }
+
+  if (!command && typeof (input as unknown) === 'string') {
+    const raw = (input as unknown as string).trim()
+    if (raw && !raw.startsWith('{') && !isDummyValue(raw)) command = raw
+  }
+
   const name = activityDetail(input, 'name')
   const tool = activityDetail(input, 'tool')
+  const server = activityDetail(input, 'server')
   const symbol = activityDetail(input, 'symbol') || activityDetail(input, 'ticker')
   const filter = activityDetail(input, 'filter')
   const expression = activityDetail(input, 'expression') || activityDetail(input, 'expr') || activityDetail(input, 'math')
@@ -82,32 +146,59 @@ export function describeTool(action: string, input: Record<string, unknown>): Ag
   const url = activityDetail(input, 'url')
   const selector = activityDetail(input, 'selector')
 
-  const fallbackTarget =
-    action === 'web_search' || action === 'search_code' || action === 'knowledge_search'
-      ? (query || '(empty query)')
-      : action === 'read_file' || action === 'write_file'
-        ? (path || '(empty path)')
-        : action === 'find_definition' || action === 'find_references'
-          ? (symbol || '(empty symbol)')
-          : action === 'run_tests'
-            ? (filter || '(all tests)')
-            : action === 'run_typecheck' || action === 'run_linter'
-              ? (path || 'workspace')
-              : action === 'run_shell'
-                ? (command || '(empty command)')
-                : action === 'calculation'
-                  ? (expression || '(math expression)')
-                  : action === 'weather'
-                    ? (city || '(location)')
-                    : action === 'stock'
-                      ? (query || symbol || '(symbol)')
-                      : action === 'browser_open'
-                        ? (url || '(url)')
-                        : action === 'browser_click'
-                          ? (selector || '(element)')
-                          : action.replaceAll('_', ' ')
-
-  const rawTarget = path || query || command || expression || symbol || city || url || selector || filter || name || tool || fallbackTarget
+  let rawTarget = ''
+  switch (action) {
+    case 'run_shell':
+      rawTarget = command || '(empty command)'
+      break
+    case 'web_search':
+    case 'search_code':
+    case 'knowledge_search':
+      rawTarget = query || '(empty query)'
+      break
+    case 'read_file':
+    case 'write_file':
+    case 'view_image':
+      rawTarget = path || '(empty path)'
+      break
+    case 'find_definition':
+    case 'find_references':
+      rawTarget = symbol || '(empty symbol)'
+      break
+    case 'run_tests':
+      rawTarget = filter || '(all tests)'
+      break
+    case 'run_typecheck':
+    case 'run_linter':
+      rawTarget = path || 'workspace'
+      break
+    case 'calculation':
+    case 'calculator':
+      rawTarget = expression || '(math expression)'
+      break
+    case 'weather':
+      rawTarget = city || '(location)'
+      break
+    case 'stock':
+      rawTarget = query || symbol || '(symbol)'
+      break
+    case 'browser_open':
+    case 'browser_navigate':
+      rawTarget = url || '(url)'
+      break
+    case 'browser_click':
+      rawTarget = selector || '(element)'
+      break
+    case 'mcp_tool':
+      rawTarget = tool ? (server ? `${server}/${tool}` : tool) : (name || 'mcp tool')
+      break
+    case 'note_write':
+      rawTarget = name || path || '(note)'
+      break
+    default:
+      rawTarget = path || query || command || expression || symbol || city || url || selector || filter || name || tool || action.replaceAll('_', ' ')
+      break
+  }
 
   // Append line range for read_file when startLine / endLine are available
   let target = rawTarget
@@ -281,6 +372,7 @@ function deriveActivitiesFrom(progress: AgentProgress[]): AgentActivityView {
 
   for (const event of progress) {
     if (event.type === 'ToolStart') {
+      if (event.data.subagent) continue
       const item = describeTool(event.data.action, event.data.input)
       item.callId = event.data.callId
       activities.push(item)
@@ -313,6 +405,7 @@ function deriveActivitiesFrom(progress: AgentProgress[]): AgentActivityView {
         }
       }
     } else if (event.type === 'ToolEnd') {
+      if (event.data.subagent) continue
       const finished = describeTool(event.data.action, event.data.input)
       for (let index = activities.length - 1; index >= 0; index -= 1) {
         if (activities[index].state !== 'active') continue
@@ -344,9 +437,10 @@ function deriveActivitiesFrom(progress: AgentProgress[]): AgentActivityView {
         currentGroup.state = hasActive ? 'active' : hasDone ? 'done' : hasRetry ? 'retry' : hasError ? 'error' : 'done'
       }
     } else if (event.type === 'ContextCompaction') {
+      if (event.data.subagent) continue
       if (event.data.status !== 'started') {
         flushGroup()
-        timeline.push({ id: `context-${nextId++}`, kind: 'thought', thought: event.data.subagent ? `[${event.data.subagent}] ${event.data.message}` : event.data.message })
+        timeline.push({ id: `context-${nextId++}`, kind: 'thought', thought: event.data.message })
       }
     } else if (event.type === 'Thought') {
       const text = event.data?.thought?.trim()
@@ -420,6 +514,32 @@ function deriveActivitiesFrom(progress: AgentProgress[]): AgentActivityView {
     }
   }
 
+  const viewedImages = viewedImagesFrom(progress)
+  if (viewedImages.length > 0) {
+    const byCallId = new Map<string, ViewedImageItem>()
+    const byPath = new Map<string, ViewedImageItem[]>()
+    for (const img of viewedImages) {
+      if (img.id) byCallId.set(img.id, img)
+      if (img.path) {
+        const list = byPath.get(img.path) || []
+        list.push(img)
+        byPath.set(img.path, list)
+      }
+    }
+    for (const act of activities) {
+      if (act.action === 'view_image' && act.state === 'done') {
+        if (act.callId && byCallId.has(act.callId)) {
+          act.viewedImage = byCallId.get(act.callId)
+        } else if (byPath.has(act.target)) {
+          const list = byPath.get(act.target)!
+          if (list.length > 0) {
+            act.viewedImage = list.shift()
+          }
+        }
+      }
+    }
+  }
+
   const items = activities.slice(-25)
   return { summary: activitySummary(activities), items, groups: groupActivities(items), timeline: timeline.slice(-60) }
 }
@@ -495,3 +615,33 @@ export function cleanIntermediateThought(text: string): string {
   cleaned = cleaned.replace(/^[\s•\-\*]+\s*/, '')
   return cleaned.trim() || text.trim()
 }
+
+export function extractLatestPlan(progress: AgentProgress[]): ActivePlan | undefined {
+  for (let i = progress.length - 1; i >= 0; i--) {
+    const event = progress[i]
+    if (event.type === 'PlanUpdated') {
+      return event.data.plan
+    }
+  }
+  return undefined
+}
+
+export function extractLatestRunSummary(progress: AgentProgress[]): RunTelemetrySummary | undefined {
+  for (let i = progress.length - 1; i >= 0; i--) {
+    const event = progress[i]
+    if (event.type === 'RunCompleted') {
+      return event.data.summary
+    }
+  }
+  return undefined
+}
+
+export function hasSubagentActivity(progress: AgentProgress[]): boolean {
+  return progress.some(
+    (e) =>
+      e.type === 'SubagentStarted' ||
+      e.type === 'SubagentFinished' ||
+      ((e.type === 'ToolStart' || e.type === 'ToolEnd') &&
+        (e.data.subagent || e.data.action === 'dispatch_agents' || e.data.action === 'dispatch_subagent')),
+  )
+}

package/src/renderer/shared/utils/artifactBrowser.ts

@@ -1,4 +1,4 @@
-import type { ArtifactFile } from '../components/ArtifactPreviewPanel'
+import type { ArtifactFile } from './artifacts'
 import { runtimePlatform, workspacePlatform } from '../platform'
 
 interface BrowserApi {

package/src/renderer/shared/utils/artifacts.ts

@@ -0,0 +1,55 @@
+export type ArtifactType =
+  | 'html'
+  | 'svg'
+  | 'markdown'
+  | 'image'
+  | 'code'
+  | 'file'
+  | 'pdf'
+  | 'audio'
+  | 'video'
+
+export type ViewportMode = 'desktop' | 'tablet' | 'mobile'
+
+export interface ArtifactFile {
+  path: string
+  workspacePath?: string
+  url?: string
+  content?: string
+  type?: ArtifactType
+  mimeType?: string
+  byteLength?: number
+  objectUrl?: boolean
+  range?: boolean
+}
+
+export function detectArtifactType(filePath: string): ArtifactType {
+  const lower = filePath.toLowerCase()
+  if (lower.endsWith('.html') || lower.endsWith('.htm')) return 'html'
+  if (/\.(png|jpe?g|gif|webp|ico)$/.test(lower)) return 'image'
+  if (lower.endsWith('.svg')) return 'svg'
+  if (lower.endsWith('.md') || lower.endsWith('.markdown')) return 'markdown'
+  if (lower.endsWith('.pdf')) return 'pdf'
+  if (/\.(mp3|wav|ogg|oga|opus|flac|m4a|aac|weba)$/.test(lower)) return 'audio'
+  if (/\.(mp4|m4v|webm|ogv|mov)$/.test(lower)) return 'video'
+  return 'code'
+}
+
+export function getFileLanguage(filePath: string): string {
+  const ext = filePath.split('.').pop()?.toLowerCase() || ''
+  const map: Record<string, string> = {
+    js: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'typescript',
+    html: 'html',
+    htm: 'html',
+    css: 'css',
+    json: 'json',
+    rs: 'rust',
+    py: 'python',
+    svg: 'xml',
+    md: 'markdown',
+  }
+  return map[ext] || ext || 'plaintext'
+}

package/src/renderer/shared/utils/contextCompaction.test.tsx

@@ -2,7 +2,7 @@ import React from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { describe, expect, it } from 'vitest'
 import { activeCompactionFrom } from './contextCompaction'
-import { ContextCompactionStatus } from '../components/ContextCompactionStatus'
+import { ContextCompactionStatus } from '../components/chat/ContextCompactionStatus'
 import { activitiesFrom } from './agentActivity'
 import type { AgentProgress } from '../types'