@freesyntax/notch-cli 0.5.19 → 0.5.21

package/dist/{chunk-6M6CXXWR.js → chunk-PKZKVOAN.js}

@@ -1,5 +1,6 @@
 // src/agent/compression.ts
 import { generateText } from "ai";
+import { createHash } from "crypto";
 function estimateTokens(messages) {
   let chars = 0;
   for (const msg of messages) {
@@ -15,6 +16,112 @@ function estimateTokens(messages) {
   }
   return Math.ceil(chars / 4);
 }
+var InMemoryArtifactStore = class {
+  map = /* @__PURE__ */ new Map();
+  put(key, value) {
+    this.map.set(key, value);
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+};
+var globalArtifactStore = new InMemoryArtifactStore();
+function setArtifactStore(store) {
+  const prev = globalArtifactStore;
+  globalArtifactStore = store;
+  return () => {
+    globalArtifactStore = prev;
+  };
+}
+function getArtifactStore() {
+  return globalArtifactStore;
+}
+var ARTIFACT_URI_PREFIX = "notch-artifact://";
+function artifactKey(content) {
+  return createHash("sha1").update(content).digest("hex").slice(0, 16);
+}
+function makeArtifactUri(key) {
+  return `${ARTIFACT_URI_PREFIX}${key}`;
+}
+function parseArtifactUri(text) {
+  const match = text.match(/notch-artifact:\/\/([a-f0-9]{8,64})/);
+  return match ? match[1] : null;
+}
+var BUDGET_TOOL_RESULT_MAX = 3e3;
+var BUDGET_PREVIEW_CHARS = 400;
+function budgetReduce(messages, opts = {}) {
+  const maxChars = opts.maxToolResultChars ?? BUDGET_TOOL_RESULT_MAX;
+  const previewChars = opts.previewChars ?? BUDGET_PREVIEW_CHARS;
+  const keepLastN = opts.keepLastN ?? 4;
+  const store = opts.store ?? globalArtifactStore;
+  const toolIdx = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool") toolIdx.push(i);
+  }
+  const eligibleUpTo = toolIdx.length - keepLastN;
+  if (eligibleUpTo <= 0) return { messages, stashed: 0, savedChars: 0 };
+  const eligible = new Set(toolIdx.slice(0, eligibleUpTo));
+  let stashed = 0;
+  let savedChars = 0;
+  const out = messages.map((msg, idx) => {
+    if (msg.role !== "tool" || !eligible.has(idx)) return msg;
+    if (!Array.isArray(msg.content)) return msg;
+    let touched = false;
+    const newContent = msg.content.map((block) => {
+      const b = block;
+      if (b.type !== "tool-result") return block;
+      const resultStr = typeof b.result === "string" ? b.result : JSON.stringify(b.result ?? "");
+      if (resultStr.length <= maxChars) return block;
+      const key = artifactKey(resultStr);
+      try {
+        void store.put(key, resultStr);
+      } catch {
+        return block;
+      }
+      const preview = resultStr.slice(0, previewChars);
+      const replacement = `${preview}
+... [+${resultStr.length - previewChars} chars stashed at ${makeArtifactUri(key)}]`;
+      savedChars += resultStr.length - replacement.length;
+      stashed++;
+      touched = true;
+      return {
+        ...b,
+        result: replacement
+      };
+    });
+    if (!touched) return msg;
+    return { ...msg, content: newContent };
+  });
+  return { messages: out, stashed, savedChars };
+}
+function snip(messages, opts = {}) {
+  const keepStart = opts.keepStart ?? 1;
+  const keepRecent = opts.keepRecent ?? 6;
+  const trigger = opts.triggerMiddleCount ?? 40;
+  const snipCount = opts.snipCount ?? 10;
+  if (messages.length < keepStart + keepRecent + trigger) {
+    return { messages, snipped: 0 };
+  }
+  const head = messages.slice(0, keepStart);
+  const tail = messages.slice(-keepRecent);
+  const middle = messages.slice(keepStart, messages.length - keepRecent);
+  let cut = Math.min(snipCount, middle.length);
+  while (cut < middle.length && middle[cut].role === "tool") cut++;
+  const dropped = middle.slice(0, cut);
+  const kept = middle.slice(cut);
+  if (dropped.length === 0) return { messages, snipped: 0 };
+  const marker = {
+    role: "user",
+    content: `[snip: ${dropped.length} older messages removed by age]`
+  };
+  return {
+    messages: [...head, marker, ...kept, ...tail],
+    snipped: dropped.length
+  };
+}
 var TEXT_BLOCK_MAX = 8e3;
 function microCompact(messages) {
   const result = [];
@@ -35,6 +142,48 @@ function microCompact(messages) {
   }
   return result;
 }
+function contextCollapse(messages, opts = {}) {
+  const keepStart = opts.keepStart ?? 1;
+  const keepRecent = opts.keepRecent ?? 4;
+  const trigger = opts.triggerMiddleCount ?? 12;
+  const store = opts.store ?? globalArtifactStore;
+  if (messages.length < keepStart + keepRecent + trigger) {
+    return { messages, collapsed: false };
+  }
+  const head = messages.slice(0, keepStart);
+  const middle = messages.slice(keepStart, messages.length - keepRecent);
+  const tail = messages.slice(-keepRecent);
+  if (middle.length === 0) return { messages, collapsed: false };
+  let key;
+  try {
+    const serialized = JSON.stringify(middle);
+    key = artifactKey(serialized);
+    void store.put(key, serialized);
+  } catch {
+  }
+  const summaryText = buildDeterministicSummary(middle);
+  const ref = key ? ` (originals at ${makeArtifactUri(key)})` : "";
+  const summaryMarker = {
+    role: "user",
+    content: `[Context collapsed \u2014 ${middle.length} messages summarized${ref}]
+${summaryText}`
+  };
+  return {
+    messages: [...head, summaryMarker, ...tail],
+    collapsed: true,
+    artifactKey: key
+  };
+}
+async function restoreCollapsedSpan(artifactKeyOrUri, store = globalArtifactStore) {
+  const key = artifactKeyOrUri.startsWith(ARTIFACT_URI_PREFIX) ? artifactKeyOrUri.slice(ARTIFACT_URI_PREFIX.length) : artifactKeyOrUri;
+  const raw = await store.get(key);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
 var RESERVE_BUFFER_TOKENS = 13e3;
 var MAX_SUMMARY_TOKENS = 2e4;
 var MAX_COMPRESSION_FAILURES = 3;
@@ -180,10 +329,19 @@ ${firstContent}`
   return { messages: compressed, compressed: true };
 }
 async function autoCompress(messages, model, contextWindow, onCompress) {
-  let result = microCompact(messages);
   const threshold = (contextWindow - RESERVE_BUFFER_TOKENS) * 0.75;
+  let result = budgetReduce(messages).messages;
+  result = snip(result).messages;
+  result = microCompact(result);
   let tokens = estimateTokens(result);
   if (tokens < threshold) return result;
+  const collapsed = contextCollapse(result);
+  if (collapsed.collapsed) {
+    onCompress?.();
+    result = collapsed.messages;
+    tokens = estimateTokens(result);
+  }
+  if (tokens < threshold) return result;
   const auto = await autoCompactSummarize(result, { model, contextWindow });
   if (auto.compressed) {
     onCompress?.();
@@ -198,6 +356,48 @@ async function autoCompress(messages, model, contextWindow, onCompress) {
   }
   return result;
 }
+async function autoCompressWithStats(messages, model, contextWindow) {
+  const stats = {
+    budgetStashed: 0,
+    snipped: 0,
+    collapsed: false,
+    autoCompacted: false,
+    fullCompacted: false
+  };
+  const threshold = (contextWindow - RESERVE_BUFFER_TOKENS) * 0.75;
+  const br = budgetReduce(messages);
+  let result = br.messages;
+  stats.budgetStashed = br.stashed;
+  const sn = snip(result);
+  result = sn.messages;
+  stats.snipped = sn.snipped;
+  result = microCompact(result);
+  let tokens = estimateTokens(result);
+  if (tokens >= threshold) {
+    const collapsed = contextCollapse(result);
+    if (collapsed.collapsed) {
+      result = collapsed.messages;
+      stats.collapsed = true;
+      tokens = estimateTokens(result);
+    }
+  }
+  if (tokens >= threshold) {
+    const auto = await autoCompactSummarize(result, { model, contextWindow });
+    if (auto.compressed) {
+      result = auto.messages;
+      stats.autoCompacted = true;
+      tokens = estimateTokens(result);
+    }
+  }
+  if (tokens >= threshold) {
+    const full = await fullCompact(result, model);
+    if (full.compressed) {
+      result = full.messages;
+      stats.fullCompacted = true;
+    }
+  }
+  return { messages: result, stats };
+}
 async function compressHistory(messages, opts) {
   const result = await autoCompactSummarize(messages, opts);
   return result;
@@ -205,9 +405,17 @@ async function compressHistory(messages, opts) {
 
 export {
   estimateTokens,
+  setArtifactStore,
+  getArtifactStore,
+  parseArtifactUri,
+  budgetReduce,
+  snip,
   microCompact,
+  contextCollapse,
+  restoreCollapsedSpan,
   autoCompactSummarize,
   fullCompact,
   autoCompress,
+  autoCompressWithStats,
   compressHistory
 };

package/dist/chunk-QKM27RHS.js

@@ -0,0 +1,198 @@
+// src/session/rollout.ts
+import fsp from "fs/promises";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var ROLLOUT_DIR = path.join(os.homedir(), ".notch", "rollouts");
+async function ensureDir() {
+  await fsp.mkdir(ROLLOUT_DIR, { recursive: true });
+}
+function rolloutPath(id) {
+  return path.join(ROLLOUT_DIR, `${id}.jsonl`);
+}
+function indexPath(id) {
+  return path.join(ROLLOUT_DIR, `${id}.idx.json`);
+}
+function generateSessionId() {
+  const d = /* @__PURE__ */ new Date();
+  const stamp = d.toISOString().slice(0, 10).replace(/-/g, "") + "-" + d.toISOString().slice(11, 16).replace(":", "");
+  const rand = crypto.randomBytes(3).toString("hex");
+  return `${stamp}-${rand}`;
+}
+var Rollout = class {
+  constructor(id) {
+    this.id = id;
+  }
+  id;
+  fd = null;
+  seq = 0;
+  idx = {
+    lastSeq: -1,
+    messageCount: 0,
+    branches: {},
+    activeStream: null
+  };
+  async openNew(header) {
+    await ensureDir();
+    this.fd = await fsp.open(rolloutPath(this.id), "a");
+    await this.writeRecord({
+      type: "header",
+      payload: { id: this.id, project: header.project, model: header.model, createdAt: (/* @__PURE__ */ new Date()).toISOString(), schema: 1 }
+    });
+  }
+  async openExisting() {
+    await ensureDir();
+    this.idx = await readIndex(this.id);
+    this.seq = this.idx.lastSeq + 1;
+    this.fd = await fsp.open(rolloutPath(this.id), "a");
+  }
+  async close() {
+    await this.saveIndex();
+    if (this.fd) {
+      await this.fd.close();
+      this.fd = null;
+    }
+    try {
+      const { upsertSessionIndexEntry } = await import("./session-index-SSGOOZXK.js");
+      await upsertSessionIndexEntry(this.id);
+    } catch {
+    }
+  }
+  async writeRecord(partial) {
+    if (!this.fd) throw new Error("rollout not open");
+    const rec = { seq: this.seq++, ts: Date.now(), ...partial };
+    const line = JSON.stringify(rec) + "\n";
+    await this.fd.write(line);
+    this.idx.lastSeq = rec.seq;
+    if (rec.type === "user-message" || rec.type === "assistant-message") {
+      this.idx.messageCount++;
+      if (rec.parent && rec.msgId) {
+        (this.idx.branches[rec.parent] ??= []).push(rec.msgId);
+      }
+    }
+    if (rec.type === "active-stream") {
+      this.idx.activeStream = rec.streamId ?? null;
+    } else if (rec.type === "turn-end" || rec.type === "error") {
+      this.idx.activeStream = null;
+    }
+    return rec;
+  }
+  append(record) {
+    return this.writeRecord(record);
+  }
+  async flush() {
+    if (this.fd) await this.fd.sync();
+    await this.saveIndex();
+  }
+  async saveIndex() {
+    await fsp.writeFile(indexPath(this.id), JSON.stringify(this.idx, null, 2));
+  }
+  get activeStream() {
+    return this.idx.activeStream;
+  }
+  get index() {
+    return this.idx;
+  }
+};
+async function readRollout(id) {
+  const raw = await fsp.readFile(rolloutPath(id), "utf-8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+async function readIndex(id) {
+  try {
+    const raw = await fsp.readFile(indexPath(id), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    const records = await readRollout(id);
+    const idx = { lastSeq: -1, messageCount: 0, branches: {}, activeStream: null };
+    for (const r of records) {
+      idx.lastSeq = r.seq;
+      if (r.type === "user-message" || r.type === "assistant-message") {
+        idx.messageCount++;
+        if (r.parent && r.msgId) (idx.branches[r.parent] ??= []).push(r.msgId);
+      }
+      if (r.type === "active-stream") idx.activeStream = r.streamId ?? null;
+      else if (r.type === "turn-end" || r.type === "error") idx.activeStream = null;
+    }
+    await fsp.writeFile(indexPath(id), JSON.stringify(idx, null, 2)).catch(() => {
+    });
+    return idx;
+  }
+}
+async function listRollouts() {
+  try {
+    const entries = await fsp.readdir(ROLLOUT_DIR);
+    const files = entries.filter((e) => e.endsWith(".jsonl"));
+    const out = [];
+    for (const f of files) {
+      const id = f.replace(/\.jsonl$/, "");
+      const stat = await fsp.stat(path.join(ROLLOUT_DIR, f));
+      const idx = await readIndex(id).catch(() => ({ messageCount: 0 }));
+      let project;
+      let model;
+      try {
+        const first = (await fsp.readFile(path.join(ROLLOUT_DIR, f), "utf-8")).split("\n", 1)[0];
+        if (first) {
+          const header = JSON.parse(first);
+          project = header.payload?.project;
+          model = header.payload?.model;
+        }
+      } catch {
+      }
+      out.push({ id, updated: stat.mtimeMs, messageCount: idx.messageCount, project, model });
+    }
+    return out.sort((a, b) => b.updated - a.updated);
+  } catch {
+    return [];
+  }
+}
+function rebuildMessagesFromRollout(records) {
+  const msgs = [];
+  let current = null;
+  for (const r of records) {
+    if (r.type === "user-message") {
+      if (current) {
+        msgs.push(current);
+        current = null;
+      }
+      msgs.push({ role: "user", content: r.payload?.content ?? "" });
+    } else if (r.type === "text-delta") {
+      const delta = r.payload?.content ?? "";
+      if (!current) current = { role: "assistant", content: "" };
+      current.content += delta;
+    } else if (r.type === "assistant-message") {
+      if (current) {
+        msgs.push(current);
+        current = null;
+      }
+      msgs.push({ role: "assistant", content: r.payload?.content ?? "" });
+    } else if (r.type === "turn-end" && current) {
+      msgs.push(current);
+      current = null;
+    }
+  }
+  if (current) msgs.push(current);
+  return msgs;
+}
+function hasActiveStream(idx) {
+  return !!idx.activeStream;
+}
+
+export {
+  rolloutPath,
+  generateSessionId,
+  Rollout,
+  readRollout,
+  readIndex,
+  listRollouts,
+  rebuildMessagesFromRollout,
+  hasActiveStream
+};