@bibobonking/opensol 3.1.5 → 3.2.0

package/src/components/composer/PlusMenu.tsx

@@ -0,0 +1,117 @@
+import { useEffect, useState } from 'react'
+import { Check, Globe2, Paperclip, Plug, Plus, Sparkles } from 'lucide-react'
+import { useSettings } from '../../store/settings'
+import { useSkills } from '../../store/skills'
+import { useMcp } from '../../store/mcp'
+import { useUi } from '../../store/ui'
+import { Popover } from './Popover'
+import { cn } from '../../lib/utils'
+
+function Row({
+  icon: Icon,
+  label,
+  hint,
+  active,
+  onClick,
+}: {
+  icon: typeof Plus
+  label: string
+  hint?: string
+  active?: boolean
+  onClick: () => void
+}) {
+  return (
+    <button
+      type="button"
+      onClick={onClick}
+      className="flex w-full items-center gap-2.5 rounded-lg px-2 py-1.5 text-left text-[12px] text-ink transition-colors hover:bg-raised"
+    >
+      <Icon size={14} className="shrink-0 text-faint" />
+      <span className="min-w-0 flex-1 truncate">{label}</span>
+      {hint && <span className="shrink-0 text-[10.5px] text-faint">{hint}</span>}
+      {active !== undefined && (
+        <span className="flex h-4 w-4 shrink-0 items-center justify-center">
+          {active && <Check size={13} className="text-accent" />}
+        </span>
+      )}
+    </button>
+  )
+}
+
+/** The "+" menu: files, web search, mode, skills and MCP. */
+export function PlusMenu({ onAddFiles }: { onAddFiles: () => void }) {
+  const settings = useSettings()
+  const update = useSettings((state) => state.update)
+  const enabledCount = useSkills((state) => state.skills.filter((skill) => skill.enabled).length)
+  const skillsLoaded = useSkills((state) => state.loaded)
+  const loadSkills = useSkills((state) => state.load)
+  const servers = useMcp((state) => state.servers)
+  const mcpLoaded = useMcp((state) => state.loaded)
+  const loadMcp = useMcp((state) => state.load)
+  const openSettings = useUi((state) => state.openSettings)
+  const setMcpOpen = useUi((state) => state.setMcpOpen)
+  const [open, setOpen] = useState(false)
+
+  useEffect(() => {
+    if (!open) return
+    if (!skillsLoaded) void loadSkills()
+    if (!mcpLoaded) void loadMcp()
+  }, [open, skillsLoaded, mcpLoaded, loadSkills, loadMcp])
+
+  const connected = servers.filter((server) => server.status === 'connected').length
+  const close = () => setOpen(false)
+
+  return (
+    <Popover
+      open={open}
+      onClose={close}
+      width={280}
+      trigger={
+        <button
+          type="button"
+          onClick={() => setOpen((value) => !value)}
+          className={cn('icon-button h-8 w-8', open && 'bg-raised text-ink')}
+          aria-label="Add files, skills and tools"
+          aria-expanded={open}
+          title="Add files, skills and tools"
+        >
+          <Plus size={16} className={cn('transition-transform duration-200', open && 'rotate-45')} />
+        </button>
+      }
+    >
+      <Row
+        icon={Paperclip}
+        label="Add files or photos"
+        onClick={() => {
+          close()
+          onAddFiles()
+        }}
+      />
+      <Row
+        icon={Globe2}
+        label="Web search"
+        active={settings.webSearchEnabled}
+        onClick={() => update({ webSearchEnabled: !settings.webSearchEnabled })}
+      />
+      <Row
+        icon={Plug}
+        label="MCP servers"
+        hint={servers.length ? `${connected}/${servers.length} connected` : 'Add'}
+        onClick={() => {
+          close()
+          setMcpOpen(true)
+        }}
+      />
+
+      <Row
+        icon={Sparkles}
+        label="Skills"
+        hint={enabledCount ? `${enabledCount} on` : undefined}
+        onClick={() => {
+          close()
+          openSettings('skills')
+        }}
+      />
+    </Popover>
+  )
+}

package/src/components/composer/Popover.tsx

@@ -0,0 +1,109 @@
+import { useLayoutEffect, useRef, useState, type ReactNode } from 'react'
+import { useClickOutside } from '../../lib/hooks'
+import { cn } from '../../lib/utils'
+
+const EDGE = 12
+const GAP = 8
+
+/**
+ * A trigger plus a floating panel. It opens on the side with room (flipping above/below, and
+ * left/right), never grows past `maxHeight` or the viewport, and scrolls inside when longer.
+ */
+export function Popover({
+  open,
+  onClose,
+  trigger,
+  children,
+  width = 260,
+  placement = 'above',
+  maxHeight = 260,
+  className,
+}: {
+  open: boolean
+  onClose: () => void
+  trigger: ReactNode
+  children: ReactNode
+  width?: number
+  /** Preferred side; flips when the other side has clearly more room. */
+  placement?: 'above' | 'below'
+  /** Upper bound for the panel height before it scrolls. */
+  maxHeight?: number
+  className?: string
+}) {
+  const wrapperRef = useRef<HTMLDivElement>(null)
+  const panelRef = useRef<HTMLDivElement>(null)
+  const [layout, setLayout] = useState({ side: placement, height: maxHeight, alignRight: false })
+  useClickOutside(wrapperRef, onClose, open)
+
+  useLayoutEffect(() => {
+    if (!open) return
+    const measure = () => {
+      const wrapper = wrapperRef.current
+      if (!wrapper) return
+      const rect = wrapper.getBoundingClientRect()
+      const above = rect.top - EDGE - GAP
+      const below = window.innerHeight - rect.bottom - EDGE - GAP
+      const natural = Math.min(panelRef.current?.scrollHeight ?? maxHeight, maxHeight)
+      const fits = (room: number) => room >= natural
+      const preferred = placement === 'above' ? above : below
+      const other = placement === 'above' ? below : above
+      const side = fits(preferred) || preferred >= other ? placement : placement === 'above' ? 'below' : 'above'
+      const room = side === 'above' ? above : below
+      setLayout({
+        side,
+        height: Math.max(96, Math.min(maxHeight, room)),
+        alignRight: rect.left + width > window.innerWidth - EDGE,
+      })
+    }
+    measure()
+    window.addEventListener('resize', measure)
+    return () => window.removeEventListener('resize', measure)
+  }, [open, placement, maxHeight, width])
+
+  return (
+    <div ref={wrapperRef} className="relative">
+      {trigger}
+      {open && (
+        <div
+          ref={panelRef}
+          style={{ width, maxHeight: layout.height }}
+          className={cn(
+            'surface-lift thin-scroll animate-scalein absolute z-40 max-w-[calc(100vw-24px)] overflow-y-auto overscroll-contain rounded-2xl border border-line p-1.5 shadow-float',
+            layout.alignRight ? 'right-0' : 'left-0',
+            layout.side === 'above' ? 'bottom-[calc(100%+8px)]' : 'top-[calc(100%+6px)]',
+            className,
+          )}
+        >
+          {children}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export function MenuLabel({ children }: { children: ReactNode }) {
+  return <p className="px-2 pb-1 pt-1.5 text-[10px] font-medium uppercase tracking-[0.1em] text-faint">{children}</p>
+}
+
+/** A plain-text toolbar button: no border or fill until it is hovered or its panel is open. */
+export function TextButton({
+  children,
+  open,
+  className,
+  ...props
+}: React.ButtonHTMLAttributes<HTMLButtonElement> & { open?: boolean }) {
+  return (
+    <button
+      type="button"
+      aria-expanded={open}
+      {...props}
+      className={cn(
+        'flex h-8 items-center gap-1 rounded-lg px-2 text-[12px] font-medium text-muted transition-colors hover:text-ink disabled:cursor-not-allowed disabled:opacity-45',
+        open && 'text-ink',
+        className,
+      )}
+    >
+      {children}
+    </button>
+  )
+}

package/src/components/composer/WorkspacePicker.tsx

@@ -0,0 +1,102 @@
+import { useState } from 'react'
+import { Check, ChevronDown, FolderOpen, GitBranch } from 'lucide-react'
+import { useUi } from '../../store/ui'
+import { useWorkspace } from '../../store/workspace'
+import { Popover, MenuLabel, TextButton } from './Popover'
+import { cn } from '../../lib/utils'
+
+/** The project folder, shown above the composer. Click to switch folders. */
+export function WorkspacePicker() {
+  const info = useWorkspace((state) => state.info)
+  const git = useWorkspace((state) => state.git)
+  const addWorkspace = useWorkspace((state) => state.addWorkspace)
+  const setWorkspaceOpen = useUi((state) => state.setWorkspaceOpen)
+  const notify = useUi((state) => state.notify)
+  const [open, setOpen] = useState(false)
+  const [switching, setSwitching] = useState('')
+
+  const choose = async (path: string) => {
+    if (path === info.root) {
+      setOpen(false)
+      return
+    }
+    setSwitching(path)
+    try {
+      await addWorkspace(path)
+      setOpen(false)
+    } catch (error) {
+      notify(error instanceof Error ? error.message : 'Could not open that folder.', 'error')
+    } finally {
+      setSwitching('')
+    }
+  }
+
+  const recent = [...info.workspaces].sort((a, b) => b.lastOpened - a.lastOpened)
+
+  return (
+    <Popover
+      open={open}
+      onClose={() => setOpen(false)}
+      placement="below"
+      width={280}
+      maxHeight={260}
+      trigger={
+        <TextButton
+          open={open}
+          onClick={() => setOpen((value) => !value)}
+          title={info.available ? info.root : 'Choose a project folder'}
+          className="max-w-[240px]"
+        >
+          <FolderOpen size={13} className="shrink-0 text-faint" />
+          <span className="truncate">{info.available ? info.name : 'Select folder'}</span>
+          {info.available && git.available && git.branch && (
+            <span className="flex shrink-0 items-center gap-0.5 text-faint">
+              <GitBranch size={11} />
+              {git.branch}
+            </span>
+          )}
+          <ChevronDown size={11} className={cn('shrink-0 text-faint transition-transform', open && 'rotate-180')} />
+        </TextButton>
+      }
+    >
+      <MenuLabel>Folders</MenuLabel>
+      <div>
+        {recent.length === 0 && <p className="px-2 pb-2 text-[11.5px] text-faint">No folders yet.</p>}
+        {recent.map((workspace) => (
+          <button
+            key={workspace.path}
+            type="button"
+            onClick={() => void choose(workspace.path)}
+            disabled={Boolean(switching)}
+            className="flex w-full items-center gap-2 rounded-lg px-2 py-1.5 text-left transition-colors hover:bg-raised disabled:opacity-60"
+            title={workspace.path}
+          >
+            <span className="flex h-4 w-4 shrink-0 items-center justify-center">
+              {workspace.path === info.root ? <Check size={12} className="text-accent" /> : <FolderOpen size={12} className="text-faint" />}
+            </span>
+            <span className="min-w-0 flex-1">
+              <span className="block truncate text-[12px] font-medium text-ink">{workspace.name}</span>
+              <span className="block truncate text-[10px] text-faint">{workspace.path}</span>
+            </span>
+            {switching === workspace.path && (
+              <span className="h-3 w-3 shrink-0 animate-spin rounded-full border border-current border-t-transparent text-faint" />
+            )}
+          </button>
+        ))}
+      </div>
+      <div className="mt-1 border-t border-line pt-1">
+        <button
+          type="button"
+          onClick={() => {
+            setOpen(false)
+            setWorkspaceOpen(true)
+          }}
+          className="flex w-full items-center gap-2 rounded-lg px-2 py-1.5 text-left text-[12px] text-muted transition-colors hover:bg-raised hover:text-ink"
+        >
+          <FolderOpen size={12} className="text-faint" />
+          Open another folder…
+        </button>
+      </div>
+    </Popover>
+  )
+}

package/src/core/plugins/tools/shell.ts

@@ -55,11 +55,11 @@ export function apply(ctx: Context) {
   return ctx.tools.register({
     name: 'shell',
     description:
-      'Run a shell command in the workspace root. The working directory resets between calls. Prefer dedicated file and git tools for edits. In Plan mode only read-only commands are accepted.',
+      'Run a command in the user\'s default shell (bash/zsh on Linux and macOS, PowerShell on Windows; see the Environment section) from the workspace root. The working directory resets between calls. Prefer dedicated file and git tools for edits. In Plan mode only read-only commands are accepted.',
     parameters: {
       type: 'object',
       properties: {
-        command: { type: 'string', description: 'The shell command to run.' },
+        command: { type: 'string', description: 'The command to run, written for the shell named in the Environment section.' },
         timeoutMs: { type: 'number', description: 'Timeout in milliseconds (max 600000).' },
       },
       required: ['command'],

package/src/core/plugins/tools/subagent.ts

@@ -1,5 +1,6 @@
 import type { Context } from 'cordis'
 import type { ToolResult } from '../../types'
+import { SUBAGENT_TYPES, subagentType } from '../../../lib/subagent-types'
 
 const MAX_TOOL_OUTPUT = 28_000
 
@@ -12,25 +13,34 @@ export const name = 'tool-subagent'
 export const inject = ['tools', 'subagents']
 
 export function apply(ctx: Context) {
+  const kinds = Object.entries(SUBAGENT_TYPES)
+    .map(([id, spec]) => `"${id}" (${spec.summary})`)
+    .join('; ')
   return ctx.tools.register({
     name: 'subagent',
-    description:
-      'Delegate a focused investigation to a read-only subagent. Use it to explore a large area, trace a bug or verify assumptions without changing files. The subagent returns a concise report.',
+    description: `Delegate a focused, read-only investigation to a subagent that works in its own context and returns a concise report. Types: ${kinds}. Give it a complete, self-contained task (it cannot see this conversation) and any file paths or constraints as context. To investigate independent questions in parallel, call this tool several times in the same message.`,
     parameters: {
       type: 'object',
       properties: {
-        task: { type: 'string', description: 'The specific question or investigation to perform.' },
-        context: { type: 'string', description: 'Optional context, constraints or files to start from.' },
+        task: { type: 'string', description: 'The specific question or investigation. Be precise about what the report must contain.' },
+        context: { type: 'string', description: 'Optional context: files to start from, what is already known, constraints.' },
+        type: { type: 'string', enum: Object.keys(SUBAGENT_TYPES), description: 'explore (default), research or review.' },
       },
       required: ['task'],
       additionalProperties: false,
     },
     allowedInMode: () => true,
     async execute(args, exec): Promise<ToolResult> {
-      const task = typeof args.task === 'string' ? args.task : ''
-      const context = typeof args.context === 'string' ? args.context : ''
-      const output = await ctx.subagents.run(task, context, exec.signal)
-      return { output: truncate(output), isError: false }
+      const report = await ctx.subagents.run({
+        task: typeof args.task === 'string' ? args.task : '',
+        context: typeof args.context === 'string' ? args.context : '',
+        type: subagentType(args.type),
+        signal: exec.signal,
+        sessionId: exec.sessionId,
+        onProgress: exec.onProgress,
+      })
+      const footer = `\n\n— subagent: ${report.toolCalls} tool call${report.toolCalls === 1 ? '' : 's'}, ${report.rounds} round${report.rounds === 1 ? '' : 's'}${report.capped ? ', stopped at its round budget' : ''}`
+      return { output: truncate(report.output) + footer, isError: false }
     },
   })
 }

package/src/core/services/agent-loop.ts

@@ -1,5 +1,5 @@
 import { Service, type Context } from 'cordis'
-import type { AssistantMessage, ToolMessage } from '../../types'
+import type { AssistantMessage, ToolCall, ToolMessage } from '../../types'
 import { activeModelId, useSettings } from '../../store/settings'
 import { createId } from '../../store/chats'
 import { findModel } from '../../store/models'
@@ -32,11 +32,6 @@ function isAbortError(error: unknown) {
   )
 }
 
-function truncate(value: string, limit = 40_000) {
-  if (value.length <= limit) return value
-  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
-}
-
 export class AgentLoopService extends Service {
   static provide = 'agentLoop'
   static inject = ['sessions', 'systemPrompt', 'tools', 'llm', 'approval', 'compaction', 'subagents']
@@ -116,13 +111,14 @@ export class AgentLoopService extends Service {
         let current = this.ctx.sessions.current(sessionId)
         if (!current) break
 
-        // Auto-compaction check before round 0
-        // A prompt queued behind this turn would be dropped by the rewrite, so wait until it is the last one.
-        if (round === 0 && lastUserMessageId(current.messages) === userMessageId) {
-          const compacted = await this.ctx.compaction.checkAutoCompact(sessionId)
+        // Auto-compaction: before the turn starts and again between tool rounds, since one long turn can
+        // fill the window. A prompt queued behind this turn would be dropped by the rewrite, so wait
+        // until this turn is the last one.
+        if (lastUserMessageId(current.messages) === userMessageId) {
+          const compacted = await this.ctx.compaction.checkAutoCompact(sessionId, { midTurn: round > 0 })
           if (compacted) {
-            // Compaction rewrites the whole transcript, so the original user message
-            // is gone: continue from the handoff message and the fresh session state.
+            // The transcript was rewritten: continue from its newest user message (the kept prompt,
+            // or the handoff note when compaction happened mid-turn).
             const refreshed = this.ctx.sessions.current(sessionId)
             if (!refreshed) break
             const handoffId = lastUserMessageId(refreshed.messages)
@@ -275,8 +271,7 @@ export class AgentLoopService extends Service {
 
         const toolMessages: ToolMessage[] = []
 
-        for (const call of result.toolCalls) {
-          if (controller.signal.aborted) break
+        const runToolCall = async (call: ToolCall): Promise<{ message: ToolMessage; stopped: boolean }> => {
           const toolSetting = resolveToolSetting(settings, call.name)
           if (!toolSetting?.enabled) {
             const message: ToolMessage = {
@@ -289,46 +284,39 @@ export class AgentLoopService extends Service {
               createdAt: Date.now(),
             }
             this.ctx.sessions.addMessage(sessionId, message)
-            toolMessages.push(message)
-            continue
+            return { message, stopped: false }
           }
 
           const toolMessageId = createId('tool')
-          const awaiting = toolSetting.approval === 'ask'
           const toolMessage: ToolMessage = {
             id: toolMessageId,
             role: 'tool',
             call,
-            status: awaiting ? 'awaiting' : 'running',
+            status: toolSetting.approval === 'ask' ? 'awaiting' : 'running',
             round,
             createdAt: Date.now(),
           }
           this.ctx.sessions.addMessage(sessionId, toolMessage)
 
+          // Long tools (subagents) stream a short live log into their card.
+          let progressTimer: number | undefined
+          let progressText = ''
+          const onProgress = (text: string) => {
+            progressText = text
+            if (progressTimer !== undefined) return
+            progressTimer = window.setTimeout(() => {
+              progressTimer = undefined
+              this.ctx.sessions.updateMessage(sessionId, toolMessageId, { result: progressText })
+            }, 250)
+          }
+
           const toolStarted = Date.now()
           try {
-            const output =
-              call.name === 'subagent'
-                ? {
-                    output: truncate(
-                      await this.ctx.subagents.run(
-                        typeof call.args.task === 'string' ? call.args.task : '',
-                        typeof call.args.context === 'string' ? call.args.context : '',
-                        controller.signal,
-                        sessionId,
-                      ),
-                    ),
-                    isError: false,
-                  }
-                : await this.ctx.tools.execute(
-                    call.name,
-                    call.args,
-                    settings,
-                    mode,
-                    controller.signal,
-                    call.id,
-                    userMessageId,
-                  )
+            const output = await this.ctx.tools.execute(call.name, call.args, settings, mode, controller.signal, call.id, userMessageId, {
+              sessionId,
+              onProgress,
+            })
+            if (progressTimer !== undefined) window.clearTimeout(progressTimer)
             const finalToolMessage: ToolMessage = {
               ...toolMessage,
               status: output.isError ? 'error' : 'done',
@@ -337,8 +325,9 @@ export class AgentLoopService extends Service {
               diff: output.diff,
             }
             this.ctx.sessions.updateMessage(sessionId, toolMessageId, finalToolMessage)
-            toolMessages.push(finalToolMessage)
+            return { message: finalToolMessage, stopped: false }
           } catch (error) {
+            if (progressTimer !== undefined) window.clearTimeout(progressTimer)
             const stopped = isAbortError(error)
             const finalToolMessage: ToolMessage = {
               ...toolMessage,
@@ -347,9 +336,22 @@ export class AgentLoopService extends Service {
               durationMs: Date.now() - toolStarted,
             }
             this.ctx.sessions.updateMessage(sessionId, toolMessageId, finalToolMessage)
-            toolMessages.push(finalToolMessage)
-            if (stopped) break
+            return { message: finalToolMessage, stopped }
+          }
+        }
+
+        // Calls run in order, except that neighbouring subagent calls run side by side.
+        const calls = result.toolCalls
+        for (let index = 0; index < calls.length; ) {
+          if (controller.signal.aborted) break
+          let end = index + 1
+          if (calls[index].name === 'subagent') {
+            while (end < calls.length && calls[end].name === 'subagent') end += 1
           }
+          const outcomes = await Promise.all(calls.slice(index, end).map(runToolCall))
+          toolMessages.push(...outcomes.map((outcome) => outcome.message))
+          if (outcomes.some((outcome) => outcome.stopped)) break
+          index = end
         }
 
         const stepResult: StepResult = {