tianshu-harness 3.23.0

package/dist/chunk-UFMN76QD.js

@@ -0,0 +1,347 @@
+#!/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 {
+  loadConfig
+} from "./chunk-ER5JW2QZ.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/resolved-env.ts
+init_esm_shims();
+import { execFile, spawnSync } from "child_process";
+import { existsSync } from "fs";
+import { win32 as winPath, posix as posixPath } from "path";
+var TOOLCHAIN_VARS = [
+  "JAVA_HOME",
+  "JDK_HOME",
+  "JRE_HOME",
+  "MAVEN_HOME",
+  "M2_HOME",
+  "M2",
+  "GRADLE_HOME",
+  "GOROOT",
+  "GOPATH",
+  "GOBIN",
+  "ANDROID_HOME",
+  "ANDROID_SDK_ROOT",
+  "CARGO_HOME",
+  "RUSTUP_HOME",
+  "NVM_DIR",
+  "PYENV_ROOT",
+  "SDKMAN_DIR",
+  "PNPM_HOME",
+  "VOLTA_HOME",
+  "FNM_DIR"
+];
+function findPathKey(env) {
+  for (const key of Object.keys(env)) {
+    if (key.toLowerCase() === "path") return key;
+  }
+  return "PATH";
+}
+function splitPath(value, sep) {
+  return value.split(sep).map((s) => s.trim()).filter(Boolean);
+}
+function expandWinVars(value, env) {
+  return value.replace(/%([^%]+)%/g, (whole, name) => {
+    const lower = name.toLowerCase();
+    for (const [k, v] of Object.entries(env)) {
+      if (k.toLowerCase() === lower && typeof v === "string") return v;
+    }
+    return whole;
+  });
+}
+function parseRegQuery(stdout) {
+  const out = {};
+  for (const line of stdout.split(/\r?\n/)) {
+    const m = line.match(/^\s+(\S+)\s+(REG_\w+)\s+(.*)$/);
+    if (m) out[m[1]] = m[3].trim();
+  }
+  return out;
+}
+function parseEnvDump(dump) {
+  const out = {};
+  for (const line of dump.split(/\r?\n/)) {
+    const m = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (m) out[m[1]] = m[2];
+  }
+  return out;
+}
+function looksShort(entries) {
+  const set = new Set(entries);
+  return !set.has("/usr/local/bin") && !set.has("/opt/homebrew/bin");
+}
+function unixProbeDirs(env) {
+  const home = env.HOME ?? "";
+  const dirs = ["/usr/local/bin", "/opt/homebrew/bin", "/usr/local/sbin"];
+  if (home) dirs.push(posixPath.join(home, ".local", "bin"), posixPath.join(home, "bin"));
+  return dirs;
+}
+function deriveBinDirs(vars, platform) {
+  const path = platform === "win32" ? winPath : posixPath;
+  const dirs = [];
+  const bin = (v) => {
+    if (v) dirs.push(path.join(v, "bin"));
+  };
+  bin(vars.JAVA_HOME);
+  bin(vars.JDK_HOME);
+  bin(vars.JRE_HOME);
+  bin(vars.MAVEN_HOME);
+  bin(vars.M2_HOME);
+  bin(vars.M2);
+  bin(vars.GRADLE_HOME);
+  bin(vars.GOROOT);
+  bin(vars.GOPATH);
+  bin(vars.CARGO_HOME);
+  if (vars.GOBIN) dirs.push(vars.GOBIN);
+  if (vars.PNPM_HOME) dirs.push(vars.PNPM_HOME);
+  bin(vars.VOLTA_HOME);
+  if (vars.ANDROID_HOME) {
+    dirs.push(path.join(vars.ANDROID_HOME, "platform-tools"), path.join(vars.ANDROID_HOME, "cmdline-tools", "latest", "bin"));
+  }
+  return dirs;
+}
+function resolveHostEnv(deps) {
+  const isWin = deps.platform === "win32";
+  const sep = isWin ? ";" : ":";
+  const pathKey = findPathKey(deps.baseEnv);
+  const basePath = deps.baseEnv[pathKey] ?? deps.baseEnv.PATH ?? "";
+  const pathEntries = splitPath(basePath, sep);
+  const seen = new Set(pathEntries.map((e) => isWin ? e.toLowerCase() : e));
+  const addPath = (p) => {
+    if (!p) return;
+    const key = isWin ? p.toLowerCase() : p;
+    if (seen.has(key)) return;
+    seen.add(key);
+    pathEntries.push(p);
+  };
+  const vars = {};
+  const baseHas = (k) => Object.keys(deps.baseEnv).some((bk) => bk.toLowerCase() === k.toLowerCase());
+  const addVar = (key, val) => {
+    if (!val || vars[key] || baseHas(key)) return;
+    vars[key] = val;
+  };
+  if (isWin) {
+    let regReadOk = false;
+    for (const scope of ["machine", "user"]) {
+      const reg = deps.readRegistryEnv(scope);
+      const regPath = reg.Path ?? reg.PATH ?? "";
+      if (regPath) regReadOk = true;
+      for (const e of splitPath(expandWinVars(regPath, deps.baseEnv), sep)) addPath(e);
+      for (const v of TOOLCHAIN_VARS) {
+        const val = reg[v];
+        if (val) addVar(v, expandWinVars(val, deps.baseEnv));
+      }
+    }
+    if (!regReadOk) {
+      const sysRoot = deps.baseEnv.SystemRoot || deps.baseEnv.windir || "C:\\Windows";
+      for (const dir of [`${sysRoot}\\System32`, `${sysRoot}`, `${sysRoot}\\System32\\Wbem`]) {
+        if (deps.exists(dir)) addPath(dir);
+      }
+      const localApp = deps.baseEnv.LOCALAPPDATA;
+      if (localApp) {
+        for (const sub of ["Programs\\Git\\bin", "Programs\\Git\\cmd", "Microsoft\\WindowsApps"]) {
+          if (deps.exists(`${localApp}\\${sub}`)) addPath(`${localApp}\\${sub}`);
+        }
+      }
+    }
+  } else if (looksShort(pathEntries)) {
+    const dump = deps.dumpLoginShellEnv();
+    if (dump) {
+      const parsed = parseEnvDump(dump);
+      for (const e of splitPath(parsed.PATH ?? "", sep)) addPath(e);
+      for (const v of TOOLCHAIN_VARS) {
+        if (parsed[v]) addVar(v, parsed[v]);
+      }
+    } else {
+      for (const dir of unixProbeDirs(deps.baseEnv)) {
+        if (deps.exists(dir)) addPath(dir);
+      }
+    }
+  }
+  const allToolchainVars = { ...vars };
+  for (const v of TOOLCHAIN_VARS) {
+    if (!allToolchainVars[v]) {
+      for (const [bk, bv] of Object.entries(deps.baseEnv)) {
+        if (bk.toLowerCase() === v.toLowerCase() && typeof bv === "string") {
+          allToolchainVars[v] = bv;
+          break;
+        }
+      }
+    }
+  }
+  for (const dir of deriveBinDirs(allToolchainVars, deps.platform)) {
+    if (deps.exists(dir)) addPath(dir);
+  }
+  return { pathKey, path: pathEntries.join(sep), vars };
+}
+function applyConfigEnv(base, config, platform) {
+  const sep = platform === "win32" ? ";" : ":";
+  const result = { ...base };
+  const pathKey = findPathKey(result);
+  const extraPath = (config.extraPath ?? []).filter(Boolean);
+  if (extraPath.length > 0) {
+    const current = result[pathKey] ?? "";
+    const existing = new Set(splitPath(current, sep).map((e) => platform === "win32" ? e.toLowerCase() : e));
+    const additions = extraPath.filter((p) => !existing.has(platform === "win32" ? p.toLowerCase() : p));
+    result[pathKey] = additions.length > 0 ? [current, ...additions].filter(Boolean).join(sep) : current;
+  }
+  for (const [k, v] of Object.entries(config.extraVars ?? {})) {
+    result[k] = v;
+  }
+  return result;
+}
+function readRegistryEnvReal(scope) {
+  const hive = scope === "machine" ? "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" : "HKCU\\Environment";
+  const systemRoot = process.env.SystemRoot || process.env.windir || "C:\\Windows";
+  const regExe = systemRoot + "\\System32\\reg.exe";
+  try {
+    const res = spawnSync(regExe, ["query", hive], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3e3,
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (res.status !== 0 || typeof res.stdout !== "string") return {};
+    return parseRegQuery(res.stdout);
+  } catch {
+    return {};
+  }
+}
+function dumpLoginShellEnvReal() {
+  try {
+    const shell = process.env.SHELL || "/bin/bash";
+    const res = spawnSync(shell, ["-lic", "command env"], {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 3e3,
+      encoding: "utf8",
+      windowsHide: true
+    });
+    if (res.status !== 0 || typeof res.stdout !== "string") return "";
+    return res.stdout;
+  } catch {
+    return "";
+  }
+}
+function realDeps() {
+  return {
+    platform: process.platform,
+    baseEnv: process.env,
+    readRegistryEnv: readRegistryEnvReal,
+    dumpLoginShellEnv: dumpLoginShellEnvReal,
+    exists: existsSync
+  };
+}
+var _cachedHost = null;
+var _prewarm = null;
+function readRegistryEnvAsync(scope) {
+  const hive = scope === "machine" ? "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment" : "HKCU\\Environment";
+  const systemRoot = process.env.SystemRoot || process.env.windir || "C:\\Windows";
+  const regExe = systemRoot + "\\System32\\reg.exe";
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        regExe,
+        ["query", hive],
+        { timeout: 3e3, encoding: "utf8", windowsHide: true, maxBuffer: 4 * 1024 * 1024 },
+        (err, stdout) => resolve(err || typeof stdout !== "string" ? {} : parseRegQuery(stdout))
+      );
+    } catch {
+      resolve({});
+    }
+  });
+}
+function dumpLoginShellEnvAsync() {
+  return new Promise((resolve) => {
+    try {
+      const shell = process.env.SHELL || "/bin/bash";
+      execFile(
+        shell,
+        ["-lic", "command env"],
+        { timeout: 3e3, encoding: "utf8", windowsHide: true, maxBuffer: 4 * 1024 * 1024 },
+        (err, stdout) => resolve(err || typeof stdout !== "string" ? "" : stdout)
+      );
+    } catch {
+      resolve("");
+    }
+  });
+}
+function prewarmResolvedEnv() {
+  if (_cachedHost) return Promise.resolve();
+  if (_prewarm) return _prewarm;
+  _prewarm = (async () => {
+    const platform = process.platform;
+    let reg = { machine: {}, user: {} };
+    let dump = "";
+    if (platform === "win32") {
+      const [machine, user] = await Promise.all([readRegistryEnvAsync("machine"), readRegistryEnvAsync("user")]);
+      reg = { machine, user };
+    } else {
+      const sep = ":";
+      const base = process.env[findPathKey(process.env)] ?? process.env.PATH ?? "";
+      if (looksShort(splitPath(base, sep))) dump = await dumpLoginShellEnvAsync();
+    }
+    if (_cachedHost) return;
+    _cachedHost = resolveHostEnv({
+      platform,
+      baseEnv: process.env,
+      readRegistryEnv: (scope) => reg[scope],
+      dumpLoginShellEnv: () => dump,
+      exists: existsSync
+    });
+  })().catch(() => {
+  }).finally(() => {
+    _prewarm = null;
+  });
+  return _prewarm;
+}
+var ANTI_INTERACTIVE_ENV = {
+  PAGER: "cat",
+  GIT_PAGER: "cat",
+  GH_PAGER: "cat",
+  MANPAGER: "cat",
+  GIT_TERMINAL_PROMPT: "0",
+  // git never prompts for credentials interactively
+  GIT_EDITOR: "true",
+  // git never launches an editor
+  GIT_SEQUENCE_EDITOR: "true",
+  GPG_TTY: ""
+  // empty = gpg/pinentry can't grab the tty, fails cleanly
+};
+function withAntiInteractive(env) {
+  return { ...env, ...ANTI_INTERACTIVE_ENV };
+}
+function getResolvedEnv(cwd) {
+  let envConfig;
+  try {
+    envConfig = loadConfig({ cwd }).env;
+  } catch {
+    envConfig = { resolve: true, extraPath: [], extraVars: {} };
+  }
+  if (envConfig.resolve === false) {
+    return withAntiInteractive(applyConfigEnv({ ...process.env }, envConfig, process.platform));
+  }
+  if (!_cachedHost) _cachedHost = resolveHostEnv(realDeps());
+  const merged = { ..._cachedHost.vars, ...process.env };
+  merged[_cachedHost.pathKey] = _cachedHost.path;
+  return withAntiInteractive(applyConfigEnv(merged, envConfig, process.platform));
+}
+function getResolvedPathDiff(cwd) {
+  const sep = process.platform === "win32" ? ";" : ":";
+  const rawKey = findPathKey(process.env);
+  const processPath = splitPath(process.env[rawKey] ?? process.env.PATH ?? "", sep);
+  const resolved = getResolvedEnv(cwd);
+  const resKey = findPathKey(resolved);
+  const resolvedPath = splitPath(resolved[resKey] ?? resolved.PATH ?? "", sep);
+  const existing = new Set(processPath.map((e) => process.platform === "win32" ? e.toLowerCase() : e));
+  const added = resolvedPath.filter((e) => !existing.has(process.platform === "win32" ? e.toLowerCase() : e));
+  return { processPath, resolvedPath, added };
+}
+
+export {
+  prewarmResolvedEnv,
+  ANTI_INTERACTIVE_ENV,
+  getResolvedEnv,
+  getResolvedPathDiff
+};

package/dist/chunk-UHGLFRZE.js

@@ -0,0 +1,205 @@
+#!/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 {
+  MAX_TASK_CONSTRAINT_CHARS
+} from "./chunk-4QJ3Y5JM.js";
+import {
+  listPlansSync
+} from "./chunk-ZMZCZNKU.js";
+import {
+  validatePathSafe
+} from "./chunk-7RDOV3DF.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/plan-constraints.ts
+init_esm_shims();
+import { readFileSync, statSync } from "fs";
+import { join } from "path";
+var HEADING_RE = /^(反目标|非目标|不做的事|待验证假设|anti-?goals?|non-?goals?|assumptions?)\s*(?:[（(].*)?$/i;
+var BOLD_RE = /^\*\*(反目标|非目标|不做的事|待验证假设|约束)[：:]*\*\*\s*[：:]?\s*(.*)$/;
+var LIST_ITEM_RE = /^\s*(?:[-*]\s+(?:\[[ xX]\]\s*)?|\d+\.\s+)(.+)$/;
+var THEMATIC_BREAK_RE = /^([-*_])(?:\s*\1){2,}$/;
+var BOLD_LINE_RE = /^\*\*/;
+var MD_TOKEN_RE = /([^\s<>"'`]+\.md)/g;
+var MAX_PLAN_BYTES = 512 * 1024;
+function kindForWord(word) {
+  const w = word.toLowerCase();
+  if (w === "\u5F85\u9A8C\u8BC1\u5047\u8BBE" || w === "assumption" || w === "assumptions") return "assumption";
+  return "anti-goal";
+}
+function kindForBoldWord(word) {
+  if (word === "\u5F85\u9A8C\u8BC1\u5047\u8BBE") return "assumption";
+  if (word === "\u7EA6\u675F") return "constraint";
+  return "anti-goal";
+}
+function extractPlanConstraints(markdown) {
+  if (!markdown) return [];
+  const items = [];
+  const push = (kind, text, section) => {
+    const trimmed = text.trim();
+    if (trimmed) items.push({ kind, text: trimmed, section });
+  };
+  let heading = null;
+  let bold = null;
+  for (const raw of markdown.split(/\r?\n/)) {
+    const line = raw.trim();
+    const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+    if (headingMatch) {
+      bold = null;
+      const level = headingMatch[1].length;
+      const title = headingMatch[2].trim();
+      const hit = title.match(HEADING_RE);
+      if (hit) {
+        heading = { kind: kindForWord(hit[1]), level, section: title };
+      } else if (heading && level <= heading.level) {
+        heading = null;
+      }
+      continue;
+    }
+    if (THEMATIC_BREAK_RE.test(line)) {
+      bold = null;
+      continue;
+    }
+    const boldMatch = line.match(BOLD_RE);
+    if (boldMatch) {
+      const kind = kindForBoldWord(boldMatch[1]);
+      const rest = boldMatch[2].trim();
+      bold = rest ? null : { kind, section: boldMatch[1] };
+      if (rest) push(kind, rest, boldMatch[1]);
+      continue;
+    }
+    if (BOLD_LINE_RE.test(line)) {
+      bold = null;
+      continue;
+    }
+    const listMatch = line.match(LIST_ITEM_RE);
+    if (listMatch && listMatch[1].trim()) {
+      const text = listMatch[1].trim();
+      if (bold) push(bold.kind, text, bold.section);
+      else if (heading) push(heading.kind, text, heading.section);
+    }
+  }
+  return items;
+}
+var PLAN_CONSTRAINT_PREFIX = "[\u8BA1\u5212";
+var PREFIX_BY_KIND = {
+  "anti-goal": `${PLAN_CONSTRAINT_PREFIX}\u53CD\u76EE\u6807] `,
+  constraint: `${PLAN_CONSTRAINT_PREFIX}\u7EA6\u675F] `,
+  assumption: `${PLAN_CONSTRAINT_PREFIX}\u5F85\u9A8C\u8BC1\u5047\u8BBE\xB7\u6267\u884C\u671F\u5148\u9A8C\u8BC1] `
+};
+var SENTENCE_END_RE = /[。．.！!？?]/g;
+function truncateWithPointer(text, section, planRef, budget) {
+  const pointer = `\u2026\uFF08\u5168\u6587\u89C1 ${planRef ?? "\u8BA1\u5212"}\u300C${section}\u300D\uFF09`;
+  const textBudget = Math.max(8, budget - pointer.length);
+  if (text.length <= textBudget) return text;
+  let cut = -1;
+  for (const m of text.slice(0, textBudget).matchAll(SENTENCE_END_RE)) {
+    cut = m.index + 1;
+  }
+  if (cut < 0) cut = textBudget;
+  return text.slice(0, cut) + pointer;
+}
+function renderPlanConstraints(items, planRef) {
+  const rank = { "anti-goal": 0, constraint: 1, assumption: 2 };
+  const sorted = [...items].sort((a, b) => rank[a.kind] - rank[b.kind]);
+  return sorted.map((item) => {
+    const prefix = PREFIX_BY_KIND[item.kind];
+    return prefix + truncateWithPointer(item.text, item.section, planRef, MAX_TASK_CONSTRAINT_CHARS - prefix.length);
+  });
+}
+function readPlanAndRender(cwd, pathToken) {
+  const validated = validatePathSafe(cwd, pathToken);
+  if (!validated.ok) return [];
+  let stat;
+  try {
+    stat = statSync(validated.path);
+  } catch {
+    return [];
+  }
+  if (!stat.isFile() || stat.size > MAX_PLAN_BYTES) return [];
+  let content = "";
+  try {
+    content = readFileSync(validated.path, "utf-8");
+  } catch {
+    return [];
+  }
+  return renderPlanConstraints(extractPlanConstraints(content), pathToken);
+}
+function resolvePlanConstraints(cwd, src) {
+  if (process.env.RIVET_PLAN_CONSTRAINTS === "0") return [];
+  try {
+    if (src.markdown) {
+      const rendered = renderPlanConstraints(extractPlanConstraints(src.markdown));
+      if (rendered.length > 0) return rendered;
+    }
+    if (src.planPath) {
+      const rendered = readPlanAndRender(cwd, src.planPath);
+      if (rendered.length > 0) return rendered;
+    }
+    if (src.objective) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const raw of src.objective.matchAll(MD_TOKEN_RE)) {
+        const token = raw[1].trim().replace(/[.,;:)\]}>]+$/, "");
+        if (!token || seen.has(token)) continue;
+        seen.add(token);
+        const rendered = readPlanAndRender(cwd, token);
+        if (rendered.length > 0) return rendered;
+      }
+    }
+    if (src.fromContract && src.fromContract.length > 0) return [...src.fromContract];
+    const approved = findApprovedPlanConstraints(cwd);
+    if (approved) return approved;
+    return [];
+  } catch {
+    return [];
+  }
+}
+var PLANS_DIR = ".rivet/plans";
+var approvedPlanCache = /* @__PURE__ */ new Map();
+var APPROVED_PLAN_CACHE_TTL_MS = 5e3;
+function findApprovedPlanConstraints(cwd) {
+  try {
+    let dirMtimeMs = -1;
+    try {
+      dirMtimeMs = statSync(join(cwd, PLANS_DIR)).mtimeMs;
+    } catch {
+    }
+    const now = Date.now();
+    const cached = approvedPlanCache.get(cwd);
+    if (cached && now - cached.at < APPROVED_PLAN_CACHE_TTL_MS && cached.dirMtimeMs === dirMtimeMs) {
+      return cached.value;
+    }
+    const approved = listPlansSync(cwd).filter((p) => p.status === "approved");
+    const value = approved.length === 0 ? void 0 : (() => {
+      const rendered = renderPlanConstraints(extractPlanConstraints(approved[0].content));
+      return rendered.length > 0 ? rendered : void 0;
+    })();
+    approvedPlanCache.set(cwd, { value, at: now, dirMtimeMs });
+    return value;
+  } catch {
+    return void 0;
+  }
+}
+function constraintsFromUnifiedPlan(src) {
+  const items = [];
+  for (const raw of src.nonGoals ?? []) {
+    const text = raw.trim();
+    if (text) items.push({ kind: "anti-goal", text, section: "nonGoals" });
+  }
+  for (const ob of src.obligations ?? []) {
+    if (ob.kind === "advisory_gate") continue;
+    const text = ob.text.trim();
+    if (text) items.push({ kind: "constraint", text, section: `obligations.${ob.kind}` });
+  }
+  return renderPlanConstraints(items);
+}
+
+export {
+  extractPlanConstraints,
+  PLAN_CONSTRAINT_PREFIX,
+  renderPlanConstraints,
+  resolvePlanConstraints,
+  constraintsFromUnifiedPlan
+};