@bibobonking/opensol 0.0.0-stage → 3.0.2

package/src/lib/boot.ts

@@ -0,0 +1,94 @@
+import { create } from 'zustand'
+import type { DaemonSnapshot } from '../types'
+import { ensureSession, getState, migrateLegacy } from './daemon'
+import { enableChatPersistence, useChats } from '../store/chats'
+import { enableSettingsPersistence, useSettings } from '../store/settings'
+import { useWorkspace } from '../store/workspace'
+
+const LEGACY_KEYS = {
+  settings: 'maxcode-settings-v1',
+  chats: 'maxcode-chats-v1',
+  workspace: 'maxcode-workspace-v1',
+} as const
+
+type BootPhase = 'idle' | 'loading' | 'ready' | 'error'
+
+interface BootState {
+  phase: BootPhase
+  error: string
+  startedAt: number
+  boot: (force?: boolean) => Promise<void>
+}
+
+export const useBoot = create<BootState>()((set, get) => ({
+  phase: 'idle',
+  error: '',
+  startedAt: 0,
+  boot: async (force = false) => {
+    if (get().phase === 'loading') return
+    if (get().phase === 'ready' && !force) return
+    set({ phase: 'loading', error: '', startedAt: Date.now() })
+    try {
+      await ensureSession()
+      let snapshot = await getState()
+      const legacy = readLegacy()
+      if (legacy.found) {
+        if (!snapshot.migration?.migratedAt) {
+          const result = await migrateLegacy({ settings: legacy.settings, chats: legacy.chats })
+          snapshot = result.state
+        }
+        clearLegacy()
+      }
+      await applySnapshot(snapshot)
+      enableSettingsPersistence()
+      enableChatPersistence()
+      set({ phase: 'ready', error: '' })
+    } catch (error) {
+      set({
+        phase: 'error',
+        error:
+          error instanceof Error
+            ? error.message
+            : 'OpenSol could not reach its local daemon.',
+      })
+    }
+  },
+}))
+
+export async function applySnapshot(snapshot: DaemonSnapshot): Promise<void> {
+  useSettings.getState().hydrate(snapshot)
+  useChats.getState().hydrate(snapshot.chats)
+  await useWorkspace.getState().hydrate(snapshot.workspace)
+}
+
+function parseLegacy(value: string | null): unknown {
+  if (!value) return undefined
+  try {
+    return JSON.parse(value) as unknown
+  } catch {
+    return undefined
+  }
+}
+
+function readLegacy() {
+  if (typeof window === 'undefined') return { found: false, settings: undefined, chats: undefined }
+  let settings: unknown
+  let chats: unknown
+  let found = false
+  try {
+    settings = parseLegacy(window.localStorage.getItem(LEGACY_KEYS.settings))
+    chats = parseLegacy(window.localStorage.getItem(LEGACY_KEYS.chats))
+    found = Boolean(settings || chats || window.localStorage.getItem(LEGACY_KEYS.workspace))
+  } catch {
+    // Local storage can be unavailable; the daemon state is still usable.
+  }
+  return { found, settings, chats }
+}
+
+function clearLegacy() {
+  try {
+    for (const key of Object.values(LEGACY_KEYS)) window.localStorage.removeItem(key)
+  } catch {
+    // Nothing else to clean up.
+  }
+}

package/src/lib/context.ts

@@ -0,0 +1,75 @@
+/**
+ * Context usage utilities.
+ *
+ * Estimates the number of tokens in the current session and computes the
+ * percentage of the active model's context window consumed. Because we count
+ * characters rather than sub-word tokens, the estimate will differ from the
+ * provider's actual token count; it is intentionally conservative (we divide
+ * by 3 instead of the usual ~4 chars/token) so the auto-compact threshold is
+ * hit slightly before the model actually runs out of context.
+ */
+
+import type { Message, ModelInfo } from '../types'
+
+/** Chars-per-token ratio used for the estimate. Intentionally conservative. */
+const CHARS_PER_TOKEN = 3
+
+/**
+ * Rough token estimate for a single message. All roles are counted; tool
+ * results tend to be verbose so they get the same treatment as text.
+ */
+function estimateMessageTokens(message: Message): number {
+  if (message.role === 'user') {
+    const attachmentChars = (message.attachments ?? []).reduce((sum, a) => sum + (a.text?.length ?? 0), 0)
+    return Math.ceil((message.content.length + attachmentChars) / CHARS_PER_TOKEN) + 4
+  }
+  if (message.role === 'assistant') {
+    const toolChars = 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 + toolChars) / CHARS_PER_TOKEN) + 4
+  }
+  // tool message
+  return Math.ceil(((message.result ?? '').length) / CHARS_PER_TOKEN) + 4
+}
+
+/** Sum of estimated tokens across all messages in a session. */
+export function estimateSessionTokens(messages: Message[]): number {
+  return messages.reduce((sum, m) => sum + estimateMessageTokens(m), 0)
+}
+
+/** Context window ceiling for a given model (falls back to a safe default). */
+export function contextLimit(model: ModelInfo | null): number {
+  return model?.context ?? 128_000
+}
+
+/**
+ * Returns a value in [0, 1] representing how full the context window is.
+ * Also accounts for the system prompt overhead (estimated at ~2 000 tokens).
+ */
+export function contextUsageRatio(messages: Message[], model: ModelInfo | null): number {
+  const SYSTEM_OVERHEAD = 2_000
+  const used = estimateSessionTokens(messages) + SYSTEM_OVERHEAD
+  const limit = contextLimit(model)
+  return Math.min(used / limit, 1)
+}
+
+/** Returns { used, limit, ratio, pct } for display and decision-making. */
+export interface ContextUsage {
+  used: number
+  limit: number
+  ratio: number
+  pct: number
+}
+
+export function getContextUsage(messages: Message[], model: ModelInfo | null): ContextUsage {
+  const SYSTEM_OVERHEAD = 2_000
+  const used = estimateSessionTokens(messages) + SYSTEM_OVERHEAD
+  const limit = contextLimit(model)
+  const ratio = Math.min(used / limit, 1)
+  return { used, limit, ratio, pct: Math.round(ratio * 100) }
+}
+
+/** The fraction at which auto-compact is triggered. */
+export const AUTO_COMPACT_THRESHOLD = 0.85

package/src/lib/conversation.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { groupConversationTurns } from './conversation.ts'
+
+const user = (id) => ({ id, role: 'user', content: 'hi', createdAt: 0 })
+const assistant = (id, content, toolCalls = 0) => ({
+  id,
+  role: 'assistant',
+  content,
+  reasoning: '',
+  toolCalls: Array.from({ length: toolCalls }, (_, index) => ({ id: `${id}-c${index}`, name: 'read_file', args: {} })),
+  round: 0,
+  createdAt: 0,
+})
+const tool = (id) => ({ id, role: 'tool', call: { id: `${id}-call`, name: 'read_file', args: {} }, status: 'done', round: 0, createdAt: 0 })
+
+test('tool rounds with no answer collapse into one Used group', () => {
+  const turns = groupConversationTurns([
+    user('u1'),
+    assistant('a1', '', 1),
+    tool('t1'),
+    assistant('a2', '', 1),
+    tool('t2'),
+    assistant('a3', 'done'),
+  ])
+  assert.equal(turns.length, 1)
+  assert.deepEqual(
+    turns[0].segments.map((segment) => segment.kind),
+    ['tools', 'assistant'],
+  )
+  assert.deepEqual(
+    turns[0].segments[0].tools.map((entry) => entry.id),
+    ['t1', 't2'],
+  )
+  assert.equal(turns[0].segments[1].message.id, 'a3')
+})
+
+test('answering closes the Used group and a later tool round opens a new one', () => {
+  const turns = groupConversationTurns([
+    user('u1'),
+    assistant('a1', '', 1),
+    tool('t1'),
+    assistant('a2', 'first answer'),
+    assistant('a3', '', 1),
+    tool('t2'),
+    assistant('a4', 'second answer'),
+  ])
+  assert.deepEqual(
+    turns[0].segments.map((segment) => segment.kind),
+    ['tools', 'assistant', 'tools', 'assistant'],
+  )
+  assert.deepEqual(turns[0].segments[2].tools.map((entry) => entry.id), ['t2'])
+})
+
+test('every user message starts a new turn and an unanswered run keeps its turn', () => {
+  const turns = groupConversationTurns([user('u1'), assistant('a1', 'one'), user('u2'), assistant('a2', '', 1), tool('t1')])
+  assert.deepEqual(turns.map((turn) => turn.id), ['u1', 'u2'])
+  assert.deepEqual(turns[1].segments.map((segment) => segment.kind), ['tools'])
+})
+
+test('a truly empty answer is kept so the empty-response notice still renders', () => {
+  const turns = groupConversationTurns([user('u1'), assistant('a1', '')])
+  assert.deepEqual(turns[0].segments.map((segment) => segment.kind), ['assistant'])
+})

package/src/lib/conversation.ts

@@ -0,0 +1,59 @@
+import type { AssistantMessage, Message, ToolMessage, UserMessage } from '../types'
+
+export type TurnSegment =
+  | { kind: 'assistant'; message: AssistantMessage }
+  | { kind: 'tools'; tools: ToolMessage[] }
+
+export interface ConversationTurn {
+  id: string
+  user?: UserMessage
+  segments: TurnSegment[]
+}
+
+function hasBody(message: AssistantMessage) {
+  return Boolean(message.content.trim() || message.reasoning.trim() || message.error || message.stopped)
+}
+
+/**
+ * One turn per user message. A tool round with no answer yet stays inside a single
+ * `tools` segment, so consecutive rounds collapse into one Used group; the group
+ * closes as soon as the model answers, and the next tool round opens a new one.
+ */
+export function groupConversationTurns(messages: Message[]): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  let turn: ConversationTurn | null = null
+  let pending: ToolMessage[] = []
+
+  const flushTools = () => {
+    if (pending.length > 0) turn?.segments.push({ kind: 'tools', tools: pending })
+    pending = []
+  }
+
+  for (const message of messages) {
+    if (message.role === 'tool') {
+      if (!turn) continue
+      pending.push(message)
+      continue
+    }
+
+    if (message.role === 'user') {
+      flushTools()
+      turn = { id: message.id, user: message, segments: [] }
+      turns.push(turn)
+      continue
+    }
+
+    // A round that only called tools is represented by those tool messages.
+    if (!hasBody(message) && message.toolCalls.length > 0) continue
+
+    if (!turn) {
+      turn = { id: message.id, segments: [] }
+      turns.push(turn)
+    }
+    flushTools()
+    turn.segments.push({ kind: 'assistant', message })
+  }
+
+  flushTools()
+  return turns
+}