tianshu-harness 3.23.0

package/dist/chunk-Z3QE7TZM.js

@@ -0,0 +1,72 @@
+#!/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/tools/net/playwright-driver.ts
+init_esm_shims();
+import { createRequire } from "module";
+var PLAYWRIGHT_CORE_INSTALL_HINT = [
+  "CLI \u5B89\u88C5\u7528\u6237\uFF1Anpm install -g tianshu-harness\uFF08\u91CD\u65B0\u5B89\u88C5\u4EE5\u8865\u9F50\u4F9D\u8D56\uFF09\uFF0C",
+  "  \u6216\u5F53\u524D\u9879\u76EE\u5185\uFF1Anpm i playwright-core",
+  "  \u4ED3\u5E93\u5185\u5F00\u53D1\uFF1Anpm i playwright-core",
+  "  \u684C\u9762\u7AEF\uFF1A\u68C0\u67E5 dist/node_modules/playwright-core \u662F\u5426\u5B8C\u6574"
+].join("\n");
+function resolvePlaywrightCoreVersion() {
+  try {
+    const pkg = createRequire(import.meta.url)("playwright-core/package.json");
+    return typeof pkg.version === "string" && pkg.version ? pkg.version : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function playwrightInstallSpec(version = resolvePlaywrightCoreVersion()) {
+  return version ? `playwright@${version}` : "playwright";
+}
+var PLAYWRIGHT_MANUAL_INSTALL_HINT = `npx ${playwrightInstallSpec()} install chromium\uFF08\u56FD\u5185\u7F51\u7EDC\uFF1APLAYWRIGHT_DOWNLOAD_HOST=https://registry.npmmirror.com/-/binary/playwright npx ${playwrightInstallSpec()} install chromium\uFF09`;
+var PLAYWRIGHT_INSTALL_HINT = `chromium \u672A\u5B89\u88C5\u3002\u4E00\u952E\u5B89\u88C5\uFF1A\u7EC8\u7AEF \`rivet browser install\`\uFF08\u81EA\u52A8\u5E26\u56FD\u5185\u955C\u50CF\uFF09\uFF0C\u6216\u684C\u9762\u7AEF \u8BBE\u7F6E \u2192 \u96C6\u6210 \u2192 \u6D4F\u89C8\u5668\uFF08\u622A\u56FE\uFF09\u91CC\u70B9\u5B89\u88C5\u3002\u624B\u52A8\uFF1A${PLAYWRIGHT_MANUAL_INSTALL_HINT}`;
+async function loadPlaywrightCore() {
+  const specifier = "playwright-core";
+  try {
+    return await import(specifier);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `\u65E0\u6CD5\u52A0\u8F7D playwright-core \u6A21\u5757\uFF08\u4E0D\u662F\u6D4F\u89C8\u5668\u7F3A\u5931\uFF09\u3002
+\uFF08\u539F\u59CB\u9519\u8BEF\uFF1A${msg.split("\n")[0]}\uFF09`
+    );
+  }
+}
+function isBrowserMissingError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return msg.includes("Executable") && msg.includes("doesn't exist");
+}
+async function launchHeadlessChromium(opts = {}) {
+  const mod = await loadPlaywrightCore();
+  try {
+    return await mod.chromium.launch({
+      headless: true,
+      ...opts.timeoutMs ? { timeout: opts.timeoutMs } : {},
+      ...opts.proxy ? { proxy: opts.proxy } : {}
+    });
+  } catch (err) {
+    if (isBrowserMissingError(err)) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`${PLAYWRIGHT_INSTALL_HINT}
+\uFF08\u539F\u59CB\u9519\u8BEF\uFF1A${msg.split("\n")[0]}\uFF09`);
+    }
+    throw err;
+  }
+}
+
+export {
+  PLAYWRIGHT_CORE_INSTALL_HINT,
+  resolvePlaywrightCoreVersion,
+  playwrightInstallSpec,
+  PLAYWRIGHT_MANUAL_INSTALL_HINT,
+  PLAYWRIGHT_INSTALL_HINT,
+  loadPlaywrightCore,
+  isBrowserMissingError,
+  launchHeadlessChromium
+};

package/dist/chunk-Z5Z3JHJY.js

@@ -0,0 +1,64 @@
+#!/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/api/json-escape-repair.ts
+init_esm_shims();
+var VALID_SINGLE_ESCAPES = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t"]);
+var HEX4_RE = /^[0-9a-fA-F]{4}/;
+function repairInvalidJsonEscapes(raw) {
+  let out = "";
+  let inString = false;
+  let changed = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (!inString) {
+      if (ch === '"') inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inString = false;
+      out += ch;
+      continue;
+    }
+    if (ch !== "\\") {
+      out += ch;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next !== void 0 && VALID_SINGLE_ESCAPES.has(next)) {
+      out += ch + next;
+      i++;
+      continue;
+    }
+    if (next === "u" && HEX4_RE.test(raw.slice(i + 2, i + 6))) {
+      out += ch;
+      continue;
+    }
+    out += "\\\\";
+    changed = true;
+  }
+  return changed ? out : null;
+}
+function parseJsonObjectWithEscapeRepair(raw) {
+  for (const candidate of [raw, repairInvalidJsonEscapes(raw)]) {
+    if (candidate === null) continue;
+    try {
+      const parsed = JSON.parse(candidate);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return null;
+    } catch {
+    }
+  }
+  return null;
+}
+
+export {
+  repairInvalidJsonEscapes,
+  parseJsonObjectWithEscapeRepair
+};

package/dist/chunk-ZDIFBJFT.js

@@ -0,0 +1,168 @@
+#!/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/agent/galaxy-contract.ts
+init_esm_shims();
+function normalizeGalaxyLabel(value) {
+  return value.trim().toLocaleLowerCase().replace(/[\s_-]+/g, "-");
+}
+function validateGalaxyDimensionContract(dimensions) {
+  const issues = [];
+  const dimensionNames = /* @__PURE__ */ new Map();
+  for (let index = 0; index < dimensions.length; index++) {
+    const dimension = dimensions[index];
+    const name = normalizeGalaxyLabel(dimension.name);
+    const previous = dimensionNames.get(name);
+    if (previous !== void 0) {
+      issues.push({
+        dimensionIndex: index,
+        code: "duplicate-dimension",
+        message: `dimension "${dimension.name}" duplicates dimension #${previous + 1}; use unique names so task identity remains stable`
+      });
+    } else {
+      dimensionNames.set(name, index);
+    }
+    const hasAuthorityField = dimension.authority !== void 0;
+    const hasAuthoritiesField = dimension.authorities !== void 0;
+    if (hasAuthorityField && hasAuthoritiesField) {
+      issues.push({
+        dimensionIndex: index,
+        code: "ambiguous-authority",
+        message: `dimension "${dimension.name}" must set either authority or authorities, not both`
+      });
+    }
+    const authority = dimension.authority?.trim() ?? "";
+    const authorities = (dimension.authorities ?? []).map((value) => value.trim());
+    if (!authority && authorities.length === 0) {
+      issues.push({
+        dimensionIndex: index,
+        code: "missing-authority",
+        message: `dimension "${dimension.name}" must select at least one star-domain authority`
+      });
+    }
+    const seenAuthorities = /* @__PURE__ */ new Set();
+    for (const candidate of authorities) {
+      const key = normalizeGalaxyLabel(candidate);
+      if (seenAuthorities.has(key)) {
+        issues.push({
+          dimensionIndex: index,
+          code: "duplicate-authority",
+          message: `dimension "${dimension.name}" repeats authority "${candidate}"; each EP perspective must be unique`
+        });
+        break;
+      }
+      seenAuthorities.add(key);
+    }
+    if (dimension.parallelism === "data") {
+      if (hasAuthoritiesField || authorities.length > 0) {
+        issues.push({
+          dimensionIndex: index,
+          code: "data-authority-list",
+          message: `data-parallel dimension "${dimension.name}" accepts one authority; use expert mode for multiple perspectives`
+        });
+      }
+      if (dimension.replicas === void 0 || dimension.replicas < 2) {
+        issues.push({
+          dimensionIndex: index,
+          code: "data-replicas",
+          message: `data-parallel dimension "${dimension.name}" requires replicas >= 2`
+        });
+      }
+    } else if (dimension.replicas !== void 0) {
+      issues.push({
+        dimensionIndex: index,
+        code: "expert-replicas",
+        message: `expert dimension "${dimension.name}" cannot set replicas; use parallelism: data for independent copies`
+      });
+    }
+  }
+  return issues;
+}
+
+// src/agent/galaxy-budget.ts
+init_esm_shims();
+var SEMANTIC_PATTERNS = [
+  ["review", ["review", "\u5BA1\u67E5", "\u8BC4\u5BA1", "\u590D\u5BA1", "\u5BA1\u9605"]],
+  ["verify", ["verify", "test", "\u9A8C\u8BC1", "\u56DE\u5F52", "\u6D4B\u8BD5", "\u81EA\u6D4B"]],
+  ["docs", ["docs", "doc", "research", "\u6587\u6863", "\u8C03\u7814", "\u7814\u7A76", "\u8D44\u6599"]],
+  ["plan", ["plan", "design", "\u89C4\u5212", "\u8BA1\u5212", "\u8BBE\u8BA1", "\u65B9\u6848"]],
+  ["search", ["search", "scout", "explore", "\u68C0\u7D22", "\u641C\u7D22", "\u63A2\u67E5", "\u4FA6\u5BDF", "\u63A2\u7D22", "\u8C03\u67E5"]],
+  ["impl", ["impl", "patch", "fix", "frontend", "backend", "feature", "\u5B9E\u73B0", "\u524D\u7AEF", "\u540E\u7AEF", "\u4FEE\u590D", "\u8865\u4E01", "\u5F00\u53D1", "\u91CD\u6784"]]
+];
+function classifyGalaxyDimension(name) {
+  const key = (name ?? "").toLowerCase().replace(/[\s_-]/g, "");
+  if (key.length === 0) return "impl";
+  for (const [semantic, patterns] of SEMANTIC_PATTERNS) {
+    for (const pattern of patterns) {
+      if (key.includes(pattern)) return semantic;
+    }
+  }
+  return "impl";
+}
+var PROFILE_BY_SEMANTIC = {
+  review: "reviewer",
+  verify: "verify_scout",
+  plan: "planner",
+  docs: "doc_scout",
+  search: "code_scout",
+  impl: "patcher"
+};
+var KIND_BY_SEMANTIC = {
+  review: "review",
+  verify: "verify",
+  plan: "plan",
+  docs: "doc_research",
+  search: "code_search",
+  impl: "patch_proposal"
+};
+var TASK_SHAPE_BY_SEMANTIC = {
+  review: "review",
+  verify: "review",
+  plan: "plan",
+  docs: "docs",
+  search: "explore",
+  impl: "impl"
+};
+function mapGalaxyDimensionToProfile(name) {
+  return PROFILE_BY_SEMANTIC[classifyGalaxyDimension(name)];
+}
+function mapGalaxyDimensionToKind(name) {
+  return KIND_BY_SEMANTIC[classifyGalaxyDimension(name)];
+}
+function mapGalaxyDimensionToTaskShape(name) {
+  return TASK_SHAPE_BY_SEMANTIC[classifyGalaxyDimension(name)];
+}
+function isReviewGalaxyDimension(name) {
+  const semantic = classifyGalaxyDimension(name);
+  return semantic === "review" || semantic === "verify";
+}
+function buildGalaxyBudgetInputs(dimensions) {
+  const profiles = [];
+  const tierFloors = [];
+  const requestedTimeoutMs = [];
+  for (const rawDimension of dimensions) {
+    if (!rawDimension || typeof rawDimension !== "object") continue;
+    const dimension = rawDimension;
+    const authorities = Array.isArray(dimension.authorities) ? dimension.authorities : typeof dimension.authority === "string" && dimension.authority.length > 0 ? [dimension.authority] : [];
+    const replicas = dimension.parallelism === "data" && typeof dimension.replicas === "number" && Number.isFinite(dimension.replicas) ? Math.max(1, Math.trunc(dimension.replicas)) : 1;
+    const profile = typeof dimension.profile === "string" ? dimension.profile : typeof dimension.name === "string" && dimension.name.length > 0 ? mapGalaxyDimensionToProfile(dimension.name) : void 0;
+    for (let i = 0; i < authorities.length * replicas; i++) {
+      profiles.push(profile);
+      tierFloors.push(dimension.tierFloor);
+      requestedTimeoutMs.push(dimension.timeoutMs);
+    }
+  }
+  return { profiles, tierFloors, requestedTimeoutMs };
+}
+
+export {
+  validateGalaxyDimensionContract,
+  mapGalaxyDimensionToProfile,
+  mapGalaxyDimensionToKind,
+  mapGalaxyDimensionToTaskShape,
+  isReviewGalaxyDimension,
+  buildGalaxyBudgetInputs
+};

package/dist/chunk-ZGGCEXDC.js

@@ -0,0 +1,176 @@
+#!/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/agent/tool-arg-post-processor.ts
+init_esm_shims();
+var ToolArgPostProcessorRegistry = class {
+  processors = /* @__PURE__ */ new Map();
+  register(processor) {
+    this.processors.set(processor.toolName, processor);
+  }
+  has(name) {
+    return this.processors.has(name);
+  }
+  /**
+   * Process an array of OaiToolCalls in-place-safe manner.
+   * Returns the same array if nothing changed, or a new array with
+   * replaced arguments. Never mutates the original OaiToolCall objects —
+   * creates shallow copies with replaced `function.arguments`.
+   */
+  processToolCalls(calls) {
+    if (calls.length === 0) return calls;
+    let changed = false;
+    const result = calls.map((tc) => {
+      const processor = this.processors.get(tc.function.name);
+      if (!processor) return tc;
+      try {
+        const newArgs = processor.process(tc.function.arguments);
+        if (newArgs !== null && newArgs !== tc.function.arguments) {
+          changed = true;
+          return {
+            ...tc,
+            function: { ...tc.function, arguments: newArgs }
+          };
+        }
+      } catch {
+      }
+      return tc;
+    });
+    return changed ? result : calls;
+  }
+};
+function createFileContentArgProcessor(opts) {
+  return {
+    toolName: opts.toolName,
+    process(args) {
+      let parsed;
+      try {
+        parsed = JSON.parse(args);
+      } catch {
+        return null;
+      }
+      const content = parsed[opts.contentField];
+      if (typeof content !== "string" || content.length === 0) return null;
+      if (content.startsWith(opts.pointerPrefix)) return null;
+      if (opts.threshold > 0 && content.length < opts.threshold) return null;
+      const path = opts.resolvePath(parsed);
+      if (typeof path !== "string" || path.length === 0) return null;
+      const chars = content.length;
+      const lines = content.split("\n").length;
+      return JSON.stringify({
+        ...parsed,
+        [opts.contentField]: opts.render({ path, lines, chars })
+      });
+    }
+  };
+}
+
+// src/tools/edit-file-arg-processor.ts
+init_esm_shims();
+
+// src/tools/pointer-tag.ts
+init_esm_shims();
+var POINTER_INTERNAL_TAG = "#RIVET-POINTER-DISPLAY-ONLY#";
+
+// src/tools/edit-file-arg-processor.ts
+var EDIT_FILE_POINTER_PREFIX = "[edit on";
+var EDIT_FILE_THRESHOLD = 8e3;
+var editFileArgProcessor = {
+  toolName: "edit_file",
+  process(args) {
+    let parsed;
+    try {
+      parsed = JSON.parse(args);
+    } catch {
+      return null;
+    }
+    const oldStr = parsed.old_string;
+    const newStr = parsed.new_string;
+    const filePath = parsed.file_path;
+    if (typeof oldStr !== "string" || typeof newStr !== "string") return null;
+    if (typeof filePath !== "string" || filePath.length === 0) return null;
+    if (oldStr.startsWith(EDIT_FILE_POINTER_PREFIX)) return null;
+    if (oldStr.length + newStr.length < EDIT_FILE_THRESHOLD) return null;
+    const preview = oldStr.slice(0, 80).replace(/\s+/g, " ").trim();
+    return JSON.stringify({
+      ...parsed,
+      old_string: `${EDIT_FILE_POINTER_PREFIX} ${filePath}: replaced ${oldStr.length}-char block, preview: "${preview}". \u5DF2\u6210\u529F\u843D\u76D8\uFF0C\u52FF\u91CD\u505A\u2014\u2014\u5386\u53F2\u6B63\u5E38\u622A\u65AD\uFF0C\u67E5\u770B\u7528 read_file\u3002${POINTER_INTERNAL_TAG} display-only pointer]`,
+      new_string: `[new block ${filePath}: ${newStr.length} chars \u2014 \u5DF2\u843D\u76D8\uFF0C\u52FF\u91CD\u505A\u3002${POINTER_INTERNAL_TAG} display-only pointer]`
+    });
+  }
+};
+
+// src/tools/hash-edit-arg-processor.ts
+init_esm_shims();
+var HASH_EDIT_POINTER_PREFIX = "[hash_edit applied to";
+var HASH_EDIT_THRESHOLD = 8e3;
+var hashEditArgProcessor = createFileContentArgProcessor({
+  toolName: "hash_edit",
+  contentField: "new_string",
+  pointerPrefix: HASH_EDIT_POINTER_PREFIX,
+  threshold: HASH_EDIT_THRESHOLD,
+  resolvePath: (parsed) => {
+    const fp = parsed.file_path;
+    return typeof fp === "string" && fp.length > 0 ? fp : null;
+  },
+  render: ({ path, lines, chars }) => `${HASH_EDIT_POINTER_PREFIX} ${path} \u2014 new block ${lines} lines, ${chars} chars. \u5DF2\u6210\u529F\u843D\u76D8\uFF0C\u52FF\u91CD\u505A\u2014\u2014\u5386\u53F2\u6B63\u5E38\u622A\u65AD\uFF0C\u67E5\u770B\u7528 read_file\u3002${POINTER_INTERNAL_TAG} display-only pointer]`
+});
+
+// src/tools/apply-patch-arg-processor.ts
+init_esm_shims();
+var APPLY_PATCH_POINTER_PREFIX = "[patch applied to";
+var APPLY_PATCH_THRESHOLD = 4e3;
+var MAX_LISTED_FILES = 5;
+function parsePatchedFiles(diff) {
+  const files = [];
+  for (const line of diff.split("\n")) {
+    if (!line.startsWith("+++ ")) continue;
+    let path = line.slice(4).trim();
+    const tabIdx = path.indexOf("	");
+    if (tabIdx !== -1) path = path.slice(0, tabIdx);
+    if (path === "/dev/null") continue;
+    if (path.startsWith("b/")) path = path.slice(2);
+    if (path.length > 0) files.push(path);
+  }
+  return files;
+}
+var applyPatchArgProcessor = {
+  toolName: "apply_patch",
+  process(args) {
+    let parsed;
+    try {
+      parsed = JSON.parse(args);
+    } catch {
+      return null;
+    }
+    const diff = parsed.diff;
+    if (typeof diff !== "string" || diff.length === 0) return null;
+    if (diff.startsWith(APPLY_PATCH_POINTER_PREFIX)) return null;
+    if (parsed.check_only === true) return null;
+    if (diff.length < APPLY_PATCH_THRESHOLD) return null;
+    const files = parsePatchedFiles(diff);
+    if (files.length === 0) return null;
+    const hunks = (diff.match(/^@@ /gm) ?? []).length;
+    const shown = files.slice(0, MAX_LISTED_FILES).join(", ");
+    const more = files.length > MAX_LISTED_FILES ? `, \u2026(+${files.length - MAX_LISTED_FILES})` : "";
+    return JSON.stringify({
+      ...parsed,
+      diff: `${APPLY_PATCH_POINTER_PREFIX} ${files.length} file(s): ${shown}${more} \u2014 ${hunks} hunks, ${diff.length} chars. \u5DF2\u6210\u529F\u5E94\u7528\uFF0C\u52FF\u91CD\u653E\u2014\u2014\u5386\u53F2\u6B63\u5E38\u622A\u65AD\uFF0C\u67E5\u770B\u7528 read_file / git diff\u3002${POINTER_INTERNAL_TAG} display-only pointer]`
+    });
+  }
+};
+
+export {
+  ToolArgPostProcessorRegistry,
+  createFileContentArgProcessor,
+  POINTER_INTERNAL_TAG,
+  EDIT_FILE_POINTER_PREFIX,
+  editFileArgProcessor,
+  HASH_EDIT_POINTER_PREFIX,
+  hashEditArgProcessor,
+  APPLY_PATCH_POINTER_PREFIX,
+  applyPatchArgProcessor
+};