@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/chunk-GEYXPTRF.js

@@ -0,0 +1,613 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  cwdHash,
+  sessionPaths
+} from "./chunk-FO5ZOVUY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/context-accounting.ts
+init_esm_shims();
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// src/domains/session/compaction/auto.ts
+init_esm_shims();
+var DEFAULT_COMPACTION_THRESHOLD = 0.8;
+function shouldCompact(contextTokens, threshold, contextWindow) {
+  const base = {
+    shouldCompact: false,
+    pressure: null,
+    contextTokens,
+    contextWindow,
+    threshold
+  };
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold > 1) return base;
+  if (!Number.isFinite(contextTokens) || contextTokens <= 0) return base;
+  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return base;
+  const pressure = contextTokens / contextWindow;
+  return {
+    shouldCompact: pressure >= threshold,
+    pressure,
+    contextTokens,
+    contextWindow,
+    threshold
+  };
+}
+var AutoCompactionTrigger = class {
+  inFlight = null;
+  /** True while a task is in flight. Callers can short-circuit on this. */
+  isBusy() {
+    return this.inFlight !== null;
+  }
+  /**
+   * Run `task` unless one is already in flight. Returns the Promise the
+   * task is running under. Callers always get the eventual result of the
+   * first task, never a second call. Rejections clear the slot so a later
+   * fire can start fresh.
+   */
+  fire(task) {
+    if (this.inFlight) return this.inFlight;
+    const run = task().finally(() => {
+      this.inFlight = null;
+    });
+    this.inFlight = run;
+    return run;
+  }
+};
+
+// src/domains/session/context-ledger.ts
+init_esm_shims();
+var SEGMENT_CATEGORY = {
+  identity: "system",
+  "operating-contract": "system",
+  delegation: "agents",
+  skills: "skills",
+  safety: "system",
+  runtime: "system",
+  "tool-contract": "system",
+  "retrieval-hints": "system",
+  "tool-catalog": "tools",
+  "tools-and-agents": "agents",
+  "agent-fleet-deltas": "agents",
+  "skills-catalog": "skills",
+  memory: "memory",
+  "project-context": "project",
+  "context.project-rules": "project",
+  "context.operator-profile": "memory",
+  "context.clio-repo-awareness": "system",
+  "history-summary": "messages"
+};
+var CONTEXT_CATEGORY_LABEL = {
+  system: "System prompt",
+  tools: "Tool definitions",
+  agents: "Agent fleet",
+  skills: "Skills",
+  memory: "Memory",
+  project: "Project context",
+  messages: "Messages",
+  pending: "Pending input",
+  reserve: "Autocompact reserve",
+  free: "Free space",
+  streaming: "Streaming output"
+};
+var CONTENT_ORDER = [
+  "system",
+  "tools",
+  "agents",
+  "skills",
+  "memory",
+  "project",
+  "messages",
+  "pending",
+  "streaming"
+];
+function categoryForSegment(id) {
+  return SEGMENT_CATEGORY[id] ?? "system";
+}
+function finiteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function percentOf(tokens, window) {
+  if (window <= 0) return null;
+  return Math.min(100, tokens / window * 100);
+}
+function buildContextLedger(input) {
+  const window = finiteNonNegative(input.contextWindow);
+  const raw = {
+    system: 0,
+    tools: 0,
+    agents: 0,
+    skills: 0,
+    memory: 0,
+    project: 0,
+    messages: 0,
+    pending: 0,
+    reserve: 0,
+    free: 0,
+    streaming: 0
+  };
+  const segments = input.promptSegments ?? [];
+  if (segments.length > 0) {
+    for (const segment of segments) {
+      raw[categoryForSegment(segment.id)] += finiteNonNegative(segment.tokenEstimate);
+    }
+  } else {
+    raw.system += finiteNonNegative(input.systemPromptTokens);
+  }
+  raw.tools += finiteNonNegative(input.toolSchemaTokens);
+  raw.messages += finiteNonNegative(input.messageTokens);
+  raw.pending += finiteNonNegative(input.pendingTokens);
+  raw.streaming += finiteNonNegative(input.streamingTokens);
+  raw.agents += finiteNonNegative(input.agentsTokens);
+  raw.skills += finiteNonNegative(input.skillsTokens);
+  raw.memory += finiteNonNegative(input.memoryTokens);
+  raw.project += finiteNonNegative(input.projectTokens);
+  const decomposed = CONTENT_ORDER.reduce((sum, category) => sum + raw[category], 0);
+  const liveTotal = finiteNonNegative(input.liveTotalTokens);
+  if (liveTotal > decomposed) {
+    raw.messages += liveTotal - decomposed;
+  }
+  const usedTokens = Math.max(decomposed, liveTotal);
+  const effectiveThreshold = typeof input.compactionThreshold === "number" && input.compactionThreshold > 0 && input.compactionThreshold < 1 ? input.compactionThreshold : input.compactionAuto ? DEFAULT_COMPACTION_THRESHOLD : null;
+  let reserveTokens = 0;
+  let freeTokens = 0;
+  if (window > 0) {
+    const remaining = Math.max(0, window - usedTokens);
+    reserveTokens = effectiveThreshold !== null ? Math.min(Math.round(window * (1 - effectiveThreshold)), remaining) : 0;
+    freeTokens = Math.max(0, window - usedTokens - reserveTokens);
+  }
+  const groups = [];
+  for (const category of CONTENT_ORDER) {
+    const tokens = raw[category];
+    if (tokens <= 0) continue;
+    groups.push({
+      category,
+      label: CONTEXT_CATEGORY_LABEL[category],
+      tokens,
+      percent: percentOf(tokens, window)
+    });
+  }
+  const meter = [...groups];
+  if (reserveTokens > 0) {
+    meter.push({
+      category: "reserve",
+      label: CONTEXT_CATEGORY_LABEL.reserve,
+      tokens: reserveTokens,
+      percent: percentOf(reserveTokens, window)
+    });
+  }
+  if (window > 0) {
+    meter.push({
+      category: "free",
+      label: CONTEXT_CATEGORY_LABEL.free,
+      tokens: freeTokens,
+      percent: percentOf(freeTokens, window)
+    });
+  }
+  return {
+    provider: input.provider ?? null,
+    model: input.model ?? null,
+    contextWindow: window,
+    contextWindowSource: input.contextWindowSource ?? null,
+    contextWindowSlots: input.contextWindowSlots ?? null,
+    usedTokens,
+    reserveTokens,
+    freeTokens,
+    percent: percentOf(usedTokens, window),
+    measured: input.measured === true && liveTotal > 0,
+    compactionThreshold: effectiveThreshold,
+    compactionAuto: input.compactionAuto === true,
+    projectPreload: input.projectPreload ?? null,
+    projectHandbookFiles: input.projectHandbookFiles ?? null,
+    toolCount: Math.max(0, Math.floor(input.toolCount ?? 0)),
+    groups,
+    meter,
+    lastCompaction: input.lastCompaction ?? null,
+    promptCache: input.promptCache ?? null
+  };
+}
+
+// src/domains/session/context-accounting.ts
+var IMAGE_CHAR_ESTIMATE = 4800;
+var TOKEN_CHARS = 4;
+var MESSAGE_OVERHEAD_TOKENS = 16;
+function ceilChars(chars) {
+  return Math.ceil(Math.max(0, chars) / TOKEN_CHARS);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function jsonLength(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "string") return value.length;
+  if (typeof value === "number" || typeof value === "boolean") return String(value).length;
+  try {
+    return JSON.stringify(value).length;
+  } catch {
+    return String(value).length;
+  }
+}
+function argsLength(value) {
+  if (value === void 0 || value === null) return 0;
+  return typeof value === "string" ? value.length : jsonLength(value);
+}
+function blockChars(block) {
+  if (typeof block === "string") return block.length;
+  if (!isRecord(block)) return jsonLength(block);
+  if (block.type === "text" && typeof block.text === "string") return block.text.length;
+  if (block.type === "thinking" && typeof block.thinking === "string") return block.thinking.length;
+  if (block.type === "image") return IMAGE_CHAR_ESTIMATE;
+  if (block.type === "toolCall") {
+    const name = typeof block.name === "string" ? block.name : "";
+    const id = typeof block.id === "string" ? block.id : "";
+    return id.length + name.length + argsLength(block.arguments ?? block.args ?? block.input);
+  }
+  if (Array.isArray(block.content)) return contentChars(block.content);
+  if (typeof block.text === "string") return block.text.length;
+  if (typeof block.thinking === "string") return block.thinking.length;
+  return jsonLength(block);
+}
+function contentChars(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return jsonLength(content);
+  return content.reduce((sum, block) => sum + blockChars(block), 0);
+}
+function messageChars(message) {
+  if (!isRecord(message)) return jsonLength(message);
+  let chars = 0;
+  chars += typeof message.role === "string" ? message.role.length : 0;
+  const payload = message.payload !== void 0 ? message.payload : message.content;
+  chars += contentChars(payload);
+  chars += typeof message.toolCallId === "string" ? message.toolCallId.length : 0;
+  chars += typeof message.toolName === "string" ? message.toolName.length : 0;
+  chars += typeof message.errorMessage === "string" ? message.errorMessage.length : 0;
+  return chars;
+}
+function toolSchemaChars(tool) {
+  if (!isRecord(tool)) return jsonLength(tool);
+  const name = typeof tool.name === "string" ? tool.name.length : 0;
+  const description = typeof tool.description === "string" ? tool.description.length : 0;
+  const parameters = jsonLength(tool.parameters);
+  return name + description + parameters;
+}
+function usageTotalTokens(usage) {
+  if (!isRecord(usage)) return null;
+  const total = usage.totalTokens;
+  if (typeof total === "number" && Number.isFinite(total) && total > 0) return total;
+  const input = typeof usage.input === "number" && Number.isFinite(usage.input) ? usage.input : 0;
+  const output = typeof usage.output === "number" && Number.isFinite(usage.output) ? usage.output : 0;
+  const cacheRead = typeof usage.cacheRead === "number" && Number.isFinite(usage.cacheRead) ? usage.cacheRead : 0;
+  const cacheWrite = typeof usage.cacheWrite === "number" && Number.isFinite(usage.cacheWrite) ? usage.cacheWrite : 0;
+  const sum = input + output + cacheRead + cacheWrite;
+  return sum > 0 ? sum : null;
+}
+function usageInvalidated(message) {
+  return message.contextUsageInvalidated === true;
+}
+function latestUsableAssistantUsage(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message?.role !== "assistant") continue;
+    if (usageInvalidated(message)) continue;
+    const stopReason = message.stopReason;
+    if (stopReason === "error" || stopReason === "aborted") continue;
+    const tokens = usageTotalTokens(message.usage);
+    if (tokens !== null) return { index: i, tokens };
+  }
+  return null;
+}
+function finiteNonNegative2(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function nestedNumber(root, path) {
+  let current = root;
+  for (const key of path) {
+    if (!isRecord(current)) return null;
+    current = current[key];
+  }
+  return finiteNonNegative2(current);
+}
+function estimateReasoningTextTokens(text) {
+  if (typeof text !== "string" || text.trim().length === 0) return null;
+  return Math.max(1, Math.round(text.length / TOKEN_CHARS));
+}
+function extractReasoningTokens(usage) {
+  if (!isRecord(usage)) return null;
+  const direct = finiteNonNegative2(usage.reasoningTokens) ?? finiteNonNegative2(usage.reasoning_tokens) ?? finiteNonNegative2(usage.reasoning);
+  if (direct !== null) return direct;
+  const paths = [
+    ["outputDetails", "reasoningTokens"],
+    ["output_details", "reasoning_tokens"],
+    ["output_tokens_details", "reasoning_tokens"],
+    ["completion_tokens_details", "reasoning_tokens"],
+    ["completionTokensDetails", "reasoningTokens"],
+    ["details", "reasoningTokens"]
+  ];
+  for (const path of paths) {
+    const value = nestedNumber(usage, path);
+    if (value !== null) return value;
+  }
+  return null;
+}
+function estimateAgentMessageTokens(message) {
+  return ceilChars(messageChars(message)) + MESSAGE_OVERHEAD_TOKENS;
+}
+function estimateAgentContextBreakdown(input) {
+  return {
+    systemPromptTokens: input.systemPrompt ? ceilChars(input.systemPrompt.length) : 0,
+    messageTokens: input.messages.reduce((sum, message) => sum + estimateAgentMessageTokens(message), 0),
+    pendingUserTokens: input.pendingUserText ? ceilChars(input.pendingUserText.length) : 0,
+    toolSchemaTokens: (input.tools ?? []).reduce((sum, tool) => sum + ceilChars(toolSchemaChars(tool)), 0)
+  };
+}
+function estimateAgentContextTokens(input) {
+  const breakdown = estimateAgentContextBreakdown(input);
+  const projection = breakdown.systemPromptTokens + breakdown.messageTokens + breakdown.pendingUserTokens + breakdown.toolSchemaTokens;
+  const usage = latestUsableAssistantUsage(input.messages);
+  if (!usage) return projection;
+  const trailingTokens = input.messages.slice(usage.index + 1).reduce((sum, message) => sum + estimateAgentMessageTokens(message), 0);
+  const anchored = usage.tokens + trailingTokens + breakdown.pendingUserTokens + breakdown.toolSchemaTokens;
+  return Math.max(projection, anchored);
+}
+function contextUsageSnapshot(tokens, contextWindow, breakdown) {
+  const window = typeof contextWindow === "number" && Number.isFinite(contextWindow) ? Math.max(0, contextWindow) : 0;
+  const base = tokens === null || tokens <= 0 || window <= 0 ? { tokens, contextWindow: window, percent: null } : { tokens, contextWindow: window, percent: Math.min(100, tokens / window * 100) };
+  return breakdown ? { ...base, breakdown } : base;
+}
+function getSnapshotsFilePath(meta) {
+  const safeMeta = {
+    ...meta,
+    cwdHash: meta.cwdHash || cwdHash(meta.cwd || process.cwd())
+  };
+  const paths = sessionPaths(safeMeta);
+  return join(dirname(paths.current), "context-snapshots.jsonl");
+}
+function persistableSnapshot(snapshot) {
+  const {
+    systemPrompt: _systemPrompt,
+    conversationMessages: _messages,
+    activeToolSchemas: _tools,
+    pendingUserInput: _pending,
+    images: _images,
+    ...slim
+  } = snapshot;
+  return slim;
+}
+function appendContextSnapshot(meta, snapshot) {
+  try {
+    const file = getSnapshotsFilePath(meta);
+    appendFileSync(file, `${JSON.stringify(persistableSnapshot(snapshot))}
+`, "utf8");
+  } catch {
+  }
+}
+function getContextSnapshots(meta) {
+  try {
+    const file = getSnapshotsFilePath(meta);
+    if (!existsSync(file)) return [];
+    const content = readFileSync(file, "utf8");
+    const snapshots = [];
+    for (const line of content.split("\n")) {
+      if (line.trim().length === 0) continue;
+      try {
+        snapshots.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return snapshots;
+  } catch {
+    return [];
+  }
+}
+function getLatestContextSnapshot(meta) {
+  const list = getContextSnapshots(meta);
+  return list.at(-1) ?? null;
+}
+function buildSnapshotCategories(inputs) {
+  const raw = {
+    system: 0,
+    tools: 0,
+    agents: 0,
+    skills: 0,
+    memory: 0,
+    project: 0,
+    messages: 0
+  };
+  if (inputs.promptSegments && inputs.promptSegments.length > 0) {
+    for (const segment of inputs.promptSegments) {
+      const cat = categoryForSegment(segment.id);
+      raw[cat] = (raw[cat] ?? 0) + segment.tokenEstimate;
+    }
+  } else if (inputs.systemPrompt) {
+    raw.system += ceilChars(inputs.systemPrompt.length);
+  }
+  if (inputs.tools) {
+    for (const tool of inputs.tools) {
+      raw.tools += ceilChars(toolSchemaChars(tool));
+    }
+  }
+  if (inputs.messages) {
+    for (const msg of inputs.messages) {
+      raw.messages += estimateAgentMessageTokens(msg);
+    }
+  }
+  const decomposed = Object.keys(raw).reduce((sum, k) => sum + (raw[k] ?? 0), 0);
+  const window = inputs.effectiveContextWindow;
+  const threshold = inputs.compactionThreshold ?? DEFAULT_COMPACTION_THRESHOLD;
+  let reserve = 0;
+  let free = 0;
+  if (window > 0) {
+    const remaining = Math.max(0, window - decomposed);
+    reserve = Math.min(Math.round(window * (1 - threshold)), remaining);
+    free = Math.max(0, window - decomposed - reserve);
+  }
+  return {
+    system: raw.system,
+    tools: raw.tools,
+    agents: raw.agents,
+    skills: raw.skills,
+    memory: raw.memory,
+    project: raw.project,
+    messages: raw.messages,
+    reserve,
+    free,
+    streaming: 0
+  };
+}
+var SNAPSHOT_SPLIT_KEYS = ["system", "tools", "agents", "skills", "memory", "project", "messages"];
+function estimatedSplitSources() {
+  const splits = {};
+  for (const key of SNAPSHOT_SPLIT_KEYS) splits[key] = "estimated";
+  return splits;
+}
+var snapshotCounter = 0;
+function nextSnapshotId() {
+  snapshotCounter += 1;
+  return `snap-${Date.now()}-${snapshotCounter.toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+function captureContextSnapshot(input) {
+  const categories = buildSnapshotCategories({
+    systemPrompt: input.systemPrompt,
+    promptSegments: input.promptSegments,
+    tools: input.activeToolSchemas,
+    messages: input.conversationMessages,
+    effectiveContextWindow: input.effectiveContextWindow,
+    compactionThreshold: input.compactionThreshold
+  });
+  return {
+    snapshotId: nextSnapshotId(),
+    sessionId: input.sessionId,
+    turnId: input.turnId,
+    providerId: input.providerId,
+    runtimeId: input.runtimeId,
+    modelId: input.modelId,
+    systemPrompt: input.systemPrompt,
+    promptSegments: input.promptSegments ? [...input.promptSegments] : void 0,
+    conversationMessages: [...input.conversationMessages],
+    activeToolSchemas: [...input.activeToolSchemas],
+    pendingUserInput: input.pendingUserInput,
+    images: input.images ? [...input.images] : void 0,
+    desiredContextWindow: input.desiredContextWindow,
+    effectiveContextWindow: input.effectiveContextWindow,
+    contextWindowSource: input.contextWindowSource,
+    categories,
+    sources: { total: "estimated", splits: estimatedSplitSources() },
+    promptHash: input.promptHash,
+    toolSignature: input.toolSignature,
+    messageRange: input.conversationMessages.length > 0 ? { start: 0, end: input.conversationMessages.length - 1 } : void 0
+  };
+}
+function snapshotInputTokens(snapshot) {
+  return SNAPSHOT_SPLIT_KEYS.reduce((sum, key) => sum + (snapshot.categories[key] ?? 0), 0);
+}
+function reconcileSnapshot(snapshot, usage) {
+  const exactInput = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
+  const exactOutput = usage.output || 0;
+  if (exactInput <= 0) {
+    const updatedCategories2 = {
+      ...snapshot.categories,
+      streaming: exactOutput
+    };
+    const window2 = snapshot.effectiveContextWindow;
+    const used2 = snapshotInputTokens(snapshot) + exactOutput;
+    let reserve2 = snapshot.categories.reserve;
+    let free2 = 0;
+    if (window2 > 0) {
+      const remaining = Math.max(0, window2 - used2);
+      reserve2 = Math.min(reserve2, remaining);
+      free2 = Math.max(0, window2 - used2 - reserve2);
+    }
+    updatedCategories2.reserve = reserve2;
+    updatedCategories2.free = free2;
+    return {
+      ...snapshot,
+      categories: updatedCategories2,
+      sources: {
+        total: "estimated",
+        splits: snapshot.sources.splits
+      }
+    };
+  }
+  const keys = SNAPSHOT_SPLIT_KEYS;
+  const currentCategories = { ...snapshot.categories };
+  const sum = keys.reduce((s, k) => s + (currentCategories[k] ?? 0), 0);
+  let normalized;
+  if (sum === 0) {
+    normalized = keys.reduce(
+      (acc, k) => {
+        acc[k] = k === "messages" ? exactInput : 0;
+        return acc;
+      },
+      {}
+    );
+  } else {
+    normalized = {};
+    let newSum = 0;
+    for (const key of keys) {
+      const val = currentCategories[key] ?? 0;
+      const norm = Math.round(val / sum * exactInput);
+      normalized[key] = norm;
+      newSum += norm;
+    }
+    const diff = exactInput - newSum;
+    if (diff !== 0) {
+      const largestKey = keys.reduce((a, b) => (normalized[a] ?? 0) >= (normalized[b] ?? 0) ? a : b);
+      normalized[largestKey] = (normalized[largestKey] ?? 0) + diff;
+    }
+  }
+  const updatedCategories = {
+    ...snapshot.categories,
+    ...normalized,
+    streaming: exactOutput
+  };
+  const window = snapshot.effectiveContextWindow;
+  const used = exactInput + exactOutput;
+  let reserve = snapshot.categories.reserve;
+  let free = 0;
+  if (window > 0) {
+    const remaining = Math.max(0, window - used);
+    reserve = Math.min(reserve, remaining);
+    free = Math.max(0, window - used - reserve);
+  }
+  updatedCategories.reserve = reserve;
+  updatedCategories.free = free;
+  const splitsSources = keys.reduce(
+    (acc, k) => {
+      acc[k] = "reconciled";
+      return acc;
+    },
+    {}
+  );
+  return {
+    ...snapshot,
+    categories: updatedCategories,
+    sources: {
+      total: "reconciled",
+      splits: splitsSources
+    }
+  };
+}
+
+export {
+  DEFAULT_COMPACTION_THRESHOLD,
+  shouldCompact,
+  AutoCompactionTrigger,
+  buildContextLedger,
+  ceilChars,
+  contentChars,
+  toolSchemaChars,
+  estimateReasoningTextTokens,
+  extractReasoningTokens,
+  estimateAgentMessageTokens,
+  estimateAgentContextBreakdown,
+  estimateAgentContextTokens,
+  contextUsageSnapshot,
+  appendContextSnapshot,
+  getLatestContextSnapshot,
+  captureContextSnapshot,
+  snapshotInputTokens,
+  reconcileSnapshot
+};
+//# sourceMappingURL=chunk-GEYXPTRF.js.map