@bibobonking/opensol 3.1.5 → 3.2.0

package/src/lib/compact-plan.test.mjs

@@ -0,0 +1,62 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { planCompaction, collectFiles, clip, chunkParts, previousSummary, transcriptParts, tokensOf } from './compact-plan.ts'
+
+const user = (id, text = 'x'.repeat(300)) => ({ id, role: 'user', content: text, createdAt: 0 })
+const asst = (id, calls = [], content = 'ok') => ({ id, role: 'assistant', content, reasoning: '', toolCalls: calls, round: 0, createdAt: 0 })
+const tool = (id, name = 'read_file', result = 'r'.repeat(300)) => ({ id, role: 'tool', call: { id: `${id}c`, name, args: {} }, status: 'done', result, round: 0, createdAt: 0 })
+
+const turn = (n) => [user(`u${n}`), asst(`a${n}`, [{ id: `c${n}`, name: 'read_file', args: {} }]), tool(`t${n}`), asst(`b${n}`)]
+
+test('keeps the newest turns that fit and cuts at a user message', () => {
+  const messages = [1, 2, 3, 4, 5].flatMap(turn)
+  const plan = planCompaction(messages, tokensOf(turn(1)) * 2 + 10)
+  assert.ok(plan)
+  assert.equal(plan.tail[0].role, 'user')
+  assert.equal(plan.tail.filter((m) => m.role === 'user').length, 2)
+  assert.equal(plan.head.length + plan.tail.length, messages.length)
+})
+
+test('never separates a tool call from its result', () => {
+  const messages = [1, 2, 3].flatMap(turn)
+  const plan = planCompaction(messages, 1)
+  assert.ok(plan)
+  assert.equal(plan.tail.length, 4) // only the newest turn, whole
+})
+
+test('returns null when there is nothing to cut', () => {
+  assert.equal(planCompaction(turn(1), 10_000), null)
+  assert.equal(planCompaction([], 100), null)
+})
+
+test('tracks written files once, most recent last', () => {
+  const calls = (name, path) => asst('a', [{ id: path + name, name, args: { path } }])
+  const files = collectFiles([calls('write_file', 'a.ts'), calls('read_file', 'z.ts'), calls('edit_file', 'b.ts'), calls('edit_file', 'a.ts')], ['old.ts'])
+  assert.deepEqual(files, ['old.ts', 'b.ts', 'a.ts'])
+})
+
+test('clip keeps head and tail', () => {
+  const text = `START${'m'.repeat(1000)}END`
+  const out = clip(text, 100)
+  assert.ok(out.startsWith('START') && out.endsWith('END') && out.length < 200)
+  assert.equal(clip('short', 100), 'short')
+})
+
+test('chunks never split a part and respect the size', () => {
+  const chunks = chunkParts(['a'.repeat(50), 'b'.repeat(50), 'c'.repeat(50)], 120)
+  assert.equal(chunks.length, 2)
+  assert.ok(chunks[0].includes('a') && chunks[0].includes('b') && !chunks[0].includes('c'))
+})
+
+test('previousSummary reads a [task, summary] pair', () => {
+  const summary = { ...asst('s'), content: 'SUM', compaction: { files: ['f.ts'], turns: 2, toolCalls: 3, at: 1, trigger: 'auto' } }
+  assert.deepEqual(previousSummary([user('u'), summary, user('u2')]), { text: 'SUM', files: ['f.ts'], skip: 2 })
+  assert.equal(previousSummary([user('u'), asst('a')]), null)
+})
+
+test('read_file output is trimmed harder than shell output in transcripts', () => {
+  const big = 'q'.repeat(5000)
+  const [read] = transcriptParts([tool('t1', 'read_file', big)])
+  const [shell] = transcriptParts([tool('t2', 'shell', big)])
+  assert.ok(read.length < shell.length)
+})

package/src/lib/compact-plan.ts

@@ -0,0 +1,188 @@
+/**
+ * Pure helpers for smart compaction (no stores, no network, so node:test can run them).
+ *
+ * Strategy: keep the most recent turns verbatim, summarise everything older, and carry the
+ * previous summary forward instead of summarising a summary. File paths touched are tracked
+ * deterministically, so the model cannot forget them.
+ */
+import type { AssistantMessage, Message, ToolMessage, UserMessage } from '../types'
+
+const CHARS_PER_TOKEN = 3
+
+export const WRITE_TOOLS = new Set(['write_file', 'edit_file', 'rewrite_file'])
+
+export function messageTokens(message: Message): number {
+  if (message.role === 'user') {
+    const extra = (message.attachments ?? []).reduce((sum, item) => sum + (item.text?.length ?? 0), 0)
+    return Math.ceil((message.content.length + extra) / CHARS_PER_TOKEN) + 4
+  }
+  if (message.role === 'assistant') {
+    const calls = message.toolCalls.reduce((sum, call) => sum + JSON.stringify(call.args).length + call.name.length + 10, 0)
+    return Math.ceil((message.content.length + message.reasoning.length + calls) / CHARS_PER_TOKEN) + 4
+  }
+  return Math.ceil((message.result ?? '').length / CHARS_PER_TOKEN) + 4
+}
+
+export function tokensOf(messages: Message[]): number {
+  return messages.reduce((sum, message) => sum + messageTokens(message), 0)
+}
+
+/** Keeps the start and the end of long text, because the end of a log usually matters most. */
+export function clip(text: string, limit: number, tailRatio = 0.35): string {
+  if (text.length <= limit) return text
+  const tail = Math.floor(limit * tailRatio)
+  const head = limit - tail
+  return `${text.slice(0, head)}\n… [${text.length - limit} characters omitted] …\n${text.slice(text.length - tail)}`
+}
+
+export function isSummaryMessage(message: Message | undefined): message is AssistantMessage {
+  return Boolean(message && message.role === 'assistant' && message.compaction)
+}
+
+export interface CompactionPlan {
+  /** Messages [0, cut) are summarised; [cut, end) stay verbatim. */
+  cut: number
+  head: Message[]
+  tail: Message[]
+  /** The cut had to land inside the running turn because older turns alone were too small. */
+  midTurn: boolean
+}
+
+/**
+ * Chooses where to cut. The tail always starts at a user message (so provider alternation stays
+ * valid and tool calls never lose their results) and is the newest run of turns that fits in
+ * `keepTokens`. The newest turn is always kept. Returns null when there is nothing worth cutting.
+ */
+export function planCompaction(messages: Message[], keepTokens: number, minHeadMessages = 4): CompactionPlan | null {
+  const userIndexes: number[] = []
+  messages.forEach((message, index) => {
+    if (message.role === 'user') userIndexes.push(index)
+  })
+  if (userIndexes.length === 0) return null
+
+  // Walk turns from the newest backwards while they fit in the keep budget.
+  let cut = userIndexes[userIndexes.length - 1]
+  let kept = tokensOf(messages.slice(cut))
+  for (let i = userIndexes.length - 2; i >= 0; i -= 1) {
+    const turnTokens = tokensOf(messages.slice(userIndexes[i], userIndexes[i + 1]))
+    if (kept + turnTokens > keepTokens) break
+    kept += turnTokens
+    cut = userIndexes[i]
+  }
+
+  // Skip an existing summary pair (task message + summary) at the very start: it is always head.
+  if (cut < minHeadMessages) return null
+  return { cut, head: messages.slice(0, cut), tail: messages.slice(cut), midTurn: false }
+}
+
+/** Previous summary text, when the head starts with `[task user message, summary]`. */
+export function previousSummary(head: Message[]): { text: string; files: string[]; skip: number } | null {
+  const summary = head[1]
+  if (head[0]?.role === 'user' && isSummaryMessage(summary)) {
+    return { text: summary.content, files: summary.compaction?.files ?? [], skip: 2 }
+  }
+  return null
+}
+
+/** Paths written or edited by tool calls, newest last, de-duplicated. */
+export function collectFiles(messages: Message[], seed: string[] = []): string[] {
+  const seen = new Set(seed)
+  const ordered = [...seed]
+  for (const message of messages) {
+    if (message.role !== 'assistant') continue
+    for (const call of message.toolCalls) {
+      const path = typeof call.args.path === 'string' ? call.args.path : ''
+      if (!path || !WRITE_TOOLS.has(call.name)) continue
+      if (seen.has(path)) {
+        ordered.splice(ordered.indexOf(path), 1)
+      }
+      seen.add(path)
+      ordered.push(path)
+    }
+  }
+  return ordered
+}
+
+function toolResultLimit(message: ToolMessage): number {
+  const name = message.call.name
+  if (message.status === 'error') return 1500
+  if (name === 'read_file') return 700 // contents can be re-read; keep only the shape
+  if (name === 'write_file' || name === 'edit_file' || name === 'rewrite_file') return 400
+  if (name === 'shell') return 2500
+  return 1500
+}
+
+function callSummary(args: Record<string, unknown>): string {
+  const text = JSON.stringify(args)
+  return text.length > 600 ? `${text.slice(0, 600)}…` : text
+}
+
+/** Transcript lines, one entry per message, so they can be chunked without splitting a message. */
+export function transcriptParts(messages: Message[]): string[] {
+  const parts: string[] = []
+  for (const message of messages) {
+    if (message.role === 'user') {
+      const names = (message.attachments ?? []).map((item) => item.name)
+      parts.push(`[USER]\n${clip(message.content, 6000)}${names.length ? `\n[Attachments: ${names.join(', ')}]` : ''}`)
+    } else if (message.role === 'assistant') {
+      const lines: string[] = []
+      if (message.content.trim()) lines.push(clip(message.content.trim(), 4000))
+      for (const call of message.toolCalls) lines.push(`→ ${call.name} ${callSummary(call.args)}`)
+      if (lines.length) parts.push(`[ASSISTANT]\n${lines.join('\n')}`)
+    } else {
+      const status = message.status === 'done' ? 'ok' : message.status
+      parts.push(`[RESULT ${message.call.name} · ${status}]\n${clip(message.result ?? '', toolResultLimit(message))}`)
+    }
+  }
+  return parts
+}
+
+/** Groups transcript parts into chunks under `maxChars`; one oversized part gets its own chunk. */
+export function chunkParts(parts: string[], maxChars: number): string[] {
+  const chunks: string[] = []
+  let current: string[] = []
+  let size = 0
+  for (const part of parts) {
+    if (current.length && size + part.length > maxChars) {
+      chunks.push(current.join('\n\n---\n\n'))
+      current = []
+      size = 0
+    }
+    current.push(part)
+    size += part.length + 9
+  }
+  if (current.length) chunks.push(current.join('\n\n---\n\n'))
+  return chunks
+}
+
+/** Used when the model cannot summarise: a lossy but deterministic record of the session. */
+export function fallbackSummary(head: Message[], previous: string, files: string[]): string {
+  const asks = head
+    .filter((message): message is UserMessage => message.role === 'user')
+    .map((message) => `- ${clip(message.content.trim().replace(/\s+/g, ' '), 300)}`)
+  const lastAnswer = [...head]
+    .reverse()
+    .find((message): message is AssistantMessage => message.role === 'assistant' && Boolean(message.content.trim()))
+  const toolCount = head.filter((message) => message.role === 'tool').length
+  return [
+    previous ? `## Earlier summary\n${previous}` : '',
+    '## User requests so far',
+    asks.slice(-12).join('\n') || '- (none)',
+    lastAnswer ? `## Last assistant conclusion\n${clip(lastAnswer.content.trim(), 1500)}` : '',
+    `## Activity\n${toolCount} tool calls were made. This summary was built without the model, so details may be missing: re-read files before relying on them.`,
+    files.length ? `## Files changed\n${files.map((file) => `- ${file}`).join('\n')}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n\n')
+}
+
+/** A short, verbatim look at the newest steps, for compaction in the middle of a running turn. */
+export function recentSteps(messages: Message[], count = 4): string {
+  const steps: string[] = []
+  for (let i = messages.length - 1; i >= 0 && steps.length < count; i -= 1) {
+    const message = messages[i]
+    if (message.role !== 'tool') continue
+    steps.push(`• ${message.call.name} ${callSummary(message.call.args)} → ${message.status}\n${clip(message.result ?? '', 1200)}`)
+  }
+  return steps.reverse().join('\n\n')
+}

package/src/lib/subagent-types.ts

@@ -0,0 +1,54 @@
+import type { ToolName } from '../types'
+
+export type SubagentType = 'explore' | 'research' | 'review'
+
+export interface SubagentSpec {
+  label: string
+  /** One line for the main agent's tool description. */
+  summary: string
+  /** Built-in tools this kind of subagent may call. All are read-only in Plan mode. */
+  tools: ToolName[]
+  /** Hard cap on model rounds; the subagent is then forced to report. */
+  maxRounds: number
+  guidance: string[]
+}
+
+export const SUBAGENT_TYPES: Record<SubagentType, SubagentSpec> = {
+  explore: {
+    label: 'Explore',
+    summary: 'fast, local: find where something lives, trace a flow or a bug through the codebase',
+    tools: ['read_file', 'list_files', 'grep', 'shell', 'git', 'skill'],
+    maxRounds: 24,
+    guidance: [
+      'Search wide first (grep, list_files), then read only the files that matter.',
+      'Run independent searches in the same round instead of one after another.',
+      'Report exact paths with line numbers and a short quote or code reference for each claim.',
+    ],
+  },
+  research: {
+    label: 'Research',
+    summary: 'look things up on the web (docs, release notes, errors) and cross-check with the local code',
+    tools: ['read_file', 'list_files', 'grep', 'web_search', 'read_url', 'skill'],
+    maxRounds: 18,
+    guidance: [
+      'Prefer primary sources (official docs, changelogs, source repositories). Open the pages you cite.',
+      'Cross-check important claims with a second source or with the local code.',
+      'Report each finding with its URL, and say plainly what you could not confirm.',
+    ],
+  },
+  review: {
+    label: 'Review',
+    summary: 'critically review code or a diff for bugs, regressions, missing tests and risky changes',
+    tools: ['read_file', 'list_files', 'grep', 'shell', 'git', 'skill'],
+    maxRounds: 30,
+    guidance: [
+      'Start from `git status` and `git diff` when the task is about recent changes; otherwise read the named files.',
+      'Check call sites and edge cases, not just the changed lines. Verify a suspected bug by reading the code it touches.',
+      'Report findings ordered by severity, each with file:line, why it is a problem and a concrete fix. Say "no issues found" if that is the truth.',
+    ],
+  },
+}
+
+export function subagentType(value: unknown): SubagentType {
+  return value === 'research' || value === 'review' ? value : 'explore'
+}

package/src/lib/tool-meta.ts

@@ -0,0 +1,40 @@
+import type { BuiltinToolName, ToolName } from '../types'
+
+export function toolLabel(name: ToolName): string {
+  if (name.startsWith('mcp__')) return name.split('__').slice(2).join(' ').replace(/_/g, ' ') || 'MCP tool'
+  const labels: Record<BuiltinToolName, string> = {
+    shell: 'Shell',
+    read_file: 'Read file',
+    list_files: 'List files',
+    write_file: 'Write file',
+    edit_file: 'Edit file',
+    rewrite_file: 'Rewrite file',
+    grep: 'Grep',
+    web_search: 'Web search',
+    read_url: 'Read URL',
+    git: 'Git',
+    subagent: 'Subagent',
+    skill: 'Skill',
+  }
+  return labels[name as BuiltinToolName] ?? 'Tool'
+}
+
+export function toolSummary(name: ToolName, args: Record<string, unknown>): string {
+  const value =
+    name === 'shell'
+      ? args.command
+      : name === 'grep'
+        ? args.pattern
+        : name === 'web_search'
+          ? args.query
+          : name === 'read_url'
+            ? args.url
+            : name === 'git'
+              ? args.action
+              : name === 'subagent'
+                ? args.task
+                : name === 'skill'
+                  ? [args.name, args.file].filter(Boolean).join(' / ')
+                : (args.path ?? '')
+  return typeof value === 'string' ? value : ''
+}

package/src/store/settings.ts

@@ -79,6 +79,7 @@ const DEFAULTS: AppSettings = {
   workDetail: 'detailed',
   autoCollapseWork: true,
   aiSessionTitles: true,
+  showMascot: false,
 }
 
 const EFFORTS = new Set<Effort>(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
@@ -187,6 +188,7 @@ function buildSettings(persisted?: Partial<AppSettings>): AppSettings {
     workDetail: saved.workDetail === 'concise' ? 'concise' : 'detailed',
     autoCollapseWork: saved.autoCollapseWork !== false,
     aiSessionTitles: saved.aiSessionTitles !== false,
+    showMascot: saved.showMascot === true,
     workspacePrompts: sanitizeWorkspacePrompts(saved.workspacePrompts),
   }
 }
@@ -216,6 +218,7 @@ function persistedPatch(patch: Partial<AppSettings>): Partial<AppSettings> {
     'workDetail',
     'autoCollapseWork',
     'aiSessionTitles',
+    'showMascot',
     'workspacePrompts',
   ]
   for (const key of keys) {

package/src/store/ui.ts

@@ -6,9 +6,21 @@ interface RuntimeState {
   /** Sessions whose title the AI is writing right now. */
   titling: Record<string, boolean>
   setTitling: (sessionId: string, active: boolean) => void
+  /** Sessions being compacted right now. */
+  compacting: Record<string, boolean>
+  setCompacting: (sessionId: string, active: boolean) => void
 }
 
 export const useRuntime = create<RuntimeState>()((set) => ({
+  compacting: {},
+  setCompacting: (sessionId, active) =>
+    set((state) => {
+      if (Boolean(state.compacting[sessionId]) === active) return state
+      const compacting = { ...state.compacting }
+      if (active) compacting[sessionId] = true
+      else delete compacting[sessionId]
+      return { compacting }
+    }),
   titling: {},
   setTitling: (sessionId, active) =>
     set((state) => {

package/src/types.ts

@@ -150,6 +150,8 @@ export interface AppSettings {
   autoCollapseWork: boolean
   /** Let the model name a session after its first answer. */
   aiSessionTitles: boolean
+  /** Show the pixel mascot on the home screen and above the composer. */
+  showMascot: boolean
 }
 
 export interface Attachment {
@@ -203,6 +205,20 @@ export interface AssistantMessage {
   createdAt: number
   /** Tool calls in this round already have follow-up tool messages. */
   round: number
+  /** Set on the summary message written by compaction; `content` is the summary. */
+  compaction?: CompactionMeta
+}
+
+export interface CompactionMeta {
+  /** Files written or edited before this point, tracked from tool calls (not model-written). */
+  files: string[]
+  /** User turns and tool calls folded into the summary. */
+  turns: number
+  toolCalls: number
+  at: number
+  trigger: 'auto' | 'manual' | 'mid-turn'
+  /** The model was unavailable, so the summary was built without it. */
+  fallback?: boolean
 }
 
 /** Line-level change report for a file edit: +added, −removed and where it started (1-based). */
@@ -358,6 +374,11 @@ export interface DaemonInfo {
   dataDir: string
   home: string
   platform: string
+  /** process.platform of the daemon: win32, darwin or linux. */
+  os?: string
+  arch?: string
+  /** Shell the agent's commands run in, e.g. "zsh on macOS (arm64)". */
+  shell?: string
   node: string
 }
 
@@ -412,6 +433,11 @@ export interface DaemonSnapshot {
   dataDir: string
   home: string
   platform: string
+  /** process.platform of the daemon: win32, darwin or linux. */
+  os?: string
+  arch?: string
+  /** Shell the agent's commands run in, e.g. "zsh on macOS (arm64)". */
+  shell?: string
   node: string
   settings: Partial<AppSettings>
   chats: { sessions: ChatSession[]; activeId: string | null }

package/shared/plugin-builder.test.mjs

@@ -1,43 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { buildPluginArchive, readPluginArchive, validatePluginManifest } from './plugin-package.mjs'
-
-const manifest = {
-  id: 'demo-plugin',
-  name: 'Demo plugin',
-  version: '1.0.0',
-  apiVersion: 1,
-  entry: 'main.js',
-  stylesheet: 'main.css',
-  capabilities: ['ui.commands'],
-  domains: [],
-}
-
-test('a built package reopens with its sources and assets intact', () => {
-  const archive = buildPluginArchive({
-    manifest,
-    files: { 'main.js': 'maxcode.log("hi")', 'main.css': '.a{}', 'assets/icon.txt': 'icon' },
-  })
-  const reopened = readPluginArchive(archive)
-  assert.equal(reopened.manifest.id, 'demo-plugin')
-  assert.equal(reopened.files['main.js'], 'maxcode.log("hi")')
-  assert.equal(reopened.files['main.css'], '.a{}')
-  assert.equal(reopened.files['assets/icon.txt'], 'icon')
-})
-
-test('a manifest may omit domains entirely — a plugin with no network declares none', () => {
-  const { domains, ...withoutDomains } = manifest
-  assert.deepEqual(validatePluginManifest(withoutDomains).domains, [])
-  assert.deepEqual(readPluginArchive(buildPluginArchive({
-    manifest: withoutDomains,
-    files: { 'main.js': 'maxcode.log("hi")', 'main.css': '' },
-  })).manifest.domains, [])
-  assert.throws(() => validatePluginManifest({ ...manifest, domains: 'api.example.com' }), /domains must be an array/)
-})
-
-test('the builder rejects an invalid manifest before packaging', () => {
-  assert.throws(() => validatePluginManifest({ ...manifest, id: 'Bad Id' }), /Invalid plugin package/)
-  assert.throws(() => validatePluginManifest({ ...manifest, entry: 'main.ts' }), /entry must be JavaScript/)
-  assert.throws(() => validatePluginManifest({ ...manifest, capabilities: ['shell.exec'] }), /capabilit/i)
-  assert.throws(() => validatePluginManifest({ ...manifest, domains: ['https://api.example.com'] }), /domain/i)
-})

package/shared/plugin-package.d.mts

@@ -1,34 +0,0 @@
-export type PluginCapability =
-  | 'workspace.list'
-  | 'workspace.read'
-  | 'workspace.write'
-  | 'workspace.edit'
-  | 'ui.commands'
-  | 'ui.panels'
-  | 'ui.themes'
-  | 'network.request'
-
-export interface PluginManifest {
-  id: string
-  name: string
-  version: string
-  apiVersion: 1 | 2
-  entry: string
-  stylesheet: string
-  capabilities: PluginCapability[]
-  domains: string[]
-}
-
-export interface PluginPackageSources {
-  manifest: PluginManifest
-  files: Record<string, string | Uint8Array>
-}
-
-export interface PluginPackage {
-  manifest: PluginManifest
-  files: Record<string, string>
-}
-
-export function validatePluginManifest(value: unknown): PluginManifest
-export function buildPluginArchive(sources: PluginPackageSources): Uint8Array
-export function readPluginArchive(bytes: Uint8Array): PluginPackage