tianshu-harness 3.23.0

package/dist/chunk-EGEI2RQA.js

@@ -0,0 +1,1167 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/workers/cpu-tasks.ts
+init_esm_shims();
+
+// node_modules/diff/libesm/index.js
+init_esm_shims();
+
+// node_modules/diff/libesm/diff/base.js
+init_esm_shims();
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return void 0;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = void 0;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = void 0;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(void 0);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path, added, removed, oldPosInc, options) {
+    const last = path.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i = 0; i < array.length; i++) {
+      if (array[i]) {
+        ret.push(array[i]);
+      }
+    }
+    return ret;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  castInput(value, options) {
+    return value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            const oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/diff/libesm/diff/line.js
+init_esm_shims();
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes("\n")) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes("\n")) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith("\n")) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith("\n")) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+};
+var lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, "\n");
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    const line = linesAndNewlines[i];
+    if (i % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+init_esm_shims();
+function needsQuoting(s) {
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] < " " || s[i] > "~" || s[i] === '"' || s[i] === "\\") {
+      return true;
+    }
+  }
+  return false;
+}
+function quoteFileNameIfNeeded(s) {
+  if (!needsQuoting(s)) {
+    return s;
+  }
+  let result = '"';
+  const bytes = new TextEncoder().encode(s);
+  let i = 0;
+  while (i < bytes.length) {
+    const b = bytes[i];
+    if (b === 7) {
+      result += "\\a";
+    } else if (b === 8) {
+      result += "\\b";
+    } else if (b === 9) {
+      result += "\\t";
+    } else if (b === 10) {
+      result += "\\n";
+    } else if (b === 11) {
+      result += "\\v";
+    } else if (b === 12) {
+      result += "\\f";
+    } else if (b === 13) {
+      result += "\\r";
+    } else if (b === 34) {
+      result += '\\"';
+    } else if (b === 92) {
+      result += "\\\\";
+    } else if (b >= 32 && b <= 126) {
+      result += String.fromCharCode(b);
+    } else {
+      result += "\\" + b.toString(8).padStart(3, "0");
+    }
+    i++;
+  }
+  result += '"';
+  return result;
+}
+var INCLUDE_HEADERS = {
+  includeIndex: true,
+  includeUnderline: true,
+  includeFileHeaders: true
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  if (!options) {
+    optionsObj = {};
+  } else if (typeof options === "function") {
+    optionsObj = { callback: options };
+  } else {
+    optionsObj = options;
+  }
+  if (typeof optionsObj.context === "undefined") {
+    optionsObj.context = 4;
+  }
+  const context = optionsObj.context;
+  if (optionsObj.newlineIsToken) {
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  }
+  if (!optionsObj.callback) {
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  } else {
+    const { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      const patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  }
+  function diffLinesResultToPatch(diff) {
+    if (!diff) {
+      return;
+    }
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    const hunks = [];
+    let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      const current = diff[i], lines = current.lines || splitLines(current.value);
+      current.lines = lines;
+      if (current.added || current.removed) {
+        if (!oldRangeStart) {
+          const prev = diff[i - 1];
+          oldRangeStart = oldLine;
+          newRangeStart = newLine;
+          if (prev) {
+            curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+            oldRangeStart -= curRange.length;
+            newRangeStart -= curRange.length;
+          }
+        }
+        for (const line of lines) {
+          curRange.push((current.added ? "+" : "-") + line);
+        }
+        if (current.added) {
+          newLine += lines.length;
+        } else {
+          oldLine += lines.length;
+        }
+      } else {
+        if (oldRangeStart) {
+          if (lines.length <= context * 2 && i < diff.length - 2) {
+            for (const line of contextLines(lines)) {
+              curRange.push(line);
+            }
+          } else {
+            const contextSize = Math.min(lines.length, context);
+            for (const line of contextLines(lines.slice(0, contextSize))) {
+              curRange.push(line);
+            }
+            const hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk);
+            oldRangeStart = 0;
+            newRangeStart = 0;
+            curRange = [];
+          }
+        }
+        oldLine += lines.length;
+        newLine += lines.length;
+      }
+    }
+    for (const hunk of hunks) {
+      for (let i = 0; i < hunk.lines.length; i++) {
+        if (hunk.lines[i].endsWith("\n")) {
+          hunk.lines[i] = hunk.lines[i].slice(0, -1);
+        } else {
+          hunk.lines.splice(i + 1, 0, "\");
+          i++;
+        }
+      }
+    }
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch, headerOptions) {
+  var _a, _b, _c, _d, _e, _f;
+  if (!headerOptions) {
+    headerOptions = INCLUDE_HEADERS;
+  }
+  if (Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders && !patch.every((p) => p.isGit)) {
+      throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
+    }
+    return patch.map((p) => formatPatch(p, headerOptions)).join("\n");
+  }
+  const ret = [];
+  if (patch.isGit) {
+    headerOptions = INCLUDE_HEADERS;
+    if (!patch.oldFileName) {
+      throw new Error("oldFileName must be specified for Git patches");
+    }
+    if (!patch.newFileName) {
+      throw new Error("newFileName must be specified for Git patches");
+    }
+    let gitOldName = patch.oldFileName;
+    let gitNewName = patch.newFileName;
+    if (patch.isCreate && gitOldName === "/dev/null") {
+      gitOldName = gitNewName.replace(/^b\//, "a/");
+    } else if (patch.isDelete && gitNewName === "/dev/null") {
+      gitNewName = gitOldName.replace(/^a\//, "b/");
+    }
+    ret.push("diff --git " + quoteFileNameIfNeeded(gitOldName) + " " + quoteFileNameIfNeeded(gitNewName));
+    if (patch.isDelete) {
+      ret.push("deleted file mode " + ((_a = patch.oldMode) !== null && _a !== void 0 ? _a : "100644"));
+    }
+    if (patch.isCreate) {
+      ret.push("new file mode " + ((_b = patch.newMode) !== null && _b !== void 0 ? _b : "100644"));
+    }
+    if (patch.oldMode && patch.newMode && !patch.isDelete && !patch.isCreate) {
+      ret.push("old mode " + patch.oldMode);
+      ret.push("new mode " + patch.newMode);
+    }
+    if (patch.isRename) {
+      ret.push("rename from " + quoteFileNameIfNeeded(((_c = patch.oldFileName) !== null && _c !== void 0 ? _c : "").replace(/^a\//, "")));
+      ret.push("rename to " + quoteFileNameIfNeeded(((_d = patch.newFileName) !== null && _d !== void 0 ? _d : "").replace(/^b\//, "")));
+    }
+    if (patch.isCopy) {
+      ret.push("copy from " + quoteFileNameIfNeeded(((_e = patch.oldFileName) !== null && _e !== void 0 ? _e : "").replace(/^a\//, "")));
+      ret.push("copy to " + quoteFileNameIfNeeded(((_f = patch.newFileName) !== null && _f !== void 0 ? _f : "").replace(/^b\//, "")));
+    }
+  } else {
+    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName && patch.oldFileName !== void 0) {
+      ret.push("Index: " + patch.oldFileName);
+    }
+    if (headerOptions.includeUnderline) {
+      ret.push("===================================================================");
+    }
+  }
+  const hasHunks = patch.hunks.length > 0;
+  if (headerOptions.includeFileHeaders && patch.oldFileName !== void 0 && patch.newFileName !== void 0 && (!patch.isGit || hasHunks)) {
+    ret.push("--- " + quoteFileNameIfNeeded(patch.oldFileName) + (patch.oldHeader ? "	" + patch.oldHeader : ""));
+    ret.push("+++ " + quoteFileNameIfNeeded(patch.newFileName) + (patch.newHeader ? "	" + patch.newHeader : ""));
+  }
+  for (let i = 0; i < patch.hunks.length; i++) {
+    const hunk = patch.hunks[i];
+    const oldStart = hunk.oldLines === 0 ? hunk.oldStart - 1 : hunk.oldStart;
+    const newStart = hunk.newLines === 0 ? hunk.newStart - 1 : hunk.newStart;
+    ret.push("@@ -" + oldStart + "," + hunk.oldLines + " +" + newStart + "," + hunk.newLines + " @@");
+    for (const line of hunk.lines) {
+      ret.push(line);
+    }
+  }
+  return ret.join("\n") + "\n";
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options === "function") {
+    options = { callback: options };
+  }
+  if (!(options === null || options === void 0 ? void 0 : options.callback)) {
+    const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    if (!patchObj) {
+      return;
+    }
+    return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
+  } else {
+    const { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      if (!patchObj) {
+        callback(void 0);
+      } else {
+        callback(formatPatch(patchObj, options.headerOptions));
+      }
+    } }));
+  }
+}
+function splitLines(text) {
+  const hasTrailingNl = text.endsWith("\n");
+  const result = text.split("\n").map((line) => line + "\n");
+  if (hasTrailingNl) {
+    result.pop();
+  } else {
+    result.push(result.pop().slice(0, -1));
+  }
+  return result;
+}
+
+// src/workers/cpu-tasks.ts
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+
+// src/tools/line-endings.ts
+init_esm_shims();
+import { extname } from "path";
+import { open } from "fs/promises";
+var REQUIRED_EOL = {
+  ".bat": "crlf",
+  ".cmd": "crlf"
+};
+function detectEol(text) {
+  let crlf = 0;
+  let lf = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) {
+      if (i > 0 && text.charCodeAt(i - 1) === 13) crlf++;
+      else lf++;
+    }
+  }
+  if (crlf === 0 && lf === 0) return null;
+  return crlf > lf ? "crlf" : "lf";
+}
+function toLf(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function applyEol(text, eol) {
+  const lf = toLf(text);
+  return eol === "crlf" ? lf.replace(/\n/g, "\r\n") : lf;
+}
+function requiredEol(filePath) {
+  return REQUIRED_EOL[extname(filePath).toLowerCase()] ?? null;
+}
+function chooseEol(filePath, existingEol, defaultEol = "lf") {
+  return requiredEol(filePath) ?? existingEol ?? defaultEol;
+}
+async function detectFileEol(filePath, sampleBytes = 65536) {
+  let fh;
+  try {
+    fh = await open(filePath, "r");
+    const buf = Buffer.alloc(sampleBytes);
+    const head = await fh.read(buf, 0, sampleBytes, 0);
+    const headEol = detectEol(buf.toString("utf-8", 0, head.bytesRead));
+    if (headEol !== null) return headEol;
+    const size = (await fh.stat()).size;
+    if (size <= sampleBytes) return null;
+    const tail = await fh.read(buf, 0, sampleBytes, size - sampleBytes);
+    return detectEol(buf.toString("utf-8", 0, tail.bytesRead));
+  } catch {
+    return null;
+  } finally {
+    await fh?.close().catch(() => {
+    });
+  }
+}
+
+// src/tools/ast-grep-napi.ts
+init_esm_shims();
+function isModuleNotFound(err) {
+  const code = err?.code;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}
+function flattenCause(err) {
+  const parts = [];
+  let cur = err;
+  for (let depth = 0; cur instanceof Error && depth < 4; depth++) {
+    parts.push(cur.message);
+    cur = cur.cause;
+  }
+  return [...new Set(parts)].join("\n  \u21B3 cause: ");
+}
+async function loadAstGrepNapi(importer = () => import("@ast-grep/napi")) {
+  try {
+    return { ok: true, napi: await importer() };
+  } catch (err) {
+    const detail = err instanceof Error ? flattenCause(err) : String(err);
+    if (isModuleNotFound(err)) {
+      return {
+        ok: false,
+        message: `\u9519\u8BEF\uFF1A\u672A\u5B89\u88C5 @ast-grep/napi\uFF08\u6216\u7F3A\u5C11\u5F53\u524D\u5E73\u53F0\u7684\u539F\u751F\u5B50\u5305\uFF09\u3002\u8BF7\u8FD0\u884C\uFF1Anpm install @ast-grep/napi
+\u539F\u59CB\u9519\u8BEF\uFF1A${detail}`
+      };
+    }
+    return {
+      ok: false,
+      message: `\u9519\u8BEF\uFF1A@ast-grep/napi \u5DF2\u5B89\u88C5\u4F46\u52A0\u8F7D\u5931\u8D25\u2014\u2014\u539F\u751F\u63D2\u4EF6\u65E0\u6CD5\u521D\u59CB\u5316\uFF0C\u5E38\u89C1\u4E8E\u5E73\u53F0/\u67B6\u6784\u4E0D\u5339\u914D\u3001\u6C99\u7BB1\u963B\u65AD dlopen\u3001\u6216\u5B89\u88C5\u6B8B\u7F3A\u3002
+\u539F\u59CB\u9519\u8BEF\uFF1A${detail}
+\u672C\u6B21\u8BF7\u6539\u7528 grep \u5B8C\u6210\u641C\u7D22\uFF1B\u4FEE\u590D\u53EF\u8BD5\uFF1Anpm rebuild @ast-grep/napi`
+    };
+  }
+}
+
+// src/tools/ast-shared.ts
+init_esm_shims();
+import { existsSync, readdirSync, lstatSync } from "fs";
+import { resolve, extname as extname2, join } from "path";
+
+// src/platform/restricted-paths.ts
+init_esm_shims();
+var WINDOWS_RESTRICTED_PATTERNS = [
+  // Known ACL-restricted subdirs under AppData\Local — exact match only.
+  // Source: Windows ACL-restricted directories observed in production telemetry.
+  /AppData[\\/]Local[\\/]ElevatedDiagnostics([\\/]|$)/i,
+  /AppData[\\/]Local[\\/]Packages([\\/]|$)/i,
+  /AppData[\\/]Local[\\/]Microsoft[\\/]Windows[\\/]Notifications([\\/]|$)/i,
+  /AppData[\\/]Local[\\/]Microsoft[\\/]Windows[\\/]INetCache([\\/]|$)/i,
+  /AppData[\\/]Local[\\/]Microsoft[\\/]Windows[\\/]Temporary Internet Files([\\/]|$)/i,
+  /AppData[\\/]Local[\\/]Microsoft[\\/]WindowsApps([\\/]|$)/i,
+  /Windows[\\/]System32[\\/]config([\\/]|$)/i,
+  /Windows[\\/]CSC([\\/]|$)/i,
+  /(^|[\\/])System Volume Information([\\/]|$)/i,
+  /(^|[\\/])\$Recycle\.?Bin([\\/]|$)/i,
+  // matches $RECYCLE.BIN, $Recycle.Bin
+  /(^|[\\/])Config\.Msi([\\/]|$)/i
+];
+var MACOS_RESTRICTED_PATTERNS = [
+  /(^|\/)\.Spotlight-V100([/]|$)/i,
+  /(^|\/)\.fseventsd([/]|$)/i,
+  /(^|\/)\.TemporaryItems([/]|$)/i,
+  /(^|\/)\.DocumentRevisions-V100([/]|$)/i,
+  /(^|\/)\.Trashes([/]|$)/i
+];
+var LINUX_RESTRICTED_PATTERNS = [
+  /^\/proc\/\d+\/(fd|map_files|task\/\d+\/fd)([/]|$)/,
+  /^\/sys\/kernel\/debug([/]|$)/,
+  /^\/sys\/fs\/cgroup([/]|$)/,
+  /(^|\/)lost\+found([/]|$)/
+];
+var ALL_RESTRICTED = [
+  ...WINDOWS_RESTRICTED_PATTERNS,
+  ...MACOS_RESTRICTED_PATTERNS,
+  ...LINUX_RESTRICTED_PATTERNS
+];
+function isRestrictedPath(path, code) {
+  if (code !== "EPERM" && code !== "EACCES") return false;
+  if (!path) return false;
+  return ALL_RESTRICTED.some((re) => re.test(path));
+}
+
+// src/tools/scan-excludes.ts
+init_esm_shims();
+var SCAN_EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  "build",
+  "target",
+  "__pycache__",
+  "TianshuData"
+]);
+function isScanExcludedDir(name) {
+  return SCAN_EXCLUDE_DIRS.has(name);
+}
+
+// src/tools/ast-shared.ts
+var LANG_BY_EXT = {
+  ".ts": "TypeScript",
+  ".tsx": "Tsx",
+  ".js": "JavaScript",
+  ".jsx": "Tsx",
+  ".html": "Html",
+  ".css": "Css",
+  // Dynamic languages — registered via registerDynamicLanguage, parsed by name
+  // (lowercase), NOT via napi.Lang.X. See DYNAMIC_LANGS + ensureDynamicLangsRegistered.
+  ".py": "python",
+  ".pyi": "python",
+  ".json": "json",
+  ".jsonc": "json"
+};
+var DYNAMIC_LANGS = /* @__PURE__ */ new Set(["python", "json"]);
+function isDynamicLang(langName) {
+  return DYNAMIC_LANGS.has(langName);
+}
+var dynamicLangsRegistered = false;
+async function ensureDynamicLangsRegistered(napi) {
+  if (dynamicLangsRegistered) return;
+  dynamicLangsRegistered = true;
+  const registration = {};
+  try {
+    const pythonMod = await import("@ast-grep/lang-python");
+    registration.python = pythonMod.default ?? pythonMod;
+  } catch {
+  }
+  try {
+    const jsonMod = await import("@ast-grep/lang-json");
+    registration.json = jsonMod.default ?? jsonMod;
+  } catch {
+  }
+  if (Object.keys(registration).length > 0) {
+    try {
+      napi.registerDynamicLanguage(registration);
+    } catch {
+    }
+  }
+}
+function inferLang(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  return LANG_BY_EXT[ext] ?? null;
+}
+function resolveLang(explicit, filePath) {
+  if (explicit) return explicit;
+  return inferLang(filePath);
+}
+var MAX_PARSE_FILE_BYTES = 1024 * 1024;
+function looksBinary(buf) {
+  const n = Math.min(buf.length, 8192);
+  for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
+  return false;
+}
+function parseSkipReason(filePath, buf, maxBytes = MAX_PARSE_FILE_BYTES) {
+  if (buf.length > maxBytes) {
+    const mb = (buf.length / 1024 / 1024).toFixed(1);
+    return `${filePath}: \u8DF3\u8FC7\uFF08${mb}MB \u8D85\u8FC7 ${maxBytes / 1024 / 1024}MB \u89E3\u6790\u4E0A\u9650\uFF09`;
+  }
+  if (looksBinary(buf)) return `${filePath}: \u8DF3\u8FC7\uFF08\u4E8C\u8FDB\u5236\u5185\u5BB9\uFF09`;
+  return null;
+}
+function buildLangMap(napi) {
+  return {
+    TypeScript: napi.Lang.TypeScript,
+    Tsx: napi.Lang.Tsx,
+    JavaScript: napi.Lang.JavaScript,
+    Html: napi.Lang.Html,
+    Css: napi.Lang.Css
+  };
+}
+var BASE_EXCLUDE_DIRS = [
+  ...SCAN_EXCLUDE_DIRS,
+  ".rivet",
+  "out",
+  ".turbo",
+  "coverage",
+  ".nyc_output"
+];
+function resolveExcludeDirs() {
+  const env = process.env.RIVET_AST_EXCLUDE;
+  if (!env) return new Set(BASE_EXCLUDE_DIRS);
+  const extra = env.split(",").map((s) => s.trim()).filter(Boolean);
+  return /* @__PURE__ */ new Set([...BASE_EXCLUDE_DIRS, ...extra]);
+}
+var MAX_FILES = 5e3;
+var MAX_DEPTH = 25;
+var YIELD_EVERY_ENTRIES = 500;
+async function collectFiles(searchPath) {
+  const excludeDirs = resolveExcludeDirs();
+  const abs = resolve(searchPath);
+  if (!existsSync(abs)) return [];
+  const stat = lstatSync(abs);
+  if (stat.isFile()) return [abs];
+  if (!stat.isDirectory()) return [];
+  const files = [];
+  let entriesSinceYield = 0;
+  const walk = async (dir, depth) => {
+    if (files.length >= MAX_FILES || depth > MAX_DEPTH) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      const e = err;
+      if (depth > 0 && isRestrictedPath(String(e.path ?? e.message ?? ""), e.code ?? "")) return;
+      throw err;
+    }
+    for (const entry of entries) {
+      if (files.length >= MAX_FILES) return;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (excludeDirs.has(entry.name)) continue;
+        await walk(full, depth + 1);
+      } else if (entry.isFile()) {
+        files.push(full);
+      }
+      if (++entriesSinceYield >= YIELD_EVERY_ENTRIES) {
+        entriesSinceYield = 0;
+        await new Promise((r) => setImmediate(r));
+      }
+    }
+  };
+  await walk(abs, 0);
+  return files;
+}
+function collectMetaVarNames(pattern) {
+  const seen = /* @__PURE__ */ new Set();
+  const vars = [];
+  const re = /\$(\$\$)?([A-Za-z_][A-Za-z0-9_]*)/g;
+  let m;
+  while ((m = re.exec(pattern)) !== null) {
+    const name = m[2];
+    if (!seen.has(name)) {
+      seen.add(name);
+      vars.push({ name, multi: m[1] === "$$" });
+    }
+  }
+  return vars;
+}
+function resolveRuleOrPattern(pattern) {
+  try {
+    const parsed = JSON.parse(pattern);
+    if (parsed && typeof parsed === "object" && "rule" in parsed) {
+      return { ruleOrPattern: parsed, isRuleObject: true };
+    }
+  } catch {
+  }
+  return { ruleOrPattern: pattern, isRuleObject: false };
+}
+var AST_SCAN_SOFT_MS_DEFAULT = 3e4;
+function astScanSoftMs() {
+  const parsed = Number(process.env.RIVET_AST_SCAN_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : AST_SCAN_SOFT_MS_DEFAULT;
+}
+function astScanUnavailable(reason) {
+  return `\u9519\u8BEF\uFF1AAST \u89E3\u6790\u4E0D\u53EF\u7528\uFF08${reason}\uFF09\u3002
+\u89E3\u6790\u5728 worker \u7EBF\u7A0B\u6267\u884C\u4EE5\u907F\u514D\u51BB\u7ED3\u4E3B\u7EBF\u7A0B\uFF1B\u4E0D\u53EF\u7528\u65F6\u4E0D\u4F1A\u56DE\u9000\u4E3B\u7EBF\u7A0B\u89E3\u6790\u3002
+\u672C\u6B21\u8BF7\u6539\u7528 grep \u5B8C\u6210\u641C\u7D22\uFF0C\u6216\u7F29\u5C0F paths \u540E\u91CD\u8BD5\u3002`;
+}
+
+// src/workers/cpu-tasks.ts
+function diffUnifiedRaw(relPath, before, after, timeout) {
+  return createTwoFilesPatch(relPath, relPath, before, after, "", "", {
+    context: 3,
+    timeout
+  });
+}
+function diffStructuredRaw(before, after, timeout) {
+  const patch = structuredPatch("a", "a", before, after, "", "", {
+    context: 0,
+    timeout
+  });
+  if (!patch) return void 0;
+  return { hunks: patch.hunks };
+}
+function diffLinesRaw(oldContent, newContent, timeout) {
+  return diffLines(oldContent, newContent, { timeout });
+}
+function parseEventsTailRaw(text, maxEvents) {
+  const all = parseEventsJsonlRaw(text);
+  if (all.length === 0) {
+    return { events: [], diskFirstSeq: 0, lastSeq: 0, artifactIds: [], total: 0 };
+  }
+  const artifactIds = [];
+  for (const e of all) {
+    if (e.type === "artifact") artifactIds.push(String(e.data.id));
+  }
+  return {
+    // delegation 事件豁免截尾（M1：stale 对账与回放依赖它们完整；被截尾的
+    // 早期 running 节点对账不可见，回放永久卡「运行中」）。与
+    // session-manager.trimEventRing 同语义——尾部窗口 + 保留 delegation。
+    events: tailExemptDelegation(all, maxEvents),
+    diskFirstSeq: all[0].seq,
+    lastSeq: all[all.length - 1].seq,
+    artifactIds,
+    total: all.length
+  };
+}
+function tailExemptDelegation(events, maxEvents) {
+  if (events.length <= maxEvents) return events;
+  const overflow = events.length - maxEvents;
+  const kept = [];
+  let dropped = 0;
+  for (const e of events) {
+    if (dropped < overflow && e.type !== "delegation") {
+      dropped++;
+      continue;
+    }
+    kept.push(e);
+  }
+  return kept;
+}
+function parseEventsJsonlRaw(text) {
+  const events = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed.seq === "number" && typeof parsed.type === "string") {
+        events.push(parsed);
+      }
+    } catch {
+    }
+  }
+  events.sort((a, b) => a.seq - b.seq);
+  return events;
+}
+var _esbuild;
+async function esbuildTransformRaw(content, options) {
+  if (_esbuild === void 0) {
+    try {
+      const req = createRequire(import.meta.url);
+      _esbuild = req("esbuild");
+    } catch {
+      _esbuild = null;
+    }
+  }
+  if (!_esbuild) throw new Error("esbuild unavailable in worker");
+  await _esbuild.transform(content, options);
+  return true;
+}
+async function astScanRaw(args) {
+  const result = {
+    matches: [],
+    filesScanned: 0,
+    errors: [],
+    skipped: [],
+    degraded: []
+  };
+  const loaded = await loadAstGrepNapi();
+  if (!loaded.ok) {
+    result.loadError = loaded.message;
+    return result;
+  }
+  const napi = loaded.napi;
+  const langMap = buildLangMap(napi);
+  await ensureDynamicLangsRegistered(napi);
+  const { ruleOrPattern } = resolveRuleOrPattern(args.pattern);
+  const metaVarDefs = args.includeMeta ? collectMetaVarNames(args.pattern) : [];
+  for (const filePath of args.files) {
+    if (result.matches.length >= args.limit) break;
+    const langStr = resolveLang(args.explicitLang, filePath);
+    if (!langStr) {
+      result.errors.push(`${filePath}: \u4E0D\u652F\u6301\u7684\u8BED\u8A00\uFF08\u8BE5\u6269\u5C55\u540D\u65E0\u8BED\u6CD5\uFF09`);
+      continue;
+    }
+    const langValue = isDynamicLang(langStr) ? langStr : langMap[langStr];
+    if (typeof langValue !== "string") {
+      result.errors.push(`${filePath}: LANG_MAP \u5BF9 "${langStr}" \u8FD4\u56DE\u4E86\u975E\u5B57\u7B26\u4E32\u2014\u2014\u53EF\u80FD\u662F @ast-grep/napi API \u53D8\u66F4`);
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync(filePath);
+    } catch {
+      result.errors.push(`${filePath}: \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6`);
+      continue;
+    }
+    const skipReason = parseSkipReason(filePath, buf, args.maxBytes);
+    if (skipReason) {
+      result.skipped.push(skipReason);
+      continue;
+    }
+    const source = buf.toString("utf-8");
+    result.filesScanned++;
+    let root;
+    try {
+      root = napi.parse(langValue, source).root();
+    } catch {
+      result.errors.push(`${filePath}: \u89E3\u6790\u9519\u8BEF`);
+      continue;
+    }
+    const errorNodes = root.findAll({ rule: { kind: "ERROR" } });
+    if (errorNodes.length > 0) {
+      result.degraded.push(`${filePath}: ${errorNodes.length} \u5904\u9519\u8BEF\u6062\u590D\u533A`);
+    }
+    let found;
+    try {
+      found = root.findAll(ruleOrPattern);
+    } catch {
+      result.errors.push(`${filePath}: pattern \u7F16\u8BD1\u9519\u8BEF`);
+      continue;
+    }
+    for (const node of found) {
+      if (result.matches.length >= args.limit) break;
+      const range = node.range();
+      const match = {
+        file: filePath,
+        line: range.start.line + 1,
+        column: range.start.column + 1,
+        matchText: node.text()
+      };
+      if (args.includeMeta) {
+        match.metaVariables = {};
+        for (const { name, multi } of metaVarDefs) {
+          if (multi) {
+            const mvs = node.getMultipleMatches(name);
+            if (mvs && mvs.length > 0) {
+              const texts = mvs.map((n) => n.text());
+              const nodeCount = texts.length;
+              const lineCount = texts.reduce((sum, t) => sum + t.split("\n").length, 0);
+              const firstLine = texts[0].split("\n")[0].trim().slice(0, 50);
+              match.metaVariables[name] = `${nodeCount}n/${lineCount}L: ${firstLine}`;
+            }
+          } else {
+            const mv = node.getMatch(name);
+            if (mv) match.metaVariables[name] = mv.text().slice(0, 120);
+          }
+        }
+      }
+      result.matches.push(match);
+    }
+  }
+  return result;
+}
+function interpolateTemplate(template, node) {
+  let result = template;
+  const vars = collectMetaVarNames(template);
+  for (const { name, multi } of vars.sort((a, b) => b.name.length - a.name.length)) {
+    if (multi) {
+      const mvs = node.getMultipleMatches(name);
+      if (mvs && mvs.length > 0) {
+        result = result.replace(new RegExp(`\\$\\$\\${name}`, "g"), mvs.map((n) => n.text()).join(""));
+      }
+    } else {
+      const mv = node.getMatch(name);
+      if (mv) {
+        result = result.replace(new RegExp(`\\$${name}\\b`, "g"), mv.text());
+      }
+    }
+  }
+  return result;
+}
+async function astEditComputeRaw(args) {
+  const result = { files: [], errors: [] };
+  const loaded = await loadAstGrepNapi();
+  if (!loaded.ok) {
+    result.loadError = loaded.message;
+    return result;
+  }
+  const napi = loaded.napi;
+  const langMap = buildLangMap(napi);
+  await ensureDynamicLangsRegistered(napi);
+  for (const filePath of args.files) {
+    const langStr = resolveLang(args.explicitLang, filePath);
+    if (!langStr) {
+      result.errors.push(`${filePath}: \u4E0D\u652F\u6301\u7684\u8BED\u8A00`);
+      continue;
+    }
+    const langValue = isDynamicLang(langStr) ? langStr : langMap[langStr];
+    if (typeof langValue !== "string") {
+      result.errors.push(`${filePath}: LANG_MAP \u5BF9 "${langStr}" \u8FD4\u56DE\u4E86\u975E\u5B57\u7B26\u4E32\u2014\u2014\u53EF\u80FD\u662F @ast-grep/napi API \u53D8\u66F4`);
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync(filePath);
+    } catch {
+      result.errors.push(`${filePath}: \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6`);
+      continue;
+    }
+    const skipReason = parseSkipReason(filePath, buf, args.maxBytes);
+    if (skipReason) {
+      result.errors.push(skipReason);
+      continue;
+    }
+    const source = buf.toString("utf-8");
+    const changes = [];
+    let currentSource = source;
+    for (const op of args.ops) {
+      let root;
+      try {
+        root = napi.parse(langValue, currentSource).root();
+      } catch {
+        result.errors.push(`${filePath}: \u64CD\u4F5C "${op.find.slice(0, 40)}" \u89E3\u6790\u9519\u8BEF`);
+        break;
+      }
+      const errorNodes = root.findAll({ rule: { kind: "ERROR" } });
+      if (errorNodes.length > 0) {
+        result.errors.push(`${filePath}: \u89E3\u6790\u9519\u8BEF\uFF08${errorNodes.length} \u4E2A\u8BED\u6CD5\u9519\u8BEF\uFF09`);
+        break;
+      }
+      const { ruleOrPattern: pattern } = resolveRuleOrPattern(op.find);
+      let found;
+      try {
+        found = root.findAll(pattern);
+      } catch {
+        result.errors.push(`${filePath}: \u6A21\u5F0F "${op.find.slice(0, 40)}" \u7F16\u8BD1\u9519\u8BEF`);
+        continue;
+      }
+      if (found.length === 0) continue;
+      const edits = [];
+      const count = Math.min(found.length, args.limit);
+      for (let i = 0; i < count; i++) {
+        const node = found[i];
+        const before = node.text();
+        const range = node.range();
+        changes.push({ before, after: interpolateTemplate(op.replace, node), line: range.start.line + 1 });
+        edits.push({ startPos: range.start.index, endPos: range.end.index, insertedText: interpolateTemplate(op.replace, node) });
+      }
+      edits.sort((a, b) => a.startPos - b.startPos);
+      const deduped = [];
+      let skippedOverlap = 0;
+      for (const e of edits) {
+        const prev = deduped[deduped.length - 1];
+        if (prev && e.startPos < prev.endPos) {
+          skippedOverlap++;
+          continue;
+        }
+        deduped.push(e);
+      }
+      if (skippedOverlap > 0) {
+        result.errors.push(`${filePath}: \u5DF2\u8DF3\u8FC7 ${skippedOverlap} \u4E2A\u91CD\u53E0\u5339\u914D\uFF08"${op.find.slice(0, 40)}"\uFF09\u2014\u2014\u5D4C\u5957\u8303\u56F4\u4F1A\u7834\u574F\u7F16\u8F91`);
+      }
+      try {
+        currentSource = root.commitEdits(deduped);
+      } catch {
+        result.errors.push(`${filePath}: \u64CD\u4F5C "${op.find.slice(0, 40)}" \u7684 commitEdits \u5931\u8D25`);
+        break;
+      }
+    }
+    if (changes.length > 0) {
+      let syntaxOk = true;
+      if (!args.dryRun) {
+        try {
+          const finalRoot = napi.parse(langValue, currentSource).root();
+          const finalErrors = finalRoot.findAll({ rule: { kind: "ERROR" } });
+          if (finalErrors.length > 0) {
+            result.errors.push(`${filePath}: \u7F16\u8F91\u540E\u8BED\u6CD5\u9519\u8BEF\uFF08${finalErrors.length} \u4E2A ERROR \u8282\u70B9\uFF09\u2014\u2014\u6587\u4EF6\u672A\u5199\u5165\uFF0C\u66F4\u6539\u5DF2\u4E22\u5F03`);
+            syntaxOk = false;
+          }
+        } catch {
+          result.errors.push(`${filePath}: \u7F16\u8F91\u540E\u89E3\u6790\u5931\u8D25\u2014\u2014\u6587\u4EF6\u672A\u5199\u5165\uFF0C\u66F4\u6539\u5DF2\u4E22\u5F03`);
+          syntaxOk = false;
+        }
+      }
+      result.files.push({ file: filePath, newSource: currentSource, changes, syntaxOk, existingEol: detectEol(source) });
+    }
+  }
+  return result;
+}
+
+export {
+  isRestrictedPath,
+  SCAN_EXCLUDE_DIRS,
+  isScanExcludedDir,
+  MAX_PARSE_FILE_BYTES,
+  collectFiles,
+  resolveRuleOrPattern,
+  astScanSoftMs,
+  astScanUnavailable,
+  detectEol,
+  toLf,
+  applyEol,
+  chooseEol,
+  detectFileEol,
+  diffUnifiedRaw,
+  diffStructuredRaw,
+  diffLinesRaw,
+  parseEventsTailRaw,
+  parseEventsJsonlRaw,
+  esbuildTransformRaw,
+  astScanRaw,
+  astEditComputeRaw
+};