@ashx-j/lunr 0.2.17 → 0.2.19

package/dist/node-runtime/chunk-STERBGUB.js

@@ -0,0 +1,949 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  minimatch
+} from "./chunk-CGBXPL3E.js";
+import {
+  buildSessionContext,
+  sessionEntryToContextMessages
+} from "./chunk-GKLEQ3I4.js";
+import {
+  convertToLlm,
+  createBranchSummaryMessage,
+  createCompactionSummaryMessage,
+  createCustomMessage
+} from "./chunk-FVDOXRUD.js";
+import {
+  isValidThinkingLevel
+} from "./chunk-QZMODZQ2.js";
+
+// packages/coding-agent/dist/core/compaction/utils.js
+function createFileOps() {
+  return {
+    read: /* @__PURE__ */ new Set(),
+    written: /* @__PURE__ */ new Set(),
+    edited: /* @__PURE__ */ new Set()
+  };
+}
+function extractFileOpsFromMessage(message, fileOps) {
+  if (message.role === "assistant" && !(!("content" in message) || !Array.isArray(message.content)))
+    for (let block of message.content) {
+      if (typeof block != "object" || block === null || !("type" in block) || block.type !== "toolCall" || !("arguments" in block) || !("name" in block))
+        continue;
+      let args = block.arguments;
+      if (!args)
+        continue;
+      let path = typeof args.path == "string" ? args.path : void 0;
+      if (path)
+        switch (block.name) {
+          case "read":
+            fileOps.read.add(path);
+            break;
+          case "write":
+            fileOps.written.add(path);
+            break;
+          case "edit":
+            fileOps.edited.add(path);
+            break;
+        }
+    }
+}
+function computeFileLists(fileOps) {
+  let modified = /* @__PURE__ */ new Set([...fileOps.edited, ...fileOps.written]), readOnly = [...fileOps.read].filter((f) => !modified.has(f)).sort(), modifiedFiles = [...modified].sort();
+  return { readFiles: readOnly, modifiedFiles };
+}
+function formatFileOperations(readFiles, modifiedFiles) {
+  let sections = [];
+  return readFiles.length > 0 && sections.push(`<read-files>
+${readFiles.join(`
+`)}
+</read-files>`), modifiedFiles.length > 0 && sections.push(`<modified-files>
+${modifiedFiles.join(`
+`)}
+</modified-files>`), sections.length === 0 ? "" : `
+
+${sections.join(`
+
+`)}`;
+}
+var TOOL_RESULT_MAX_CHARS = 2e3;
+function truncateForSummary(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
+  let truncatedChars = text.length - maxChars;
+  return `${text.slice(0, maxChars)}
+
+[... ${truncatedChars} more characters truncated]`;
+}
+function serializeConversation(messages) {
+  let parts = [];
+  for (let msg of messages)
+    if (msg.role === "user") {
+      let content = typeof msg.content == "string" ? msg.content : msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      content && parts.push(`[User]: ${content}`);
+    } else if (msg.role === "assistant") {
+      let textParts = [], thinkingParts = [], toolCalls = [];
+      for (let block of msg.content)
+        if (block.type === "text")
+          textParts.push(block.text);
+        else if (block.type === "thinking")
+          thinkingParts.push(block.thinking);
+        else if (block.type === "toolCall") {
+          let args = block.arguments, argsStr = Object.entries(args).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+          toolCalls.push(`${block.name}(${argsStr})`);
+        }
+      thinkingParts.length > 0 && parts.push(`[Assistant thinking]: ${thinkingParts.join(`
+`)}`), textParts.length > 0 && parts.push(`[Assistant]: ${textParts.join(`
+`)}`), toolCalls.length > 0 && parts.push(`[Assistant tool calls]: ${toolCalls.join("; ")}`);
+    } else if (msg.role === "toolResult") {
+      let content = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+      content && parts.push(`[Tool result]: ${truncateForSummary(content, TOOL_RESULT_MAX_CHARS)}`);
+    }
+  return parts.join(`
+
+`);
+}
+var SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarization assistant. Your task is to read a conversation between a user and an AI assistant, then produce a structured summary following the exact format specified.
+
+Do NOT continue the conversation. Do NOT respond to any questions in the conversation. ONLY output the structured summary.`;
+
+// packages/coding-agent/dist/core/compaction/compaction.js
+import { completeSimple } from "@ashx-j/lunr-ai/compat";
+function extractFileOperations(messages, entries, prevCompactionIndex) {
+  let fileOps = createFileOps();
+  if (prevCompactionIndex >= 0) {
+    let prevCompaction = entries[prevCompactionIndex];
+    if (!prevCompaction.fromHook && prevCompaction.details) {
+      let details = prevCompaction.details;
+      if (Array.isArray(details.readFiles))
+        for (let f of details.readFiles)
+          fileOps.read.add(f);
+      if (Array.isArray(details.modifiedFiles))
+        for (let f of details.modifiedFiles)
+          fileOps.edited.add(f);
+    }
+  }
+  for (let msg of messages)
+    extractFileOpsFromMessage(msg, fileOps);
+  return fileOps;
+}
+function getMessageFromEntryForCompaction(entry) {
+  if (entry.type !== "compaction")
+    return sessionEntryToContextMessages(entry)[0];
+}
+var DEFAULT_COMPACTION_SETTINGS = {
+  enabled: !0,
+  reserveTokens: 16384,
+  keepRecentTokens: 2e4
+};
+function calculateContextTokens(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function getAssistantUsage(msg) {
+  if (msg.role === "assistant" && "usage" in msg) {
+    let assistantMsg = msg;
+    if (assistantMsg.stopReason !== "aborted" && assistantMsg.stopReason !== "error" && assistantMsg.usage && calculateContextTokens(assistantMsg.usage) > 0)
+      return assistantMsg.usage;
+  }
+}
+function getLastAssistantUsage(entries) {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    let entry = entries[i];
+    if (entry.type === "message") {
+      let usage = getAssistantUsage(entry.message);
+      if (usage)
+        return usage;
+    }
+  }
+}
+function getLastAssistantUsageInfo(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    let usage = getAssistantUsage(messages[i]);
+    if (usage)
+      return { usage, index: i };
+  }
+}
+function estimateContextTokens(messages) {
+  let usageInfo = getLastAssistantUsageInfo(messages);
+  if (!usageInfo) {
+    let estimated = 0;
+    for (let message of messages)
+      estimated += estimateTokens(message);
+    return {
+      tokens: estimated,
+      usageTokens: 0,
+      trailingTokens: estimated,
+      lastUsageIndex: null
+    };
+  }
+  let usageTokens = calculateContextTokens(usageInfo.usage), trailingTokens = 0;
+  for (let i = usageInfo.index + 1; i < messages.length; i++)
+    trailingTokens += estimateTokens(messages[i]);
+  return {
+    tokens: usageTokens + trailingTokens,
+    usageTokens,
+    trailingTokens,
+    lastUsageIndex: usageInfo.index
+  };
+}
+function shouldCompact(contextTokens, contextWindow, settings) {
+  return settings.enabled ? contextTokens > contextWindow - settings.reserveTokens : !1;
+}
+var ESTIMATED_IMAGE_CHARS = 4800;
+function estimateTextAndImageContentChars(content) {
+  if (typeof content == "string")
+    return content.length;
+  let chars = 0;
+  for (let block of content)
+    block.type === "text" && block.text ? chars += block.text.length : block.type === "image" && (chars += ESTIMATED_IMAGE_CHARS);
+  return chars;
+}
+function estimateTokens(message) {
+  let chars = 0;
+  switch (message.role) {
+    case "user":
+      return chars = estimateTextAndImageContentChars(message.content), Math.ceil(chars / 4);
+    case "assistant": {
+      let assistant = message;
+      for (let block of assistant.content)
+        block.type === "text" ? chars += block.text.length : block.type === "thinking" ? chars += block.thinking.length : block.type === "toolCall" && (chars += block.name.length + JSON.stringify(block.arguments).length);
+      return Math.ceil(chars / 4);
+    }
+    case "custom":
+    case "toolResult":
+      return chars = estimateTextAndImageContentChars(message.content), Math.ceil(chars / 4);
+    case "bashExecution":
+      return chars = message.command.length + message.output.length, Math.ceil(chars / 4);
+    case "branchSummary":
+    case "compactionSummary":
+      return chars = message.summary.length, Math.ceil(chars / 4);
+  }
+  return 0;
+}
+function isCutPointMessage(message) {
+  switch (message.role) {
+    case "user":
+    case "assistant":
+    case "bashExecution":
+    case "custom":
+    case "branchSummary":
+    case "compactionSummary":
+      return !0;
+    case "toolResult":
+      return !1;
+  }
+  return !1;
+}
+function isTurnStartMessage(message) {
+  switch (message.role) {
+    case "user":
+    case "bashExecution":
+    case "custom":
+    case "branchSummary":
+    case "compactionSummary":
+      return !0;
+    case "assistant":
+    case "toolResult":
+      return !1;
+  }
+  return !1;
+}
+function isTurnStartEntry(entry) {
+  return entry.type === "compaction" ? !1 : sessionEntryToContextMessages(entry).some(isTurnStartMessage);
+}
+function findValidCutPoints(entries, startIndex, endIndex) {
+  let cutPoints = [];
+  for (let i = startIndex; i < endIndex; i++) {
+    let entry = entries[i];
+    entry.type !== "compaction" && sessionEntryToContextMessages(entry).some(isCutPointMessage) && cutPoints.push(i);
+  }
+  return cutPoints;
+}
+function findTurnStartIndex(entries, entryIndex, startIndex) {
+  for (let i = entryIndex; i >= startIndex; i--)
+    if (isTurnStartEntry(entries[i]))
+      return i;
+  return -1;
+}
+function findCutPoint(entries, startIndex, endIndex, keepRecentTokens) {
+  let cutPoints = findValidCutPoints(entries, startIndex, endIndex);
+  if (cutPoints.length === 0)
+    return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: !1 };
+  let accumulatedTokens = 0, cutIndex = cutPoints[0];
+  for (let i = endIndex - 1; i >= startIndex; i--) {
+    let entry = entries[i], messageTokens = sessionEntryToContextMessages(entry).reduce((sum, message) => sum + estimateTokens(message), 0);
+    if (messageTokens !== 0 && (accumulatedTokens += messageTokens, accumulatedTokens >= keepRecentTokens)) {
+      let nextCutPoint = cutPoints.find((candidate) => candidate >= i);
+      if (nextCutPoint !== void 0)
+        cutIndex = nextCutPoint;
+      else
+        for (let c = cutPoints.length - 1; c >= 0; c--)
+          if (cutPoints[c] <= i) {
+            cutIndex = cutPoints[c];
+            break;
+          }
+      break;
+    }
+  }
+  for (; cutIndex > startIndex; ) {
+    let prevEntry = entries[cutIndex - 1];
+    if (prevEntry.type === "compaction" || sessionEntryToContextMessages(prevEntry).length > 0)
+      break;
+    cutIndex--;
+  }
+  let cutEntry = entries[cutIndex], startsTurn = isTurnStartEntry(cutEntry), turnStartIndex = startsTurn ? -1 : findTurnStartIndex(entries, cutIndex, startIndex);
+  return {
+    firstKeptEntryIndex: cutIndex,
+    turnStartIndex,
+    isSplitTurn: !startsTurn && turnStartIndex !== -1
+  };
+}
+var SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+- [Any data, examples, or references needed to continue]
+- [Or "(none)" if not applicable]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`, UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+- [Preserve important context, add new if needed]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+function createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel, cacheRetention) {
+  let options = { maxTokens, signal, apiKey, headers, env, cacheRetention };
+  return model.reasoning && thinkingLevel && thinkingLevel !== "off" && (options.reasoning = thinkingLevel), options;
+}
+async function completeSummarization(model, context, options, streamFn) {
+  return streamFn ? (await streamFn(model, context, options)).result() : completeSimple(model, context, options);
+}
+async function generateSummary(currentMessages, model, reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env) {
+  let maxTokens = Math.min(Math.floor(0.8 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY), basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
+  customInstructions && (basePrompt = `${basePrompt}
+
+Additional focus: ${customInstructions}`);
+  let llmMessages = convertToLlm(currentMessages), promptText = `<conversation>
+${serializeConversation(llmMessages)}
+</conversation>
+
+`;
+  previousSummary && (promptText += `<previous-summary>
+${previousSummary}
+</previous-summary>
+
+`), promptText += basePrompt;
+  let summarizationMessages = [
+    {
+      role: "user",
+      content: [{ type: "text", text: promptText }],
+      timestamp: Date.now()
+    }
+  ], completionOptions = createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel), response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, completionOptions, streamFn);
+  if (response.stopReason === "error")
+    throw new Error(`Summarization failed: ${response.errorMessage || "Unknown error"}`);
+  return response.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+}
+function prepareCompaction(pathEntries, settings) {
+  if (pathEntries.length > 0 && pathEntries[pathEntries.length - 1].type === "compaction")
+    return;
+  let prevCompactionIndex = -1;
+  for (let i = pathEntries.length - 1; i >= 0; i--)
+    if (pathEntries[i].type === "compaction") {
+      prevCompactionIndex = i;
+      break;
+    }
+  let previousSummary, boundaryStart = 0;
+  if (prevCompactionIndex >= 0) {
+    let prevCompaction = pathEntries[prevCompactionIndex];
+    previousSummary = prevCompaction.summary;
+    let firstKeptEntryIndex = pathEntries.findIndex((entry) => entry.id === prevCompaction.firstKeptEntryId);
+    boundaryStart = firstKeptEntryIndex >= 0 ? firstKeptEntryIndex : prevCompactionIndex + 1;
+  }
+  let boundaryEnd = pathEntries.length, tokensBefore = estimateContextTokens(buildSessionContext(pathEntries).messages).tokens, cutPoint = findCutPoint(pathEntries, boundaryStart, boundaryEnd, settings.keepRecentTokens), firstKeptEntry = pathEntries[cutPoint.firstKeptEntryIndex];
+  if (!firstKeptEntry?.id)
+    return;
+  let firstKeptEntryId = firstKeptEntry.id, historyEnd = cutPoint.isSplitTurn ? cutPoint.turnStartIndex : cutPoint.firstKeptEntryIndex, messagesToSummarize = [];
+  for (let i = boundaryStart; i < historyEnd; i++) {
+    let msg = getMessageFromEntryForCompaction(pathEntries[i]);
+    msg && messagesToSummarize.push(msg);
+  }
+  let turnPrefixMessages = [];
+  if (cutPoint.isSplitTurn)
+    for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
+      let msg = getMessageFromEntryForCompaction(pathEntries[i]);
+      msg && turnPrefixMessages.push(msg);
+    }
+  if (messagesToSummarize.length === 0 && turnPrefixMessages.length === 0)
+    return;
+  let fileOps = extractFileOperations(messagesToSummarize, pathEntries, prevCompactionIndex);
+  if (cutPoint.isSplitTurn)
+    for (let msg of turnPrefixMessages)
+      extractFileOpsFromMessage(msg, fileOps);
+  return {
+    firstKeptEntryId,
+    messagesToSummarize,
+    turnPrefixMessages,
+    isSplitTurn: cutPoint.isSplitTurn,
+    tokensBefore,
+    previousSummary,
+    fileOps,
+    settings
+  };
+}
+var TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
+async function compact(preparation, model, apiKey, headers, customInstructions, signal, thinkingLevel, streamFn, env) {
+  let { firstKeptEntryId, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, previousSummary, fileOps, settings } = preparation, summary;
+  if (isSplitTurn && turnPrefixMessages.length > 0) {
+    let historyResult = messagesToSummarize.length > 0 ? await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env) : "No prior history.", turnPrefixResult = await generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn);
+    summary = `${historyResult}
+
+---
+
+**Turn Context (split turn):**
+
+${turnPrefixResult}`;
+  } else
+    summary = await generateSummary(messagesToSummarize, model, settings.reserveTokens, apiKey, headers, signal, customInstructions, previousSummary, thinkingLevel, streamFn, env);
+  let { readFiles, modifiedFiles } = computeFileLists(fileOps);
+  if (summary += formatFileOperations(readFiles, modifiedFiles), !firstKeptEntryId)
+    throw new Error("First kept entry has no UUID - session may need migration");
+  return {
+    summary,
+    firstKeptEntryId,
+    tokensBefore,
+    details: { readFiles, modifiedFiles }
+  };
+}
+async function generateTurnPrefixSummary(messages, model, reserveTokens, apiKey, headers, env, signal, thinkingLevel, streamFn) {
+  let maxTokens = Math.min(Math.floor(0.5 * reserveTokens), model.maxTokens > 0 ? model.maxTokens : Number.POSITIVE_INFINITY), llmMessages = convertToLlm(messages), summarizationMessages = [
+    {
+      role: "user",
+      content: [{ type: "text", text: `<conversation>
+${serializeConversation(llmMessages)}
+</conversation>
+
+${TURN_PREFIX_SUMMARIZATION_PROMPT}` }],
+      timestamp: Date.now()
+    }
+  ], response = await completeSummarization(model, { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, createSummarizationOptions(model, maxTokens, apiKey, headers, env, signal, thinkingLevel), streamFn);
+  if (response.stopReason === "error")
+    throw new Error(`Turn prefix summarization failed: ${response.errorMessage || "Unknown error"}`);
+  return response.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+}
+
+// packages/coding-agent/dist/core/compaction/branch-summarization.js
+import { completeSimple as completeSimple2 } from "@ashx-j/lunr-ai/compat";
+function collectEntriesForBranchSummary(session, oldLeafId, targetId) {
+  if (!oldLeafId)
+    return { entries: [], commonAncestorId: null };
+  let oldPath = new Set(session.getBranch(oldLeafId).map((e) => e.id)), targetPath = session.getBranch(targetId), commonAncestorId = null;
+  for (let i = targetPath.length - 1; i >= 0; i--)
+    if (oldPath.has(targetPath[i].id)) {
+      commonAncestorId = targetPath[i].id;
+      break;
+    }
+  let entries = [], current = oldLeafId;
+  for (; current && current !== commonAncestorId; ) {
+    let entry = session.getEntry(current);
+    if (!entry)
+      break;
+    entries.push(entry), current = entry.parentId;
+  }
+  return entries.reverse(), { entries, commonAncestorId };
+}
+function getMessageFromEntry(entry) {
+  switch (entry.type) {
+    case "message":
+      return entry.message.role === "toolResult" ? void 0 : entry.message;
+    case "custom_message":
+      return createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp);
+    case "branch_summary":
+      return createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp);
+    case "compaction":
+      return createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
+    // These don't contribute to conversation content
+    case "thinking_level_change":
+    case "model_change":
+    case "custom":
+    case "label":
+    case "session_info":
+      return;
+  }
+}
+function prepareBranchEntries(entries, tokenBudget = 0) {
+  let messages = [], fileOps = createFileOps(), totalTokens = 0;
+  for (let entry of entries)
+    if (entry.type === "branch_summary" && !entry.fromHook && entry.details) {
+      let details = entry.details;
+      if (Array.isArray(details.readFiles))
+        for (let f of details.readFiles)
+          fileOps.read.add(f);
+      if (Array.isArray(details.modifiedFiles))
+        for (let f of details.modifiedFiles)
+          fileOps.edited.add(f);
+    }
+  for (let i = entries.length - 1; i >= 0; i--) {
+    let entry = entries[i], message = getMessageFromEntry(entry);
+    if (!message)
+      continue;
+    extractFileOpsFromMessage(message, fileOps);
+    let tokens = estimateTokens(message);
+    if (tokenBudget > 0 && totalTokens + tokens > tokenBudget) {
+      (entry.type === "compaction" || entry.type === "branch_summary") && totalTokens < tokenBudget * 0.9 && (messages.unshift(message), totalTokens += tokens);
+      break;
+    }
+    messages.unshift(message), totalTokens += tokens;
+  }
+  return { messages, fileOps, totalTokens };
+}
+var BRANCH_SUMMARY_PREAMBLE = `The user explored a different conversation branch before returning here.
+Summary of that exploration:
+
+`, BRANCH_SUMMARY_PROMPT = `Create a structured summary of this conversation branch for context when returning later.
+
+Use this EXACT format:
+
+## Goal
+[What was the user trying to accomplish in this branch?]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Work that was started but not finished]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [What should happen next to continue this work]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+async function generateBranchSummary(entries, options) {
+  let { model, apiKey, headers, env, signal, customInstructions, replaceInstructions, reserveTokens = 16384, streamFn } = options, tokenBudget = (model.contextWindow || 128e3) - reserveTokens, { messages, fileOps } = prepareBranchEntries(entries, tokenBudget);
+  if (messages.length === 0)
+    return { summary: "No content to summarize" };
+  let llmMessages = convertToLlm(messages), conversationText = serializeConversation(llmMessages), instructions;
+  replaceInstructions && customInstructions ? instructions = customInstructions : customInstructions ? instructions = `${BRANCH_SUMMARY_PROMPT}
+
+Additional focus: ${customInstructions}` : instructions = BRANCH_SUMMARY_PROMPT;
+  let summarizationMessages = [
+    {
+      role: "user",
+      content: [{ type: "text", text: `<conversation>
+${conversationText}
+</conversation>
+
+${instructions}` }],
+      timestamp: Date.now()
+    }
+  ], context = { systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages }, requestOptions = { apiKey, headers, env, signal, maxTokens: 2048 }, response = streamFn ? await (await streamFn(model, context, requestOptions)).result() : await completeSimple2(model, context, requestOptions);
+  if (response.stopReason === "aborted")
+    return { aborted: !0 };
+  if (response.stopReason === "error")
+    return { error: response.errorMessage || "Summarization failed" };
+  let summary = response.content.filter((c) => c.type === "text").map((c) => c.text).join(`
+`);
+  summary = BRANCH_SUMMARY_PREAMBLE + summary;
+  let { readFiles, modifiedFiles } = computeFileLists(fileOps);
+  return summary += formatFileOperations(readFiles, modifiedFiles), {
+    summary: summary || "No summary generated",
+    readFiles,
+    modifiedFiles
+  };
+}
+
+// packages/coding-agent/dist/core/model-resolver.js
+import { modelsAreEqual } from "@ashx-j/lunr-ai";
+import chalk from "chalk";
+
+// packages/coding-agent/dist/core/defaults.js
+var DEFAULT_THINKING_LEVEL = "medium";
+
+// packages/coding-agent/dist/core/model-resolver.js
+var defaultModelPerProvider = {
+  "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
+  "ant-ling": "Ring-2.6-1T",
+  anthropic: "claude-opus-4-8",
+  openai: "gpt-5.5",
+  "azure-openai-responses": "gpt-5.4",
+  "openai-codex": "gpt-5.5",
+  radius: "auto",
+  nvidia: "nvidia/nemotron-3-super-120b-a12b",
+  deepseek: "deepseek-v4-pro",
+  google: "gemini-3.1-pro-preview",
+  "google-vertex": "gemini-3.1-pro-preview",
+  "github-copilot": "gpt-5.4",
+  openrouter: "moonshotai/kimi-k2.6",
+  "vercel-ai-gateway": "zai/glm-5.1",
+  xai: "grok-4.5",
+  groq: "openai/gpt-oss-120b",
+  cerebras: "zai-glm-4.7",
+  zai: "glm-5.1",
+  "zai-coding-cn": "glm-5.1",
+  mistral: "devstral-medium-latest",
+  minimax: "MiniMax-M2.7",
+  "minimax-cn": "MiniMax-M2.7",
+  moonshotai: "kimi-k2.6",
+  "moonshotai-cn": "kimi-k2.6",
+  huggingface: "moonshotai/Kimi-K2.6",
+  fireworks: "accounts/fireworks/models/kimi-k2p6",
+  together: "moonshotai/Kimi-K2.6",
+  opencode: "kimi-k2.6",
+  "opencode-go": "kimi-k2.6",
+  "kimi-coding": "kimi-for-coding",
+  "cloudflare-workers-ai": "@cf/moonshotai/kimi-k2.6",
+  "cloudflare-ai-gateway": "workers-ai/@cf/moonshotai/kimi-k2.6",
+  xiaomi: "mimo-v2.5-pro",
+  "xiaomi-token-plan-cn": "mimo-v2.5-pro",
+  "xiaomi-token-plan-ams": "mimo-v2.5-pro",
+  "xiaomi-token-plan-sgp": "mimo-v2.5-pro",
+  "qwen-token-plan": "qwen3.8-max-preview",
+  "qwen-token-plan-cn": "qwen3.8-max-preview",
+  "qwen-cloud": "qwen3.8-max",
+  "qwen-cloud-cn": "qwen3.8-max"
+};
+function isAlias(id) {
+  return id.endsWith("-latest") ? !0 : !/-\d{8}$/.test(id);
+}
+function findExactModelReferenceMatch(modelReference, availableModels) {
+  let trimmedReference = modelReference.trim();
+  if (!trimmedReference)
+    return;
+  let normalizedReference = trimmedReference.toLowerCase(), canonicalMatches = availableModels.filter((model) => `${model.provider}/${model.id}`.toLowerCase() === normalizedReference);
+  if (canonicalMatches.length === 1)
+    return canonicalMatches[0];
+  if (canonicalMatches.length > 1)
+    return;
+  let slashIndex = trimmedReference.indexOf("/");
+  if (slashIndex !== -1) {
+    let provider = trimmedReference.substring(0, slashIndex).trim(), modelId = trimmedReference.substring(slashIndex + 1).trim();
+    if (provider && modelId) {
+      let providerMatches = availableModels.filter((model) => model.provider.toLowerCase() === provider.toLowerCase() && model.id.toLowerCase() === modelId.toLowerCase());
+      if (providerMatches.length === 1)
+        return providerMatches[0];
+      if (providerMatches.length > 1)
+        return;
+    }
+  }
+  let idMatches = availableModels.filter((model) => model.id.toLowerCase() === normalizedReference);
+  return idMatches.length === 1 ? idMatches[0] : void 0;
+}
+function tryMatchModel(modelPattern, availableModels) {
+  let exactMatch = findExactModelReferenceMatch(modelPattern, availableModels);
+  if (exactMatch)
+    return exactMatch;
+  let matches = availableModels.filter((m) => m.id.toLowerCase().includes(modelPattern.toLowerCase()) || m.name?.toLowerCase().includes(modelPattern.toLowerCase()));
+  if (matches.length === 0)
+    return;
+  let aliases = matches.filter((m) => isAlias(m.id)), datedVersions = matches.filter((m) => !isAlias(m.id));
+  return aliases.length > 0 ? (aliases.sort((a, b) => b.id.localeCompare(a.id)), aliases[0]) : (datedVersions.sort((a, b) => b.id.localeCompare(a.id)), datedVersions[0]);
+}
+function buildFallbackModel(provider, modelId, availableModels) {
+  let providerModels = availableModels.filter((m) => m.provider === provider);
+  if (providerModels.length === 0)
+    return;
+  let defaultId = defaultModelPerProvider[provider];
+  return {
+    ...defaultId ? providerModels.find((m) => m.id === defaultId) ?? providerModels[0] : providerModels[0],
+    id: modelId,
+    name: modelId
+  };
+}
+function parseModelPattern(pattern, availableModels, options) {
+  let exactMatch = tryMatchModel(pattern, availableModels);
+  if (exactMatch)
+    return { model: exactMatch, thinkingLevel: void 0, warning: void 0 };
+  let lastColonIndex = pattern.lastIndexOf(":");
+  if (lastColonIndex === -1)
+    return { model: void 0, thinkingLevel: void 0, warning: void 0 };
+  let prefix = pattern.substring(0, lastColonIndex), suffix = pattern.substring(lastColonIndex + 1);
+  if (isValidThinkingLevel(suffix)) {
+    let result = parseModelPattern(prefix, availableModels, options);
+    return result.model ? {
+      model: result.model,
+      thinkingLevel: result.warning ? void 0 : suffix,
+      warning: result.warning
+    } : result;
+  } else {
+    if (!(options?.allowInvalidThinkingLevelFallback ?? !0))
+      return { model: void 0, thinkingLevel: void 0, warning: void 0 };
+    let result = parseModelPattern(prefix, availableModels, options);
+    return result.model ? {
+      model: result.model,
+      thinkingLevel: void 0,
+      warning: `Invalid thinking level "${suffix}" in pattern "${pattern}". Using default instead.`
+    } : result;
+  }
+}
+async function resolveModelScopeWithDiagnostics(patterns, modelRuntime) {
+  let availableModels = [...await modelRuntime.getAvailable()], scopedModels = [], diagnostics = [];
+  for (let pattern of patterns) {
+    if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[")) {
+      let colonIdx = pattern.lastIndexOf(":"), globPattern = pattern, thinkingLevel2;
+      if (colonIdx !== -1) {
+        let suffix = pattern.substring(colonIdx + 1);
+        isValidThinkingLevel(suffix) && (thinkingLevel2 = suffix, globPattern = pattern.substring(0, colonIdx));
+      }
+      let matchingModels = availableModels.filter((m) => {
+        let fullId = `${m.provider}/${m.id}`;
+        return minimatch(fullId, globPattern, { nocase: !0 }) || minimatch(m.id, globPattern, { nocase: !0 });
+      });
+      if (matchingModels.length === 0) {
+        diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
+        continue;
+      }
+      for (let model2 of matchingModels)
+        scopedModels.find((sm) => modelsAreEqual(sm.model, model2)) || scopedModels.push({ model: model2, thinkingLevel: thinkingLevel2 });
+      continue;
+    }
+    let { model, thinkingLevel, warning } = parseModelPattern(pattern, availableModels);
+    if (warning && diagnostics.push({ type: "warning", message: warning, pattern }), !model) {
+      diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
+      continue;
+    }
+    scopedModels.find((sm) => modelsAreEqual(sm.model, model)) || scopedModels.push({ model, thinkingLevel });
+  }
+  return { scopedModels, diagnostics };
+}
+async function resolveModelScope(patterns, modelRuntime) {
+  let { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(patterns, modelRuntime);
+  for (let diagnostic of diagnostics)
+    console.warn(chalk.yellow(`Warning: ${diagnostic.message}`));
+  return scopedModels;
+}
+function resolveCliModel(options) {
+  let { cliProvider, cliModel, cliThinking, modelRuntime } = options;
+  if (!cliModel)
+    return { model: void 0, warning: void 0, error: void 0 };
+  let availableModels = [...modelRuntime.getModels()];
+  if (availableModels.length === 0)
+    return {
+      model: void 0,
+      warning: void 0,
+      error: "No models available. Check your installation or add models to models.json."
+    };
+  let providerMap = /* @__PURE__ */ new Map();
+  for (let m of availableModels)
+    providerMap.set(m.provider.toLowerCase(), m.provider);
+  let provider = cliProvider ? providerMap.get(cliProvider.toLowerCase()) : void 0;
+  if (cliProvider && !provider)
+    return {
+      model: void 0,
+      warning: void 0,
+      error: `Unknown provider "${cliProvider}". Use --list-models to see available providers/models.`
+    };
+  let pattern = cliModel, inferredProvider = !1;
+  if (!provider) {
+    let slashIndex = cliModel.indexOf("/");
+    if (slashIndex !== -1) {
+      let maybeProvider = cliModel.substring(0, slashIndex), canonical = providerMap.get(maybeProvider.toLowerCase());
+      canonical && (provider = canonical, pattern = cliModel.substring(slashIndex + 1), inferredProvider = !0);
+    }
+  }
+  if (!provider) {
+    let lower = cliModel.toLowerCase(), exact = availableModels.find((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
+    if (exact)
+      return { model: exact, warning: void 0, thinkingLevel: void 0, error: void 0 };
+  }
+  if (cliProvider && provider) {
+    let prefix = `${provider}/`;
+    cliModel.toLowerCase().startsWith(prefix.toLowerCase()) && (pattern = cliModel.substring(prefix.length));
+  }
+  let candidates = provider ? availableModels.filter((m) => m.provider === provider) : availableModels, { model, thinkingLevel, warning } = parseModelPattern(pattern, candidates, {
+    allowInvalidThinkingLevelFallback: !1
+  });
+  if (model) {
+    if (inferredProvider) {
+      let rawExactMatches = availableModels.filter((m) => m.id.toLowerCase() === cliModel.toLowerCase() && !modelsAreEqual(m, model));
+      if (rawExactMatches.length > 0 && !modelRuntime.hasConfiguredAuth(model.provider)) {
+        let authenticatedRawMatches = rawExactMatches.filter((m) => modelRuntime.hasConfiguredAuth(m.provider));
+        if (authenticatedRawMatches.length === 1)
+          return {
+            model: authenticatedRawMatches[0],
+            thinkingLevel: void 0,
+            warning: void 0,
+            error: void 0
+          };
+      }
+    }
+    return { model, thinkingLevel, warning, error: void 0 };
+  }
+  if (inferredProvider) {
+    let lower = cliModel.toLowerCase(), exact = availableModels.find((m) => m.id.toLowerCase() === lower || `${m.provider}/${m.id}`.toLowerCase() === lower);
+    if (exact)
+      return { model: exact, warning: void 0, thinkingLevel: void 0, error: void 0 };
+    let fallback = parseModelPattern(cliModel, availableModels, {
+      allowInvalidThinkingLevelFallback: !1
+    });
+    if (fallback.model)
+      return {
+        model: fallback.model,
+        thinkingLevel: fallback.thinkingLevel,
+        warning: fallback.warning,
+        error: void 0
+      };
+  }
+  if (provider) {
+    let fallbackPattern = pattern, fallbackThinking;
+    if (!cliThinking) {
+      let lastColon = pattern.lastIndexOf(":");
+      if (lastColon !== -1) {
+        let suffix = pattern.substring(lastColon + 1);
+        isValidThinkingLevel(suffix) && (fallbackPattern = pattern.substring(0, lastColon), fallbackThinking = suffix);
+      }
+    }
+    let fallbackModel = buildFallbackModel(provider, fallbackPattern, availableModels);
+    if (fallbackModel) {
+      let requestedThinking = cliThinking ?? fallbackThinking, model2 = requestedThinking && requestedThinking !== "off" ? { ...fallbackModel, reasoning: !0 } : fallbackModel, fallbackWarning = warning ? `${warning} Model "${fallbackPattern}" not found for provider "${provider}". Using custom model id.` : `Model "${fallbackPattern}" not found for provider "${provider}". Using custom model id.`;
+      return { model: model2, thinkingLevel: fallbackThinking, warning: fallbackWarning, error: void 0 };
+    }
+  }
+  let display = provider ? `${provider}/${pattern}` : cliModel;
+  return {
+    model: void 0,
+    thinkingLevel: void 0,
+    warning,
+    error: `Model "${display}" not found. Use --list-models to see available models.`
+  };
+}
+async function findInitialModel(options) {
+  let { cliProvider, cliModel, scopedModels, isContinuing, defaultProvider, defaultModelId, defaultThinkingLevel, modelRuntime } = options, model, thinkingLevel = DEFAULT_THINKING_LEVEL;
+  if (cliProvider && cliModel) {
+    let resolved = resolveCliModel({
+      cliProvider,
+      cliModel,
+      modelRuntime
+    });
+    if (resolved.error && (console.error(chalk.red(resolved.error)), process.exit(1)), resolved.model)
+      return { model: resolved.model, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: void 0 };
+  }
+  if (scopedModels.length > 0 && !isContinuing)
+    return {
+      model: scopedModels[0].model,
+      thinkingLevel: scopedModels[0].thinkingLevel ?? defaultThinkingLevel ?? DEFAULT_THINKING_LEVEL,
+      fallbackMessage: void 0
+    };
+  if (defaultProvider && defaultModelId) {
+    let found = modelRuntime.getModel(defaultProvider, defaultModelId);
+    if (found && modelRuntime.hasConfiguredAuth(found.provider))
+      return model = found, defaultThinkingLevel && (thinkingLevel = defaultThinkingLevel), { model, thinkingLevel, fallbackMessage: void 0 };
+  }
+  let availableModels = [...await modelRuntime.getAvailable()];
+  if (availableModels.length > 0) {
+    for (let provider of Object.keys(defaultModelPerProvider)) {
+      let defaultId = defaultModelPerProvider[provider], match = availableModels.find((m) => m.provider === provider && m.id === defaultId);
+      if (match)
+        return { model: match, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: void 0 };
+    }
+    return { model: availableModels[0], thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: void 0 };
+  }
+  return { model: void 0, thinkingLevel: DEFAULT_THINKING_LEVEL, fallbackMessage: void 0 };
+}
+
+export {
+  createFileOps,
+  extractFileOpsFromMessage,
+  computeFileLists,
+  serializeConversation,
+  DEFAULT_COMPACTION_SETTINGS,
+  calculateContextTokens,
+  getLastAssistantUsage,
+  estimateContextTokens,
+  shouldCompact,
+  estimateTokens,
+  findTurnStartIndex,
+  findCutPoint,
+  generateSummary,
+  prepareCompaction,
+  compact,
+  collectEntriesForBranchSummary,
+  prepareBranchEntries,
+  generateBranchSummary,
+  DEFAULT_THINKING_LEVEL,
+  defaultModelPerProvider,
+  findExactModelReferenceMatch,
+  resolveModelScopeWithDiagnostics,
+  resolveModelScope,
+  resolveCliModel,
+  findInitialModel
+};