@ycodium-ai/agent-claude 0.2.2544 → 0.2.2566

package/dist/index.js

@@ -21153,6 +21153,492 @@ import * as NodeOS6 from "node:os";
 import * as NodePath6 from "node:path";
 import * as NodeProcess from "node:process";
 
+// ../../packages/ycodium-jsonl-stream/src/jsonlStream.ts
+var DEFAULT_MAX_RETAINED_CHARS = 8e6;
+var MAX_DEPTH = 128;
+var MAX_KEY_CHARS = 256;
+var MAX_BARE_CHARS = 64;
+var NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/u;
+var OversizedRecordParser = class {
+  #fields;
+  #budget;
+  #retained = 0;
+  #malformed = false;
+  #done = false;
+  #result = void 0;
+  #stack = [];
+  // 词法状态。
+  #inString = false;
+  #stringIsKey = false;
+  #escape = false;
+  #unicodeLeft = 0;
+  #unicodeValue = 0;
+  #bare = "";
+  // 当前字符串的保留规则与累积。
+  #strRetain = false;
+  #strCap = void 0;
+  #strHead = "";
+  #strTail = "";
+  #strLength = 0;
+  #key = "";
+  #keyOverflow = false;
+  // 值之间的位置。
+  #expectKey = false;
+  #expectColon = false;
+  #expectComma = false;
+  #expectValue = true;
+  constructor(fields, maxRetainedChars = DEFAULT_MAX_RETAINED_CHARS) {
+    this.#fields = fields;
+    this.#budget = maxRetainedChars;
+  }
+  write(chunk) {
+    if (this.#malformed) return;
+    try {
+      this.#consume(chunk);
+    } catch (cause) {
+      if (cause instanceof MalformedRecord) {
+        this.#malformed = true;
+        return;
+      }
+      throw cause;
+    }
+  }
+  /** 完整且合法才返回记录；其余（含空行）返回 `undefined`。 */
+  finish() {
+    if (this.#malformed) return void 0;
+    try {
+      if (this.#bare.length > 0) this.#finishBare();
+    } catch (cause) {
+      if (cause instanceof MalformedRecord) return void 0;
+      throw cause;
+    }
+    if (!this.#done || this.#inString || this.#result === SKIPPED) return void 0;
+    return this.#result;
+  }
+  #fail() {
+    throw new MalformedRecord();
+  }
+  #charge(chars) {
+    this.#retained += chars;
+    if (this.#retained > this.#budget) this.#fail();
+  }
+  #consume(chunk) {
+    const n = chunk.length;
+    let i = 0;
+    while (i < n) {
+      if (this.#inString) {
+        i = this.#consumeString(chunk, i);
+        continue;
+      }
+      const c = chunk.charCodeAt(i);
+      if (this.#bare.length > 0) {
+        if (isBareChar(c)) {
+          if (this.#bare.length >= MAX_BARE_CHARS) this.#fail();
+          this.#bare += chunk[i];
+          i += 1;
+          continue;
+        }
+        this.#finishBare();
+      }
+      i += 1;
+      if (c === 32 || c === 9 || c === 10 || c === 13) continue;
+      if (this.#done) this.#fail();
+      switch (c) {
+        case 123:
+          this.#requireValue();
+          this.#openContainer(false);
+          break;
+        case 91:
+          this.#requireValue();
+          this.#openContainer(true);
+          break;
+        case 125:
+          this.#closeContainer(false);
+          break;
+        case 93:
+          this.#closeContainer(true);
+          break;
+        case 44:
+          this.#comma();
+          break;
+        case 58:
+          if (!this.#expectColon) this.#fail();
+          this.#expectColon = false;
+          this.#expectValue = true;
+          break;
+        case 34:
+          this.#openString();
+          break;
+        default:
+          if (isBareChar(c)) {
+            this.#requireValue();
+            this.#bare = chunk[i - 1] ?? "";
+          } else this.#fail();
+      }
+    }
+  }
+  #top() {
+    return this.#stack[this.#stack.length - 1];
+  }
+  #requireValue() {
+    if (!this.#expectValue) this.#fail();
+    this.#expectValue = false;
+  }
+  /** 当前要读的值（刚要开始）落在什么模式；`isContainer` 决定 scalarOnly 清单项是否适用。 */
+  #childMode(isContainer) {
+    const parent = this.#top();
+    if (parent === void 0) return this.#classify([], isContainer);
+    if (parent.mode === "skip") return { mode: "skip", cap: void 0, path: [] };
+    if (parent.mode === "keep") return { mode: "keep", cap: parent.cap, path: [] };
+    const segment = parent.isArray ? String(parent.index) : parent.key ?? "";
+    if (parent.skipValue) return { mode: "skip", cap: void 0, path: [] };
+    return this.#classify([...parent.path, segment], isContainer);
+  }
+  #classify(path, isContainer) {
+    let descend = false;
+    for (const field of this.#fields) {
+      const fieldPath = field.path;
+      if (fieldPath.length <= path.length) {
+        if (field.scalarOnly === true && (isContainer || fieldPath.length !== path.length)) {
+          continue;
+        }
+        if (matchesPrefix(fieldPath, path, fieldPath.length)) {
+          return { mode: "keep", cap: field.maxChars, path };
+        }
+      } else if (matchesPrefix(fieldPath, path, path.length)) {
+        descend = true;
+      }
+    }
+    return { mode: descend ? "descend" : "skip", cap: void 0, path };
+  }
+  #openContainer(isArray) {
+    if (this.#stack.length >= MAX_DEPTH) this.#fail();
+    const { mode, cap, path } = this.#childMode(true);
+    const keeping = mode !== "skip";
+    let target = null;
+    if (keeping) {
+      this.#charge(16);
+      target = isArray ? [] : {};
+    }
+    this.#stack.push({ isArray, mode, path, cap, target, key: null, skipValue: false, index: 0 });
+    this.#expectValue = isArray;
+    this.#expectKey = !isArray;
+    this.#expectComma = false;
+    this.#expectColon = false;
+  }
+  #closeContainer(isArray) {
+    const top = this.#top();
+    if (top === void 0 || top.isArray !== isArray) this.#fail();
+    if (!this.#expectComma && top.index > 0) this.#fail();
+    if (this.#expectColon || !isArray && this.#expectValue) this.#fail();
+    this.#stack.pop();
+    this.#expectValue = false;
+    this.#expectKey = false;
+    this.#expectColon = false;
+    this.#expectComma = true;
+    this.#store(top.target ?? SKIPPED);
+  }
+  #comma() {
+    const top = this.#top();
+    if (top === void 0 || !this.#expectComma) this.#fail();
+    this.#expectComma = false;
+    if (top.isArray) {
+      this.#expectValue = true;
+    } else {
+      this.#expectKey = true;
+    }
+  }
+  /** 一个值读完：交给外层容器，或成为整条记录。 */
+  #store(value) {
+    const parent = this.#top();
+    if (parent === void 0) {
+      this.#result = value;
+      this.#done = true;
+      this.#expectComma = false;
+      return;
+    }
+    this.#expectComma = true;
+    if (parent.isArray) {
+      parent.index += 1;
+      if (parent.target !== null && value !== SKIPPED) {
+        parent.target.push(value);
+        this.#charge(8);
+      }
+      return;
+    }
+    parent.index += 1;
+    const key = parent.key;
+    parent.key = null;
+    parent.skipValue = false;
+    if (parent.target !== null && value !== SKIPPED && key !== null) {
+      Object.defineProperty(parent.target, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+      this.#charge(key.length + 8);
+    }
+  }
+  #openString() {
+    const parent = this.#top();
+    const asKey = parent !== void 0 && !parent.isArray && this.#expectKey;
+    if (!asKey) this.#requireValue();
+    this.#inString = true;
+    this.#stringIsKey = asKey;
+    this.#escape = false;
+    this.#unicodeLeft = 0;
+    this.#strLength = 0;
+    this.#strHead = "";
+    this.#strTail = "";
+    this.#key = "";
+    if (asKey) {
+      this.#keyOverflow = false;
+      this.#strRetain = true;
+      this.#strCap = void 0;
+      return;
+    }
+    const { mode, cap } = this.#childMode(false);
+    this.#strRetain = mode === "keep";
+    this.#strCap = cap;
+  }
+  /** 字符串里的一个解码后片段；按保留规则累积。 */
+  #append(text) {
+    if (text.length === 0) return;
+    if (this.#stringIsKey) {
+      if (this.#keyOverflow) return;
+      this.#key += text;
+      if (this.#key.length > MAX_KEY_CHARS) {
+        this.#keyOverflow = true;
+        this.#key = "";
+      }
+      return;
+    }
+    this.#strLength += text.length;
+    if (!this.#strRetain) return;
+    const cap = this.#strCap;
+    if (cap === void 0) {
+      this.#strHead += text;
+      this.#charge(text.length);
+      return;
+    }
+    if (this.#strHead.length < cap) {
+      const room = cap - this.#strHead.length;
+      this.#strHead += text.slice(0, room);
+      text = text.slice(room);
+      if (text.length === 0) return;
+    }
+    this.#strTail += text;
+    if (this.#strTail.length > cap * 2) this.#strTail = this.#strTail.slice(-cap);
+  }
+  #consumeString(chunk, start) {
+    const n = chunk.length;
+    let i = start;
+    while (i < n) {
+      if (this.#unicodeLeft > 0) {
+        const digit = hexValue(chunk.charCodeAt(i));
+        if (digit < 0) this.#fail();
+        this.#unicodeValue = this.#unicodeValue * 16 + digit;
+        this.#unicodeLeft -= 1;
+        i += 1;
+        if (this.#unicodeLeft === 0) this.#append(String.fromCharCode(this.#unicodeValue));
+        continue;
+      }
+      if (this.#escape) {
+        this.#escape = false;
+        const c3 = chunk[i] ?? "";
+        i += 1;
+        switch (c3) {
+          case '"':
+          case "\\":
+          case "/":
+            this.#append(c3);
+            break;
+          case "b":
+            this.#append("\b");
+            break;
+          case "f":
+            this.#append("\f");
+            break;
+          case "n":
+            this.#append("\n");
+            break;
+          case "r":
+            this.#append("\r");
+            break;
+          case "t":
+            this.#append("	");
+            break;
+          case "u":
+            this.#unicodeLeft = 4;
+            this.#unicodeValue = 0;
+            break;
+          default:
+            this.#fail();
+        }
+        continue;
+      }
+      const runStart = i;
+      while (i < n) {
+        const c3 = chunk.charCodeAt(i);
+        if (c3 === 34 || c3 === 92 || c3 < 32) break;
+        i += 1;
+      }
+      if (i > runStart) this.#append(chunk.slice(runStart, i));
+      if (i >= n) break;
+      const c = chunk.charCodeAt(i);
+      i += 1;
+      if (c === 92) {
+        this.#escape = true;
+      } else if (c === 34) {
+        this.#inString = false;
+        this.#endString();
+        return i;
+      } else {
+        this.#fail();
+      }
+    }
+    return i;
+  }
+  #endString() {
+    if (this.#stringIsKey) {
+      const parent = this.#top();
+      if (parent === void 0) this.#fail();
+      parent.key = this.#key;
+      parent.skipValue = this.#keyOverflow;
+      this.#key = "";
+      this.#expectKey = false;
+      this.#expectColon = true;
+      return;
+    }
+    if (!this.#strRetain) {
+      this.#store(SKIPPED);
+      return;
+    }
+    const cap = this.#strCap;
+    let text = this.#strHead;
+    if (cap !== void 0) {
+      let tail = this.#strTail;
+      if (tail.length > cap) tail = tail.slice(-cap);
+      if (this.#strLength > text.length + tail.length) {
+        if (isHighSurrogate(text.charCodeAt(text.length - 1))) text = text.slice(0, -1);
+        if (isLowSurrogate(tail.charCodeAt(0))) tail = tail.slice(1);
+        const omitted = this.#strLength - text.length - tail.length;
+        text = `${text}
+[\u2026 ${omitted} chars omitted \u2026]
+${tail}`;
+      } else {
+        text = `${text}${tail}`;
+      }
+      this.#charge(text.length);
+    }
+    this.#strHead = "";
+    this.#strTail = "";
+    this.#store(text);
+  }
+  #finishBare() {
+    const text = this.#bare;
+    this.#bare = "";
+    const { mode } = this.#childMode(false);
+    let value;
+    if (text === "true") value = true;
+    else if (text === "false") value = false;
+    else if (text === "null") value = null;
+    else if (NUMBER_PATTERN.test(text)) value = Number(text);
+    else this.#fail();
+    this.#store(mode === "keep" ? value : SKIPPED);
+  }
+};
+var SKIPPED = /* @__PURE__ */ Symbol("skipped");
+var MalformedRecord = class extends Error {
+};
+function isBareChar(c) {
+  return c >= 48 && c <= 57 || // 0-9
+  c >= 97 && c <= 122 || // a-z
+  c >= 65 && c <= 90 || // A-Z
+  c === 43 || c === 45 || c === 46;
+}
+function hexValue(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  if (c >= 97 && c <= 102) return c - 97 + 10;
+  if (c >= 65 && c <= 70) return c - 65 + 10;
+  return -1;
+}
+var isHighSurrogate = (c) => c >= 55296 && c <= 56319;
+var isLowSurrogate = (c) => c >= 56320 && c <= 57343;
+function matchesPrefix(pattern, path, length) {
+  for (let index = 0; index < length; index += 1) {
+    const expected = pattern[index];
+    if (expected !== "*" && expected !== path[index]) return false;
+  }
+  return true;
+}
+function jsonlEntryRecord(entry, accepts) {
+  if ("oversized" in entry) return entry.oversized;
+  if (!accepts(entry.line)) return void 0;
+  try {
+    return JSON.parse(entry.line);
+  } catch {
+    return void 0;
+  }
+}
+async function* readJsonlEntries(fs2, path, options) {
+  const decoder = new TextDecoder("utf-8");
+  let pieces = [];
+  let pending = 0;
+  let parser = null;
+  const startOversized = () => {
+    const next = new OversizedRecordParser(options.fields, options.maxRetainedChars);
+    for (const piece of pieces) next.write(piece);
+    pieces = [];
+    pending = 0;
+    return next;
+  };
+  const append = (text) => {
+    if (text.length === 0) return;
+    if (parser !== null) {
+      parser.write(text);
+      return;
+    }
+    pieces.push(text);
+    pending += text.length;
+    if (pending > options.maxLineChars) parser = startOversized();
+  };
+  const takeLine = () => {
+    if (parser !== null) {
+      const record = parser.finish();
+      parser = null;
+      return { oversized: record };
+    }
+    if (pending === 0) return null;
+    let line = pieces.length === 1 ? pieces[0] ?? "" : pieces.join("");
+    pieces = [];
+    pending = 0;
+    if (line.endsWith("\r")) line = line.slice(0, -1);
+    return line.length === 0 ? null : { line };
+  };
+  const feed = function* (text) {
+    let from = 0;
+    while (from <= text.length) {
+      const newline = text.indexOf("\n", from);
+      if (newline < 0) {
+        append(text.slice(from));
+        return;
+      }
+      append(text.slice(from, newline));
+      const entry = takeLine();
+      if (entry !== null) yield entry;
+      from = newline + 1;
+    }
+  };
+  for await (const chunk of fs2.createReadStream(path)) {
+    yield* feed(decoder.decode(chunk, { stream: true }));
+  }
+  yield* feed(decoder.decode());
+  const last = takeLine();
+  if (last !== null) yield last;
+}
+
 // src/sessionScope.ts
 var EXTENDED_LENGTH_UNC = "//?/UNC/";
 var EXTENDED_LENGTH = "//?/";
@@ -21182,6 +21668,34 @@ var MAX_SCANNED_FILES = 200;
 var MAX_ROWS = 50;
 var MAX_PARSED_LINE_BYTES = 1e6;
 var TRANSCRIPT_SUFFIX = ".jsonl";
+var DIGEST_TEXT_KEEP_CHARS = 4096;
+var fileSource = {
+  createReadStream: (path) => NodeFS3.createReadStream(path)
+};
+var DIGEST_FIELDS = [
+  { path: ["type"] },
+  { path: ["cwd"] },
+  { path: ["isSidechain"] },
+  { path: ["customTitle"] },
+  { path: ["aiTitle"] },
+  { path: ["message", "model"] },
+  { path: ["message", "content"], scalarOnly: true, maxChars: DIGEST_TEXT_KEEP_CHARS },
+  { path: ["message", "content", "*", "type"] },
+  { path: ["message", "content", "*", "text"], maxChars: DIGEST_TEXT_KEEP_CHARS }
+];
+var RECORD_FIELDS = [
+  { path: ["type"] },
+  { path: ["uuid"] },
+  { path: ["isSidechain"] },
+  { path: ["isSideChain"] },
+  { path: ["isMeta"] },
+  { path: ["parent_tool_use_id"] },
+  { path: ["timestamp"] },
+  { path: ["message", "model"] },
+  { path: ["message", "content"], scalarOnly: true },
+  { path: ["message", "content", "*", "type"] },
+  { path: ["message", "content", "*", "text"] }
+];
 function truncate(value) {
   const trimmed = value?.trim() ?? "";
   if (trimmed.length === 0) return null;
@@ -21201,11 +21715,7 @@ function textFromContent(content) {
   }
   return parts.join("\n\n").trim();
 }
-function readLines(filePath) {
-  const raw = NodeFS3.readFileSync(filePath, "utf8");
-  return raw.split(/\r?\n/);
-}
-function readClaudeTranscriptDigest(filePath) {
+async function readClaudeTranscriptDigest(filePath) {
   let cwd = null;
   let model = null;
   let preview = null;
@@ -21213,18 +21723,17 @@ function readClaudeTranscriptDigest(filePath) {
   let aiTitle = null;
   let turnCount = 0;
   try {
-    for (const line of readLines(filePath)) {
-      const isUser = line.includes('"type":"user"');
-      const wantsAssistant = model === null && line.includes('"type":"assistant"');
-      const isTitle = line.includes('"custom-title"') || line.includes('"ai-title"');
-      if (!isUser && !wantsAssistant && !isTitle) continue;
-      if (line.length > MAX_PARSED_LINE_BYTES) continue;
-      let record;
-      try {
-        record = JSON.parse(line);
-      } catch {
-        continue;
-      }
+    const entries = readJsonlEntries(fileSource, filePath, {
+      maxLineChars: MAX_PARSED_LINE_BYTES,
+      fields: DIGEST_FIELDS
+    });
+    for await (const entry of entries) {
+      const record = jsonlEntryRecord(entry, (line) => {
+        const isUser = line.includes('"type":"user"');
+        const wantsAssistant = model === null && line.includes('"type":"assistant"');
+        const isTitle = line.includes('"custom-title"') || line.includes('"ai-title"');
+        return isUser || wantsAssistant || isTitle;
+      });
       if (!record || typeof record !== "object") continue;
       const typed = record;
       if (cwd === null && typeof typed.cwd === "string" && typed.cwd.length > 0) cwd = typed.cwd;
@@ -21322,7 +21831,7 @@ function readClaudeLiveSessionIds(configDir) {
   }
   return live;
 }
-function scanClaudeSessions(input) {
+async function scanClaudeSessions(input) {
   let root;
   try {
     root = NodeFS3.statSync(input.transcriptDir);
@@ -21340,7 +21849,7 @@ function scanClaudeSessions(input) {
   const rows = [];
   for (const file of files) {
     if (rows.length >= MAX_ROWS) break;
-    const digest = readClaudeTranscriptDigest(file.path);
+    const digest = await readClaudeTranscriptDigest(file.path);
     if (digest === null || digest.cwd === null) continue;
     if (!isWithinDirectory(digest.cwd, input.directory, caseInsensitive)) continue;
     rows.push({
@@ -21392,7 +21901,7 @@ function isRecord4(value) {
 function nonempty(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
 }
-function readClaudeSessionRecord(input) {
+async function readClaudeSessionRecord(input) {
   const path = resolveTranscriptPath({
     transcriptDir: input.transcriptDir,
     sessionId: input.nativeSessionId,
@@ -21404,15 +21913,15 @@ function readClaudeSessionRecord(input) {
   const messages = [];
   const byUuid = /* @__PURE__ */ new Map();
   let model = null;
-  for (const line of readLines(path)) {
-    if (line.length > MAX_PARSED_LINE_BYTES) continue;
-    if (!line.includes('"type":"user"') && !line.includes('"type":"assistant"')) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      continue;
-    }
+  const entries = readJsonlEntries(fileSource, path, {
+    maxLineChars: MAX_PARSED_LINE_BYTES,
+    fields: RECORD_FIELDS
+  });
+  for await (const entry of entries) {
+    const parsed = jsonlEntryRecord(
+      entry,
+      (line) => line.includes('"type":"user"') || line.includes('"type":"assistant"')
+    );
     if (!isRecord4(parsed)) continue;
     if (parsed.type !== "user" && parsed.type !== "assistant") continue;
     if (parsed.isSidechain === true || parsed.isSideChain === true || parsed.isMeta === true)
@@ -25500,7 +26009,7 @@ ${stderr}`);
       scan: async (input) => {
         const roots = resolveTranscriptRoots(input.directory);
         return {
-          candidates: scanClaudeSessions({
+          candidates: await scanClaudeSessions({
             transcriptDir: roots.transcriptDir,
             configDir: roots.configDir,
             directory: input.directory ?? ""
@@ -25509,7 +26018,7 @@ ${stderr}`);
       },
       read: async (input) => {
         const roots = resolveTranscriptRoots(input.cwd);
-        return readClaudeSessionRecord({
+        return await readClaudeSessionRecord({
           transcriptDir: roots.transcriptDir,
           nativeSessionId: input.nativeSessionId,
           cwd: input.cwd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-claude",
-  "version": "0.2.2544",
+  "version": "0.2.2566",
   "description": "Claude executor: Claude Code CLI via @anthropic-ai/claude-agent-sdk.",
   "keywords": [
     "ycodium",
@@ -24,7 +24,8 @@
     "@types/node": "24.12.4",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.2544",
+    "@ycodium-ai/plugin-api": "0.2.2566",
+    "ycodium-jsonl-stream": "0.0.0",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {