@shawnstack/quickforge 1.3.13 → 1.3.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.3.13",
+  "version": "1.3.14",
   "description": "AI chat application with YOLO-mode local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",

package/server/agent-manager.mjs

@@ -15,6 +15,10 @@ import {
   parseCompactArgs,
   saveCompactBackup,
 } from './conversation-compaction.mjs'
+import {
+  buildAutoCompactLoopMessages,
+  maybeAutoCompactSession,
+} from './auto-compaction.mjs'
 import {
   handleInternalCommand,
   parseInternalCommandInvocation,
@@ -294,10 +298,13 @@ function addToolTimingToEvent(session, event) {
 
 function updateSessionMessages(session, messages) {
   session.agent.state.messages = messages
-  const compacted = compactedContextMessages(messages)
-  if (compacted.length < messages.length) {
-    session.agent.state.messages = compacted
-  }
+}
+
+function resetSessionCompaction(session) {
+  session.contextCompaction = null
+  session.lastAutoCompactAt = null
+  session.lastTransformedContextMessages = null
+  session.autoCompacting = false
 }
 
 function finishManualSessionRun(session, status, errorMessage) {
@@ -464,6 +471,7 @@ async function clearSession(session) {
   }
 
   updateSessionMessages(session, [])
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.startedAt = null
   session.finishedAt = new Date().toISOString()
@@ -576,8 +584,18 @@ function compactedContextMessages(messages) {
   return index >= 0 ? messages.slice(index) : messages
 }
 
-function transformAgentContext(messages, commandPrompt) {
-  return applyActiveCommandPrompt(compactedContextMessages(messages), commandPrompt)
+async function transformSessionContext(session, messages, signal) {
+  await maybeAutoCompactSession({
+    session,
+    messages,
+    signal,
+    emitSessionEvent,
+    persistSession,
+    logger,
+  })
+  const transformedMessages = buildAutoCompactLoopMessages(session, messages)
+  session.lastTransformedContextMessages = transformedMessages
+  return applyActiveCommandPrompt(compactedContextMessages(transformedMessages), session?.activeCommandPrompt)
 }
 
 export const agentEvents = new EventEmitter()
@@ -633,6 +651,7 @@ export async function createAgent(sessionId, config = {}) {
     systemPrompt = null,
     title = 'New chat',
     createdAt = new Date().toISOString(),
+    contextCompaction = null,
   } = config
 
   // Resolve project context for tool calls
@@ -704,9 +723,9 @@ export async function createAgent(sessionId, config = {}) {
     sessionId,
     convertToLlm: serverConvertToLlm,
     onPayload: (payload) => {
-      restoreReasoningContentInPayload(payload, agent.state.messages, agent.state.model)
+      restoreReasoningContentInPayload(payload, session?.lastTransformedContextMessages || agent.state.messages, agent.state.model)
     },
-    transformContext: (messages) => transformAgentContext(messages, session?.activeCommandPrompt),
+    transformContext: (messages, signal) => transformSessionContext(session, messages, signal),
     beforeToolCall: async (context) => {
       const toolName = context.toolCall?.name
       const toolCallId = context.toolCall?.id
@@ -756,6 +775,10 @@ export async function createAgent(sessionId, config = {}) {
     titleGenerated: false,
     toolTimings: new Map(),
     getApiKey,
+    contextCompaction,
+    lastTransformedContextMessages: null,
+    autoCompacting: false,
+    lastAutoCompactAt: null,
     /** Track active SSE connections. Only one SSE stream allowed per session to prevent
      *  connection-pool exhaustion when two browser tabs load the same session. */
     sseConnected: false,
@@ -816,8 +839,8 @@ export async function createAgent(sessionId, config = {}) {
  * Persist session data to storage.
  */
 async function persistSession(session) {
-  const { sessionId, agent, scope, projectId, title, createdAt, status, startedAt, finishedAt, model, thinkingLevel, yoloMode } = session
-  const messages = compactedContextMessages(agent.state.messages)
+  const { sessionId, agent, scope, projectId, title, createdAt, status, startedAt, finishedAt, model, thinkingLevel, yoloMode, contextCompaction } = session
+  const messages = agent.state.messages
 
   if (messages.length === 0) {
     try {
@@ -847,6 +870,7 @@ async function persistSession(session) {
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
+    contextCompaction: contextCompaction || undefined,
   }
 
   // Calculate usage
@@ -894,6 +918,13 @@ async function persistSession(session) {
     taskStatus: status,
     taskStartedAt: startedAt,
     taskFinishedAt: finishedAt,
+    contextCompaction: contextCompaction ? {
+      compactedAt: contextCompaction.compactedAt,
+      compactedUpToIndex: contextCompaction.compactedUpToIndex,
+      keepRecentTurns: contextCompaction.keepRecentTurns,
+      thresholdPercent: contextCompaction.thresholdPercent,
+      usageBefore: contextCompaction.usageBefore,
+    } : undefined,
   }
 
   // Write to storage atomically (read-modify-write within queue)
@@ -947,6 +978,7 @@ export async function rollbackSessionMessages(sessionId, rollbackMessageIndex) {
 
   const nextMessages = messages.slice(0, rollbackIndex)
   updateSessionMessages(session, nextMessages)
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
@@ -971,6 +1003,7 @@ export async function replaceSessionMessages(sessionId, messages) {
     throw Object.assign(new Error('Generation is still running. Stop it or wait until it finishes before rolling back.'), { statusCode: 409 })
   }
   updateSessionMessages(session, Array.isArray(messages) ? messages : [])
+  resetSessionCompaction(session)
   session.status = 'idle'
   session.finishedAt = new Date().toISOString()
   await persistSession(session)
@@ -1160,6 +1193,7 @@ export function getSessionState(sessionId) {
     finishedAt: session.finishedAt,
     tools: session.agent.state.tools,
     messages: session.agent.state.messages,
+    contextCompaction: session.contextCompaction,
     isStreaming: session.agent.state.isStreaming,
     errorMessage: session.agent.state.errorMessage,
   }
@@ -1255,6 +1289,7 @@ export async function restoreAgent(sessionId) {
       messages: sessionData.messages || [],
       title: sessionData.title || 'New chat',
       createdAt: sessionData.createdAt,
+      contextCompaction: sessionData.contextCompaction || null,
     })
   } catch (err) {
     logger.error(`Failed to restore agent ${sessionId}:`, err, { sessionId })

package/server/auto-compaction.mjs

@@ -0,0 +1,229 @@
+import { readStore } from './storage.mjs'
+import { compactConversation, saveCompactBackup } from './conversation-compaction.mjs'
+
+export const AUTO_COMPACT_SETTINGS_KEY = 'auto-compact-settings'
+
+export const DEFAULT_AUTO_COMPACT_SETTINGS = {
+  enabled: false,
+  thresholdPercent: 80,
+  keepRecentTurns: 2,
+  minSourceChars: 1600,
+}
+
+const AUTO_COMPACT_MIN_INTERVAL_MS = 30_000
+
+function clampNumber(value, fallback, min, max) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(max, Math.max(min, Math.round(parsed)))
+}
+
+export function normalizeAutoCompactSettings(value) {
+  if (!value || typeof value !== 'object') return { ...DEFAULT_AUTO_COMPACT_SETTINGS }
+  return {
+    enabled: value.enabled === true,
+    thresholdPercent: clampNumber(value.thresholdPercent, DEFAULT_AUTO_COMPACT_SETTINGS.thresholdPercent, 50, 95),
+    keepRecentTurns: clampNumber(value.keepRecentTurns, DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns, 1, 20),
+    minSourceChars: clampNumber(value.minSourceChars, DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars, 0, 200000),
+  }
+}
+
+export async function readAutoCompactSettings() {
+  const settings = await readStore('settings')
+  return normalizeAutoCompactSettings(settings?.[AUTO_COMPACT_SETTINGS_KEY])
+}
+
+function safeJson(value) {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return ''
+  }
+}
+
+function estimateTextTokens(value) {
+  const text = String(value || '')
+  if (!text) return 0
+  const cjkChars = text.match(/[\u3400-\u9fff\uf900-\ufaff]/g)?.length ?? 0
+  const otherChars = Math.max(0, text.length - cjkChars)
+  return Math.ceil(cjkChars + otherChars / 3.5)
+}
+
+function contentToText(content) {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.map((block) => {
+    if (!block || typeof block !== 'object') return ''
+    if (block.type === 'text') return block.text || ''
+    if (block.type === 'thinking') return block.thinking || ''
+    if (block.type === 'image') return `[image:${block.mimeType || 'unknown'}]`
+    if (block.type === 'toolCall') return `[toolCall:${block.name || 'unknown'}] ${safeJson(block.arguments)}`
+    return safeJson(block)
+  }).filter(Boolean).join('\n')
+}
+
+function estimateMessageTokens(message) {
+  if (!message || typeof message !== 'object') return 0
+  const parts = [message.role || '', contentToText(message.content)]
+  if (message.toolName) parts.push(message.toolName)
+  if (message.toolCallId) parts.push(message.toolCallId)
+  if (message.details !== undefined) parts.push(safeJson(message.details))
+  if (message.attachments !== undefined) parts.push(safeJson(message.attachments))
+  return estimateTextTokens(parts.join('\n'))
+}
+
+function estimateMessagesTokens(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((total, message) => total + estimateMessageTokens(message), 0)
+}
+
+function estimateMessagesChars(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((total, message) => {
+    if (!message || typeof message !== 'object') return total
+    return total + [message.role || '', contentToText(message.content), safeJson(message.details), safeJson(message.attachments)].join('\n').length
+  }, 0)
+}
+
+export function estimateContextUsage({ systemPrompt, messages, tools, model }) {
+  const contextWindow = Number(model?.contextWindow) || 0
+  const reservedOutputTokens = Math.max(0, Number(model?.maxTokens) || 4096)
+  const inputTokens =
+    estimateTextTokens(systemPrompt) +
+    estimateMessagesTokens(messages) +
+    estimateTextTokens(safeJson(tools))
+  const totalTokens = inputTokens + reservedOutputTokens
+  const percent = contextWindow > 0 ? Math.round((totalTokens / contextWindow) * 1000) / 10 : 0
+  return { inputTokens, reservedOutputTokens, totalTokens, contextWindow, percent }
+}
+
+function isUserMessage(message) {
+  return message?.role === 'user' || message?.role === 'user-with-attachments'
+}
+
+function tailStartForRecentTurns(messages, keepRecentTurns) {
+  const source = Array.isArray(messages) ? messages : []
+  let seenUserTurns = 0
+  for (let index = source.length - 1; index >= 0; index--) {
+    if (!isUserMessage(source[index])) continue
+    seenUserTurns += 1
+    if (seenUserTurns >= keepRecentTurns) return index
+  }
+  return 0
+}
+
+function compactSummaryText(message) {
+  const content = message?.content
+  const text = typeof content === 'string'
+    ? content
+    : Array.isArray(content)
+      ? content.filter((block) => block?.type === 'text').map((block) => block.text || '').join('\n')
+      : ''
+  const match = text.match(/<compact_summary>\s*([\s\S]*?)\s*<\/compact_summary>/)
+  return match?.[1]?.trim() || text.trim()
+}
+
+function userTextMessage(text) {
+  return {
+    role: 'user',
+    content: [{ type: 'text', text }],
+    timestamp: Date.now(),
+  }
+}
+
+function buildCompactionSourceMessages(session, messages, tailStart) {
+  const source = []
+  const previousSummary = session.contextCompaction?.summaryMessage
+  if (previousSummary) {
+    source.push(userTextMessage([
+      'Existing rolling compact summary from earlier conversation history:',
+      '',
+      '<compact_summary>',
+      compactSummaryText(previousSummary),
+      '</compact_summary>',
+    ].join('\n')))
+  }
+  source.push(...messages.slice(session.contextCompaction?.compactedUpToIndex || 0, tailStart))
+  return source
+}
+
+export function buildAutoCompactLoopMessages(session, messages) {
+  const summaryMessage = session?.contextCompaction?.summaryMessage
+  if (!summaryMessage) return messages
+  const keepRecentTurns = session.contextCompaction.keepRecentTurns || DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns
+  const tailStart = tailStartForRecentTurns(messages, keepRecentTurns)
+  return [summaryMessage, ...messages.slice(tailStart)]
+}
+
+export async function maybeAutoCompactSession({ session, messages, signal, emitSessionEvent, persistSession, logger }) {
+  if (!session || session.autoCompacting) return { compacted: false }
+  const settings = await readAutoCompactSettings()
+  if (!settings.enabled) return { compacted: false }
+  if (signal?.aborted) return { compacted: false }
+
+  const loopMessages = buildAutoCompactLoopMessages(session, messages)
+  const usage = estimateContextUsage({
+    systemPrompt: session.agent.state.systemPrompt,
+    messages: loopMessages,
+    tools: session.agent.state.tools,
+    model: session.model,
+  })
+  if (!usage.contextWindow || usage.percent < settings.thresholdPercent) return { compacted: false, usage }
+
+  const now = Date.now()
+  if (session.lastAutoCompactAt && now - session.lastAutoCompactAt < AUTO_COMPACT_MIN_INTERVAL_MS) {
+    return { compacted: false, usage, reason: 'recently_compacted' }
+  }
+  if (session.contextCompaction?.sourceMessageCount && messages.length <= session.contextCompaction.sourceMessageCount + 2) {
+    return { compacted: false, usage, reason: 'not_enough_new_messages' }
+  }
+
+  const tailStart = tailStartForRecentTurns(messages, settings.keepRecentTurns)
+  const sourceMessages = buildCompactionSourceMessages(session, messages, tailStart)
+  if (sourceMessages.length < 2 || estimateMessagesChars(sourceMessages) < settings.minSourceChars) {
+    return { compacted: false, usage, reason: 'not_enough_history' }
+  }
+
+  session.autoCompacting = true
+  try {
+    const result = await compactConversation({
+      messages: sourceMessages,
+      model: session.model,
+      thinkingLevel: session.thinkingLevel,
+      getApiKey: session.getApiKey,
+      keepTurns: 0,
+    })
+
+    if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
+
+    await saveCompactBackup(session.sessionId, sourceMessages)
+    const summaryMessage = userTextMessage([
+      'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+      '',
+      '<compact_summary>',
+      result.summary,
+      '</compact_summary>',
+    ].join('\n'))
+    session.contextCompaction = {
+      summaryMessage,
+      compactedUpToIndex: tailStart,
+      compactedAt: new Date().toISOString(),
+      keepRecentTurns: settings.keepRecentTurns,
+      sourceMessageCount: messages.length,
+      usageBefore: usage,
+      thresholdPercent: settings.thresholdPercent,
+    }
+    session.lastAutoCompactAt = now
+    await persistSession(session)
+    emitSessionEvent(session, {
+      type: 'messages_replaced',
+      reason: 'auto_compact',
+      messages,
+      contextCompaction: session.contextCompaction,
+    })
+    return { compacted: true, usage }
+  } catch (error) {
+    logger?.warn?.(`Auto compact failed for session ${session.sessionId}:`, error?.message || error, { sessionId: session.sessionId })
+    return { compacted: false, usage, reason: 'error', error }
+  } finally {
+    session.autoCompacting = false
+  }
+}