@bibobonking/opensol 0.0.0-stage → 3.0.1

package/src/agent/compact.ts

@@ -0,0 +1,234 @@
+/**
+ * Smart session compaction.
+ *
+ * When the context window is getting full, this module asks the AI to produce
+ * a detailed summary of everything that has happened so far — tools called,
+ * files changed, decisions made, open tasks — and replaces the old messages
+ * with that summary plus a compact system note. The summary is intentionally
+ * thorough so the AI does not lose track of ongoing work.
+ *
+ * The compacted session contains:
+ *   1. A synthetic user message: the original FIRST user message (task framing)
+ *   2. A synthetic assistant message: the AI-generated summary
+ *   3. A synthetic user message: a brief handoff note telling the AI to continue
+ *
+ * This keeps the conversation coherent from the provider's perspective while
+ * drastically reducing token consumption.
+ */
+
+import type { AssistantMessage, Message, UserMessage } from '../types'
+import { useChats, createId } from '../store/chats'
+import { useSettings, activeModelId } from '../store/settings'
+import { findModel } from '../store/models'
+import { streamModel } from './model'
+import { EMPTY_HANDLERS } from './adapters/shared'
+
+const COMPACT_SYSTEM = `You are a session compactor. Your ONLY job is to produce a detailed, structured summary of the conversation you are given. This summary will replace the original messages so the AI agent can continue the task without losing important context.
+
+The summary MUST include, in clear sections:
+
+## Task & Goal
+What the user originally asked for. The full scope, requirements, and any constraints they stated.
+
+## Work Completed So Far
+Every meaningful action taken: files read, files created or modified (list each file path and what changed), commands run (and their output), API calls made, decisions reached, bugs found and fixed.
+
+## Current State
+What is the exact state of the workspace right now? Which files are in what state? What has been verified to work? What is broken or incomplete?
+
+## Open Tasks & Next Steps
+What remains to be done? List concrete next actions with enough detail that the agent can pick up exactly where things left off.
+
+## Key Facts & Decisions
+Important technical facts discovered during the session: library versions, APIs used, architectural decisions made, pitfalls encountered.
+
+## Files Modified or Created
+An exhaustive list of every file path that was touched and a one-line description of what was done.
+
+Be exhaustive and precise. Do not summarize tool output vaguely — include actual file paths, function names, error messages, command outputs. The agent continuing the work must be able to act on this summary without access to the original messages.`
+
+/** True while a compact is in progress for a given session id. */
+const compacting = new Set<string>()
+
+export function isCompacting(sessionId: string): boolean {
+  return compacting.has(sessionId)
+}
+
+/**
+ * Runs the compaction for `sessionId`.
+ *
+ * Returns true if compaction succeeded, false if it was skipped or failed.
+ * Never throws — errors are surfaced via the maxcode:notice event.
+ */
+export async function compactSession(sessionId: string): Promise<boolean> {
+  if (compacting.has(sessionId)) return false
+  compacting.add(sessionId)
+
+  try {
+    const session = useChats.getState().sessions.find((s) => s.id === sessionId)
+    if (!session || session.messages.length < 4) return false
+
+    const settings = useSettings.getState()
+    const modelId = activeModelId(settings)
+    if (!modelId) return false
+
+    const model = findModel(settings.provider, modelId)
+
+    // Build a full conversation transcript for the summariser.
+    // We include assistant text and tool results so the summariser has the
+    // complete picture of what happened.
+    const transcript = buildTranscript(session.messages)
+
+    // The summariser request is sent as a plain user message so we don't have
+    // to worry about tool call parsing or streaming UI updates.
+    const summaryHistory: Message[] = [
+      {
+        id: createId('msg'),
+        role: 'user',
+        content: `Below is a complete transcript of a coding session. Produce the detailed summary as instructed.\n\n${transcript}`,
+        createdAt: Date.now(),
+      },
+    ]
+
+    let summaryContent = ''
+
+    try {
+      const result = await streamModel({
+        settings,
+        model,
+        history: summaryHistory,
+        system: COMPACT_SYSTEM,
+        mode: 'build',
+        signal: new AbortController().signal,
+        handlers: {
+          ...EMPTY_HANDLERS,
+          onText: (delta) => {
+            summaryContent += delta
+          },
+        },
+      })
+      if (result.content.trim()) summaryContent = result.content
+    } catch (error) {
+      window.dispatchEvent(
+        new CustomEvent('maxcode:notice', {
+          detail: {
+            message: `Auto-compact failed: ${error instanceof Error ? error.message : 'Unknown error'}. Continuing with full context.`,
+            tone: 'error',
+          },
+        }),
+      )
+      return false
+    }
+
+    if (!summaryContent.trim()) return false
+
+    // Find the first user message to preserve the original task framing.
+    const firstUser = session.messages.find((m): m is UserMessage => m.role === 'user')
+    const now = Date.now()
+
+    // Build the replacement message set.
+    const compactedMessages: Message[] = []
+
+    // 1. Original task (first user message, preserved exactly).
+    if (firstUser) {
+      compactedMessages.push({ ...firstUser })
+    }
+
+    // 2. AI-generated summary of all the work done.
+    const summaryMessage: AssistantMessage = {
+      id: createId('msg'),
+      role: 'assistant',
+      content: summaryContent.trim(),
+      reasoning: '',
+      toolCalls: [],
+      round: 0,
+      model: modelId,
+      provider: settings.provider,
+      createdAt: now,
+      durationMs: 0,
+    }
+    compactedMessages.push(summaryMessage)
+
+    // 3. Handoff note telling the AI to resume work.
+    const handoffNote = buildHandoffNote(session.messages)
+    const handoffMessage: UserMessage = {
+      id: createId('msg'),
+      role: 'user',
+      content: handoffNote,
+      createdAt: now,
+    }
+    compactedMessages.push(handoffMessage)
+
+    // Atomically replace the session's messages with the compacted set.
+    useChats.getState().updateSession(sessionId, {
+      messages: compactedMessages,
+    })
+
+    window.dispatchEvent(
+      new CustomEvent('maxcode:notice', {
+        detail: {
+          message: '✦ Context compacted — session summary saved, continuing with fresh context.',
+          tone: 'success',
+        },
+      }),
+    )
+
+    return true
+  } finally {
+    compacting.delete(sessionId)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function buildTranscript(messages: Message[]): string {
+  const parts: string[] = []
+  for (const message of messages) {
+    if (message.role === 'user') {
+      const attachmentNote =
+        message.attachments && message.attachments.length > 0
+          ? `\n[Attachments: ${message.attachments.map((a) => a.name).join(', ')}]`
+          : ''
+      parts.push(`[USER]\n${message.content}${attachmentNote}`)
+    } else if (message.role === 'assistant') {
+      const lines: string[] = []
+      if (message.reasoning.trim()) lines.push(`<thinking>\n${message.reasoning.trim()}\n</thinking>`)
+      if (message.content.trim()) lines.push(message.content.trim())
+      for (const call of message.toolCalls) {
+        lines.push(`<tool_call name="${call.name}">\n${JSON.stringify(call.args, null, 2)}\n</tool_call>`)
+      }
+      if (lines.length > 0) parts.push(`[ASSISTANT]\n${lines.join('\n\n')}`)
+    } else if (message.role === 'tool') {
+      const status = message.status === 'done' ? 'OK' : message.status.toUpperCase()
+      const result = (message.result ?? '').slice(0, 8_000)
+      const truncated = (message.result ?? '').length > 8_000 ? '\n… (truncated)' : ''
+      parts.push(`[TOOL: ${message.call.name} — ${status}]\n${result}${truncated}`)
+    }
+  }
+  return parts.join('\n\n---\n\n')
+}
+
+function buildHandoffNote(messages: Message[]): string {
+  // Find the last user message to understand what was most recently requested.
+  const reversed = [...messages].reverse()
+  const lastUser = reversed.find((m): m is UserMessage => m.role === 'user')
+  const lastUserContent = lastUser?.content?.trim() ?? ''
+
+  // Count completed tool calls for context.
+  const toolCalls = messages.filter((m) => m.role === 'tool').length
+  const userTurns = messages.filter((m) => m.role === 'user').length
+
+  return [
+    `[CONTEXT COMPACTED — ${userTurns} user turns, ${toolCalls} tool calls summarised above]`,
+    '',
+    'The summary above contains the full record of work done so far. Please:',
+    '1. Read the summary carefully before acting — it contains critical state information.',
+    '2. Continue exactly where you left off.',
+    '3. Do not repeat work already marked as completed in the summary.',
+    lastUserContent ? `\nThe most recent task/request was:\n${lastUserContent}` : '',
+  ]
+    .filter((line) => line !== undefined)
+    .join('\n')
+}

package/src/agent/index.ts

@@ -0,0 +1,36 @@
+import { kernel } from '../core/kernel'
+
+export function stopRun(sessionId: string): void {
+  if (kernel.agentLoop) {
+    kernel.agentLoop.stopRun(sessionId)
+  } else {
+    queueMicrotask(() => kernel.agentLoop?.stopRun(sessionId))
+  }
+}
+
+export function stopAllRuns(): void {
+  if (kernel.agentLoop) {
+    kernel.agentLoop.stopAllRuns()
+  } else {
+    queueMicrotask(() => kernel.agentLoop?.stopAllRuns())
+  }
+}
+
+/**
+ * Queue one agent run for the submitted user message. A prompt sent while a turn
+ * is streaming waits its turn instead of starting a second overlapping reply.
+ */
+export function runAgent(sessionId: string, userMessageId?: string): void {
+  if (kernel.agentLoop) {
+    kernel.agentLoop.runAgent(sessionId, userMessageId)
+  } else {
+    queueMicrotask(() => kernel.agentLoop?.runAgent(sessionId, userMessageId))
+  }
+}
+
+export function regenerateLastTurn(sessionId: string): boolean {
+  if (kernel.agentLoop) {
+    return kernel.agentLoop.regenerateLastTurn(sessionId)
+  }
+  return false
+}

package/src/agent/model.ts

@@ -0,0 +1,20 @@
+import type { AdapterRequest, AdapterResult } from './adapters/shared'
+import { streamAnthropic } from './adapters/anthropic'
+import { streamGemini } from './adapters/gemini'
+import { streamOpenAI } from './adapters/openai'
+import { streamOpenAIResponses } from './adapters/openai-responses'
+import { apiKindFor } from '../store/models'
+
+export function streamModel(request: AdapterRequest): Promise<AdapterResult> {
+  const kind = apiKindFor(request.settings.provider, request.settings.model, request.model)
+  switch (kind) {
+    case 'anthropic':
+      return streamAnthropic(request)
+    case 'gemini':
+      return streamGemini(request)
+    case 'openai-responses':
+      return streamOpenAIResponses(request)
+    default:
+      return streamOpenAI(request)
+  }
+}

package/src/agent/prompt.ts

@@ -0,0 +1,107 @@
+import type { AgentMode, AppSettings } from '../types'
+import { activeModelId } from '../store/settings'
+import { useWorkspace } from '../store/workspace'
+import { kernel } from '../core/kernel'
+
+function workspaceContext(): string {
+  const state = useWorkspace.getState()
+  const root = state.root || state.info.root
+  if (!root) {
+    return 'No folder is open yet. Ask the user to choose a workspace folder in the Workspace panel before using file, shell or git tools.'
+  }
+  const topLevel = state.entries
+    .filter((entry) => !entry.path.includes('/'))
+    .slice(0, 40)
+    .map((entry) => `${entry.path}${entry.type === 'dir' ? '/' : ''}`)
+  const git = state.git.available
+    ? `${state.git.branch || 'detached HEAD'} · ${state.git.entries.length} changed file${state.git.entries.length === 1 ? '' : 's'}`
+    : 'not a git repository'
+  return [
+    `Root: ${root}`,
+    `Git: ${git}`,
+    topLevel.length > 0 ? `Top level: ${topLevel.join(', ')}` : 'The folder is empty.',
+    state.truncated ? 'The file tree was truncated; use list_files or grep for deeper paths.' : '',
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+export function buildSystemPrompt(settings: AppSettings, mode: AgentMode = settings.mode): string {
+  if (kernel.systemPrompt) {
+    return kernel.systemPrompt.assemble(settings, mode)
+  }
+  const chunks: string[] = [settings.systemPrompt.trim()]
+
+  const skills = settings.skills.filter((skill) => skill.enabled)
+  if (skills.length > 0) {
+    chunks.push(
+      [
+        '## Loaded skills',
+        'Apply these skills when the task matches their purpose. They refine the working rules above; they never override safety, tool permissions or plan mode.',
+        ...skills.map(
+          (skill) =>
+            `<skill name="${skill.name}">\nPurpose: ${skill.description}\n${skill.instructions.trim()}\n</skill>`,
+        ),
+      ].join('\n\n'),
+    )
+  }
+
+  chunks.push(
+    [
+      '## Workspace',
+      'You operate on the real folder below through the local OpenSol daemon. Tools return real output; never invent file contents, command results, URLs or deployments.',
+      workspaceContext(),
+    ].join('\n\n'),
+  )
+
+  chunks.push(
+    mode === 'plan'
+      ? [
+          '## Mode: Plan (read-only)',
+          'Investigate and design. Do not modify anything.',
+          '- Allowed: read_file, list_files, grep, web_search, read_url, read-only shell commands and read-only git actions.',
+          '- Forbidden: write_file, edit_file, rewrite_file, git add/commit/init/checkout, and shell commands that change files, install packages or change system state. The daemon rejects these.',
+          '- Read the relevant source before proposing changes. Grep for call sites and inspect the real files.',
+          '- Finish with a concrete, ordered implementation plan naming files and functions. State assumptions and open questions plainly.',
+          '- Never pretend an edit was made or a check was run.',
+        ].join('\n')
+      : [
+          '## Mode: Build',
+          'You may inspect and change the real workspace.',
+          '- Inspect before editing: list files, read the source, grep for call sites, check git status.',
+          '- Make the smallest coherent change. Do not reformat unrelated code, add speculative abstractions or invent APIs.',
+          '- After a mutation, inspect the result. Run the project’s real typecheck, lint, tests and build when they exist, and read the output.',
+          '- Never claim a check passed without running it. If a check cannot run, say why.',
+          '- Ask before destructive actions, force pushes, credential changes or anything that leaves the workspace.',
+        ].join('\n'),
+  )
+
+  chunks.push(
+    [
+      '## Session context',
+      `- Model: ${activeModelId(settings) || 'unset'}`,
+      `- Date: ${new Date().toISOString().slice(0, 10)}`,
+      `- Mode: ${mode}`,
+      settings.webSearchEnabled
+        ? '- Web search is enabled. Use it when facts may be current or when the user asks for sources.'
+        : '- Web search is turned off for this session.',
+      '- Use relative paths from the workspace root. Do not use /workspace paths.',
+    ].join('\n'),
+  )
+
+  return chunks.filter(Boolean).join('\n\n')
+}
+
+export function buildSubagentPrompt(settings: AppSettings): string {
+  return [
+    buildSystemPrompt(settings, 'plan'),
+    [
+      '## Subagent',
+      'You are a focused read-only investigator. Work only on the assigned task.',
+      '- Inspect the real workspace with read-only file, grep, shell and web tools.',
+      '- Do not edit files, change git state or run commands that mutate the machine. The daemon enforces this.',
+      '- Be concise: return findings, exact file paths and line references, and any uncertainty.',
+      '- Do not repeat the task back. Do not invent evidence. If something cannot be verified, say so.',
+    ].join('\n'),
+  ].join('\n\n')
+}

package/src/agent/queue.test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { createTurnQueue, historyUpTo, lastUserMessageId, turnHistory } from './queue.ts'
+
+const u = (id) => ({ id, role: 'user', content: 'hi', createdAt: 0 })
+const a = (id) => ({ id, role: 'assistant', content: '', reasoning: '', toolCalls: [], round: 0, createdAt: 0 })
+const t = (id) => ({ id, role: 'tool', call: { id: `${id}-c`, name: 'read_file', args: {} }, status: 'done', round: 0, createdAt: 0 })
+
+test('an answer cannot see a later user prompt', () => {
+  const messages = [u('u1'), u('u2')]
+  assert.deepEqual(historyUpTo(messages, 'u1')?.map((m) => m.id), ['u1'])
+  assert.equal(historyUpTo(messages, 'gone'), null)
+  assert.equal(lastUserMessageId(messages), 'u2')
+})
+
+test('turn history stops at the next user message but keeps later rounds', () => {
+  const messages = [u('u1'), a('a1'), t('t1'), a('a2'), u('u2')]
+  assert.deepEqual(turnHistory(messages, 'u1')?.map((m) => m.id), ['u1', 'a1', 't1', 'a2'])
+  assert.deepEqual(turnHistory(messages, 'u2')?.map((m) => m.id), ['u1', 'a1', 't1', 'a2', 'u2'])
+  assert.equal(turnHistory(messages, 'gone'), null)
+})
+
+test('queued turns run in submission order, never concurrently', async () => {
+  const events = []
+  let active = 0
+  let peak = 0
+  const queue = createTurnQueue(async (_sessionId, id) => {
+    active += 1
+    peak = Math.max(peak, active)
+    events.push(`start:${id}`)
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    events.push(`end:${id}`)
+    active -= 1
+  })
+
+  const first = queue.push('s', 'u1')
+  const second = queue.push('s', 'u2')
+  assert.equal(queue.isBusy('s'), true)
+  await Promise.all([first, second])
+
+  assert.deepEqual(events, ['start:u1', 'end:u1', 'start:u2', 'end:u2'])
+  assert.equal(peak, 1)
+  assert.equal(queue.isIdle(), true)
+  assert.equal(queue.isBusy('s'), false)
+})
+
+test('separate sessions run independently and a failed turn still drains the queue', async () => {
+  const done = []
+  const queue = createTurnQueue(async (sessionId, id) => {
+    if (id === 'bad') throw new Error('provider failed')
+    done.push(`${sessionId}:${id}`)
+  })
+
+  await Promise.all([queue.push('a', 'bad'), queue.push('a', 'ok'), queue.push('b', 'ok')])
+  assert.deepEqual(done.sort(), ['a:ok', 'b:ok'])
+  assert.equal(queue.isIdle(), true)
+})
+
+test('stop settles the turn so the next queued prompt still runs', async () => {
+  const ran = []
+  const queue = createTurnQueue(async (_sessionId, id) => {
+    if (id === 'stop') return
+    ran.push(id)
+  })
+  await queue.push('s', 'stop')
+  await queue.push('s', 'after')
+  assert.deepEqual(ran, ['after'])
+})
+
+test('clear drops waiting turns but not the running one', async () => {
+  const ran = []
+  let release
+  const gate = new Promise((resolve) => {
+    release = resolve
+  })
+  const queue = createTurnQueue(async (_sessionId, id) => {
+    ran.push(id)
+    if (id === 'first') await gate
+  })
+
+  const running = queue.push('s', 'first')
+  await new Promise((resolve) => setTimeout(resolve, 0))
+  const waiting = queue.push('s', 'second')
+  queue.clear('s')
+  release()
+  await Promise.all([running, waiting])
+
+  assert.deepEqual(ran, ['first'])
+  assert.equal(queue.isIdle(), true)
+})
+
+test('clearAll drops queued turns in every session but lets the running one finish', async () => {
+  const ran = []
+  let release
+  const gate = new Promise((resolve) => {
+    release = resolve
+  })
+  const queue = createTurnQueue(async (sessionId, id) => {
+    ran.push(`${sessionId}:${id}`)
+    if (id === 'a1' || id === 'b1') await gate
+  })
+  const running = queue.push('a', 'a1')
+  const queuedA = queue.push('a', 'a2')
+  const runningB = queue.push('b', 'b1')
+  const queuedB = queue.push('b', 'b2')
+  await Promise.resolve()
+  queue.clearAll()
+  release()
+  await Promise.all([running, runningB, queuedA, queuedB])
+  assert.deepEqual(ran.sort(), ['a:a1', 'b:b1'])
+})

package/src/agent/queue.ts

@@ -0,0 +1,84 @@
+import type { Message, UserMessage } from '../types'
+
+/** Provider history for one turn: everything through its submitted user message. */
+export function historyUpTo(messages: Message[], userMessageId: string): Message[] | null {
+  const end = messages.findIndex((message) => message.id === userMessageId)
+  if (end === -1) return null
+  return messages.slice(0, end + 1)
+}
+
+/**
+ * History for a turn mid-run. A prompt submitted while this turn is streaming is
+ * already in the store, so the slice stops before the next user message.
+ */
+export function turnHistory(messages: Message[], userMessageId: string): Message[] | null {
+  const start = messages.findIndex((message) => message.id === userMessageId)
+  if (start === -1) return null
+  for (let index = start + 1; index < messages.length; index += 1) {
+    if (messages[index].role === 'user') return messages.slice(0, index)
+  }
+  return messages.slice()
+}
+
+export function lastUserMessageId(messages: Message[]): string | null {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message.role === 'user') return (message as UserMessage).id
+  }
+  return null
+}
+
+export interface TurnQueue {
+  /** Runs after every turn already queued for this session. */
+  push(sessionId: string, userMessageId: string): Promise<void>
+  /** Drops turns that have not started yet; the running one keeps its abort signal. */
+  clear(sessionId: string): void
+  /** Drops every turn that has not started yet, in every session. */
+  clearAll(): void
+  isBusy(sessionId: string): boolean
+  isIdle(): boolean
+}
+
+interface Lane {
+  chain: Promise<void>
+  /** Bumped by clear(); a queued run whose token is stale never starts. */
+  token: object
+}
+
+/**
+ * One run per session at a time, in submission order. A prompt sent mid-turn is
+ * queued instead of dropped, and each run only sees history up to its own turn.
+ */
+export function createTurnQueue(run: (sessionId: string, userMessageId: string) => Promise<void>): TurnQueue {
+  const lanes = new Map<string, Lane>()
+
+  return {
+    isBusy: (sessionId) => lanes.has(sessionId),
+    isIdle: () => lanes.size === 0,
+    clear(sessionId) {
+      const lane = lanes.get(sessionId)
+      if (!lane) return
+      lanes.set(sessionId, { chain: lane.chain, token: {} })
+    },
+    clearAll() {
+      for (const [sessionId, lane] of lanes) lanes.set(sessionId, { chain: lane.chain, token: {} })
+    },
+    push(sessionId, userMessageId) {
+      const lane = lanes.get(sessionId) ?? { chain: Promise.resolve(), token: {} }
+      const token = lane.token
+      const next = lane.chain.then(
+        () => (lanes.get(sessionId)?.token === token ? run(sessionId, userMessageId) : undefined),
+        () => (lanes.get(sessionId)?.token === token ? run(sessionId, userMessageId) : undefined),
+      )
+      const done = next.then(
+        () => undefined,
+        () => undefined,
+      )
+      lanes.set(sessionId, { chain: done, token })
+      void done.then(() => {
+        if (lanes.get(sessionId)?.chain === done) lanes.delete(sessionId)
+      })
+      return done
+    },
+  }
+}