@ycodium-ai/plugin-session-import 0.2.2526 → 0.2.2544

package/dist/index.js

@@ -171,6 +171,483 @@ import * as NodeProcess2 from "node:process";
 import * as NodePath from "node:path";
 import * as NodeProcess from "node:process";
 
+// 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 c2 = chunk[i] ?? "";
+        i += 1;
+        switch (c2) {
+          case '"':
+          case "\\":
+          case "/":
+            this.#append(c2);
+            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 c2 = chunk.charCodeAt(i);
+        if (c2 === 34 || c2 === 92 || c2 < 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;
+}
+async function* readJsonlEntries(fs, 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 record3 = parser.finish();
+      parser = null;
+      return { oversized: record3 };
+    }
+    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 fs.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 = "//?/";
@@ -199,6 +676,61 @@ var PREVIEW_LIMIT = 200;
 var MAX_SCANNED_FILES = 200;
 var MAX_ROWS = 50;
 var MAX_PARSED_LINE_BYTES = 1e6;
+var TOOL_TEXT_KEEP_CHARS = 64e3;
+var DIGEST_TEXT_KEEP_CHARS = 4096;
+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 TRANSCRIPT_FIELDS = [
+  { path: ["type"] },
+  { path: ["uuid"] },
+  { path: ["isSidechain"] },
+  { path: ["isSideChain"] },
+  { path: ["isMeta"] },
+  { path: ["parent_tool_use_id"] },
+  { path: ["timestamp"] },
+  { path: ["model"] },
+  { path: ["message", "model"] },
+  { path: ["message", "content"], scalarOnly: true },
+  { path: ["message", "content", "*", "type"] },
+  // 消息正文不截：它就是导入的内容。
+  { path: ["message", "content", "*", "text"] },
+  { path: ["message", "content", "*", "thinking"], maxChars: TOOL_TEXT_KEEP_CHARS },
+  { path: ["message", "content", "*", "id"] },
+  { path: ["message", "content", "*", "name"] },
+  { path: ["message", "content", "*", "input"], maxChars: TOOL_TEXT_KEEP_CHARS },
+  { path: ["message", "content", "*", "tool_use_id"] },
+  { path: ["message", "content", "*", "is_error"] },
+  { path: ["message", "content", "*", "status"] },
+  // tool_result 的 content 可能是字符串，也可能是块数组；块只认文本块。
+  {
+    path: ["message", "content", "*", "content"],
+    scalarOnly: true,
+    maxChars: TOOL_TEXT_KEEP_CHARS
+  },
+  { path: ["message", "content", "*", "content", "*", "type"] },
+  {
+    path: ["message", "content", "*", "content", "*", "text"],
+    maxChars: TOOL_TEXT_KEEP_CHARS
+  }
+];
+function entryRecord(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;
+  }
+}
 var TRANSCRIPT_SUFFIX = ".jsonl";
 function truncate(value) {
   const trimmed = value?.trim() ?? "";
@@ -227,18 +759,17 @@ async function readClaudeTranscriptDigest(fs, filePath) {
   let aiTitle = null;
   let turnCount = 0;
   try {
-    for await (const line of fs.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 record3;
-      try {
-        record3 = JSON.parse(line);
-      } catch {
-        continue;
-      }
+    const entries = readJsonlEntries(fs, filePath, {
+      maxLineChars: MAX_PARSED_LINE_BYTES,
+      fields: DIGEST_FIELDS
+    });
+    for await (const entry of entries) {
+      const record3 = entryRecord(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 (!record3 || typeof record3 !== "object") continue;
       const typed = record3;
       if (cwd === null && typeof typed.cwd === "string" && typed.cwd.length > 0) cwd = typed.cwd;
@@ -377,14 +908,16 @@ async function readClaudeSessionRecords(input) {
     throw new Error(`No transcript file for Claude session ${input.sessionId}.`);
   }
   const records = [];
-  for await (const line of input.fs.readLines(path)) {
-    if (line.length > MAX_PARSED_LINE_BYTES) continue;
-    if (!line.includes('"type":"user"') && !line.includes('"type":"assistant"')) continue;
-    try {
-      records.push(JSON.parse(line));
-    } catch {
-      continue;
-    }
+  const entries = readJsonlEntries(input.fs, path, {
+    maxLineChars: MAX_PARSED_LINE_BYTES,
+    fields: TRANSCRIPT_FIELDS
+  });
+  for await (const entry of entries) {
+    const record3 = entryRecord(
+      entry,
+      (line) => line.includes('"type":"user"') || line.includes('"type":"assistant"')
+    );
+    if (record3 !== void 0) records.push(record3);
   }
   return records;
 }
@@ -573,6 +1106,14 @@ var PAGE_LIMIT = 50;
 var MAX_PAGES = 10;
 var MAX_ROWS2 = 50;
 var PREVIEW_LIMIT2 = 200;
+var MAX_PARSED_LINE_CHARS = 1e6;
+var ROLLOUT_FIELDS = [
+  { path: ["type"] },
+  { path: ["payload", "id"] },
+  { path: ["payload", "session_id"] },
+  { path: ["payload", "cwd"] },
+  { path: ["payload", "model"] }
+];
 function truncate2(value) {
   const trimmed = value?.trim() ?? "";
   if (trimmed.length === 0) return null;
@@ -691,13 +1232,23 @@ async function readRolloutModel(input, rolloutPath, sameDirectory) {
   let verified = false;
   let model = null;
   try {
-    for await (const line of input.fs.readLines(resolved)) {
-      if (!line.includes('"session_meta"') && !line.includes('"turn_context"')) continue;
+    const entries = readJsonlEntries(input.fs, resolved, {
+      maxLineChars: MAX_PARSED_LINE_CHARS,
+      fields: ROLLOUT_FIELDS
+    });
+    for await (const entry of entries) {
       let record3;
-      try {
-        record3 = asRecord(JSON.parse(line));
-      } catch {
-        continue;
+      if ("oversized" in entry) {
+        record3 = asRecord(entry.oversized);
+      } else {
+        if (!entry.line.includes('"session_meta"') && !entry.line.includes('"turn_context"')) {
+          continue;
+        }
+        try {
+          record3 = asRecord(JSON.parse(entry.line));
+        } catch {
+          continue;
+        }
       }
       const payload = asRecord(record3?.payload);
       if (!record3 || !payload) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/plugin-session-import",
-  "version": "0.2.2526",
+  "version": "0.2.2544",
   "description": "Brings a session you started in a terminal into Ycodium.",
   "keywords": [
     "session-import",
@@ -20,7 +20,7 @@
     "effect": "4.0.0-beta.103",
     "esbuild": "0.28.1",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.2526"
+    "@ycodium-ai/plugin-api": "0.2.2544"
   },
   "ycodium": {
     "plugin": "./dist/index.js",