tianshu-harness 3.23.0

package/dist/chunk-JCFWOULR.js

@@ -0,0 +1,245 @@
+#!/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/plan/plan-fact-anchors.ts
+init_esm_shims();
+import { stat, readFile } from "fs/promises";
+import { readdirSync } from "fs";
+import { resolve, relative, isAbsolute, join, dirname, basename } from "path";
+var EXTENSIONS = [
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "mts",
+  "cts",
+  "json",
+  "jsonc",
+  "md",
+  "mdx",
+  "txt",
+  "css",
+  "scss",
+  "less",
+  "html",
+  "vue",
+  "svelte",
+  "py",
+  "rs",
+  "go",
+  "java",
+  "kt",
+  "rb",
+  "php",
+  "c",
+  "h",
+  "cpp",
+  "hpp",
+  "cs",
+  "swift",
+  "sh",
+  "bash",
+  "zsh",
+  "ps1",
+  "bat",
+  "yml",
+  "yaml",
+  "toml",
+  "ini",
+  "env.example",
+  "sql",
+  "graphql",
+  "proto"
+];
+var EXT_ALTERNATION = [...EXTENSIONS].sort((a, b) => b.length - a.length).map((ext) => ext.replace(/\./g, String.raw`\.`)).join("|");
+var PATH_TOKEN_RE = new RegExp(
+  String.raw`(?<![\w./\\-])((?:[\w.@-]+/)+[\w.@-]+\.(?:${EXT_ALTERNATION}))(?!\w)(?::(\d+)(?:-\d+)?)?`,
+  "g"
+);
+var KNOWN_EXT_TAIL_RE = new RegExp(String.raw`\.(?:${EXT_ALTERNATION})$`, "i");
+function hasFileShapedIntermediateSegment(path) {
+  const segments = path.split("/");
+  return segments.slice(0, -1).some((s) => KNOWN_EXT_TAIL_RE.test(s));
+}
+var PLACEHOLDER_BASENAMES = /* @__PURE__ */ new Set(["foo", "bar", "baz", "qux", "quux", "example", "sample", "demo", "dummy", "placeholder"]);
+function isPlaceholderShaped(path) {
+  const base = (path.split("/").pop() ?? path).replace(/\.[^.]*$/, "").toLowerCase();
+  return PLACEHOLDER_BASENAMES.has(base) || /^[a-z]$/.test(base);
+}
+var NEW_FILE_MARKER_RE = /新增|新建|创建|\bnew file\b|\bcreate[ds]?\b/i;
+var CHECKABLE_FENCE_LANGS = /* @__PURE__ */ new Set(["bash", "sh", "shell", "zsh", "console", ""]);
+var LINE_CHECK_MAX_BYTES = 2 * 1024 * 1024;
+var MAX_ANCHORS = 200;
+function extractPlanAnchors(content) {
+  const anchors = /* @__PURE__ */ new Map();
+  let inFence = false;
+  let fenceLang = "";
+  for (const line of content.split("\n")) {
+    const fenceMatch = line.match(/^\s*```([\w-]*)/);
+    if (fenceMatch) {
+      inFence = !inFence;
+      fenceLang = inFence ? (fenceMatch[1] ?? "").toLowerCase() : "";
+      continue;
+    }
+    if (inFence && !CHECKABLE_FENCE_LANGS.has(fenceLang)) continue;
+    const declaredNew = NEW_FILE_MARKER_RE.test(line);
+    for (const match of line.matchAll(PATH_TOKEN_RE)) {
+      const rawPath = match[1];
+      if (rawPath.startsWith("./") || rawPath.includes("..")) continue;
+      if (rawPath.includes("node_modules/")) continue;
+      if (hasFileShapedIntermediateSegment(rawPath)) continue;
+      const lineNo = match[2] ? Number.parseInt(match[2], 10) : void 0;
+      const key = `${rawPath}:${lineNo ?? ""}`;
+      const existing = anchors.get(key);
+      if (existing) {
+        if (declaredNew && !existing.declaredNew) existing.declaredNew = true;
+        continue;
+      }
+      anchors.set(key, { raw: match[0], path: rawPath, line: lineNo, declaredNew, placeholderShaped: isPlaceholderShaped(rawPath) });
+    }
+  }
+  return [...anchors.values()];
+}
+function isInsideProject(cwd, inputPath) {
+  const rel = relative(resolve(cwd), resolve(cwd, inputPath));
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+}
+var REROOT_EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist"]);
+var REROOT_PROBE_BUDGET = 128;
+var MAX_ROOT_ENUM = 512;
+function listSubdirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !REROOT_EXCLUDE_DIRS.has(e.name)).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function createRerootProbe(cwd) {
+  return {
+    cwd,
+    parent: dirname(cwd),
+    selfName: basename(cwd),
+    probes: 0,
+    roots: null,
+    firstLevel: /* @__PURE__ */ new Map()
+  };
+}
+function probeSpend(p) {
+  if (p.probes >= REROOT_PROBE_BUDGET) return false;
+  p.probes += 1;
+  return true;
+}
+function ensureRerootRoots(p) {
+  if (p.roots) return p.roots;
+  if (!probeSpend(p)) return null;
+  const subs = listSubdirs(p.cwd).slice(0, MAX_ROOT_ENUM);
+  const roots = subs.map((n) => ({ label: `${n}/`, abs: join(p.cwd, n) }));
+  if (p.parent !== p.cwd) {
+    if (!probeSpend(p)) {
+      p.roots = roots;
+      return roots;
+    }
+    const siblings = listSubdirs(p.parent).filter((n) => n !== p.selfName).slice(0, MAX_ROOT_ENUM);
+    roots.push(...siblings.map((n) => ({ label: `../${n}/`, abs: join(p.parent, n) })));
+  }
+  p.roots = roots;
+  return roots;
+}
+function rootFirstLevel(p, rootAbs) {
+  const cached = p.firstLevel.get(rootAbs);
+  if (cached) return cached;
+  if (!probeSpend(p)) return null;
+  const set = new Set(listSubdirs(rootAbs));
+  p.firstLevel.set(rootAbs, set);
+  return set;
+}
+async function probeReroot(p, rel) {
+  if (!probeSpend(p)) return null;
+  const parentHit = await stat(join(p.parent, rel)).catch(() => null);
+  if (parentHit?.isFile()) return { label: "../", abs: p.parent };
+  const roots = ensureRerootRoots(p);
+  if (!roots) return null;
+  const s1 = rel.split("/")[0];
+  for (const root of roots) {
+    const first = rootFirstLevel(p, root.abs);
+    if (!first) return null;
+    if (!first.has(s1)) continue;
+    if (!probeSpend(p)) return null;
+    const hit = await stat(join(root.abs, rel)).catch(() => null);
+    if (hit?.isFile()) return root;
+  }
+  return null;
+}
+async function checkPlanFactAnchors(content, cwd) {
+  const anchors = extractPlanAnchors(content).slice(0, MAX_ANCHORS);
+  const drifts = [];
+  let checked = 0;
+  const pendingReroot = [];
+  let probe = null;
+  const declaredNewPaths = new Set(anchors.filter((a) => a.declaredNew).map((a) => a.path));
+  for (const anchor of anchors) {
+    if (!isInsideProject(cwd, anchor.path)) continue;
+    checked += 1;
+    const absolute = resolve(cwd, anchor.path);
+    if (anchor.declaredNew || declaredNewPaths.has(anchor.path)) {
+      continue;
+    }
+    const fileStat = await stat(absolute).catch(() => null);
+    if (!fileStat || !fileStat.isFile()) {
+      pendingReroot.push(anchor);
+      continue;
+    }
+    if (anchor.line !== void 0 && fileStat.size <= LINE_CHECK_MAX_BYTES) {
+      const text = await readFile(absolute, "utf-8").catch(() => null);
+      if (text !== null) {
+        const lineCount = text.split("\n").length;
+        if (anchor.line > lineCount) {
+          drifts.push({
+            anchor: anchor.raw,
+            path: anchor.path,
+            line: anchor.line,
+            kind: "line-out-of-range",
+            detail: `\u8BA1\u5212\u5F15\u7528 \`${anchor.raw}\`\uFF0C\u4F46\u8BE5\u6587\u4EF6\u5F53\u524D\u53EA\u6709 ${lineCount} \u884C\u2014\u2014\u884C\u53F7\u951A\u70B9\u5DF2\u6F02\u79FB\uFF0C\u91CD\u8BFB\u6587\u4EF6\u66F4\u65B0\u5F15\u7528\u3002`
+          });
+        }
+      }
+    }
+  }
+  if (pendingReroot.length > 0) {
+    probe ??= createRerootProbe(cwd);
+    for (const anchor of pendingReroot) {
+      const hit = await probeReroot(probe, anchor.path);
+      if (hit) {
+        drifts.push({
+          anchor: anchor.raw,
+          path: anchor.path,
+          kind: "root-mismatch",
+          detail: `\u8BA1\u5212\u5F15\u7528 \`${anchor.raw}\`\uFF0C\u76F8\u5BF9\u4F1A\u8BDD\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u4F46\u5B9E\u9645\u4F4D\u4E8E \`${hit.label}${anchor.path}\`\u2014\u2014\u628A\u5F15\u7528\u8865\u5168\u4E3A\u5E26\u6839\u524D\u7F00\u7684\u8DEF\u5F84\uFF0C\u6216\u786E\u8BA4\u6267\u884C\u76EE\u5F55\u540E\u518D\u52A8\u624B\u3002`
+        });
+        continue;
+      }
+      if (anchor.placeholderShaped) continue;
+      drifts.push({
+        anchor: anchor.raw,
+        path: anchor.path,
+        kind: "missing-file",
+        detail: `\u8BA1\u5212\u5F15\u7528 \`${anchor.raw}\`\uFF0C\u4F46\u8BE5\u6587\u4EF6\u5728\u5F53\u524D\u9879\u76EE\u4E2D\u4E0D\u5B58\u5728\u2014\u2014\u7528\u5DE5\u5177\u6838\u5B9E\u771F\u5B9E\u8DEF\u5F84\uFF0C\u6216\u5982\u679C\u662F\u6709\u610F\u65B0\u5EFA\u8BF7\u6807\u6CE8\u300C\u65B0\u589E\u300D\u3002`
+      });
+    }
+  }
+  return { checked, drifts, rerootProbes: probe?.probes ?? 0 };
+}
+function formatAnchorDrifts(drifts) {
+  return drifts.map((d) => `- ${d.detail}`).join("\n");
+}
+
+export {
+  extractPlanAnchors,
+  checkPlanFactAnchors,
+  formatAnchorDrifts
+};

package/dist/chunk-JRF5L6OD.js

@@ -0,0 +1,131 @@
+#!/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 {
+  OFF_TOPIC_ERROR,
+  runBackendChain
+} from "./chunk-EBJTVRQN.js";
+import {
+  DuckDuckGoBackend,
+  createProxyAwareFetch
+} from "./chunk-J4U4AW46.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/web-search.ts
+init_esm_shims();
+
+// src/tools/web-search/tool.ts
+init_esm_shims();
+
+// src/tools/lenient.ts
+init_esm_shims();
+function lenientString(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  return void 0;
+}
+function lenientNumber(v) {
+  if (typeof v === "number") {
+    return Number.isFinite(v) ? v : void 0;
+  }
+  if (typeof v === "string" && v.trim().length > 0) {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function lenientPositiveNumber(v) {
+  const n = lenientNumber(v);
+  return n !== void 0 && n >= 1 ? n : void 0;
+}
+
+// src/tools/web-search/tool.ts
+var MAX_RESULTS = 20;
+var DEFAULT_TIMEOUT_MS = 15e3;
+function createWebSearchTool(deps = {}) {
+  const fetchImpl = deps.fetch ?? createProxyAwareFetch(deps.proxy);
+  const backends = deps.backends && deps.backends.length > 0 ? deps.backends : [new DuckDuckGoBackend(fetchImpl)];
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return {
+    definition: {
+      name: "web_search",
+      description: `\u641C\u7D22 Web \u83B7\u53D6\u5B9E\u65F6\u4FE1\u606F\u3002\u7ED3\u679C\u5305\u542B\u6807\u9898\u3001URL \u548C\u5185\u5BB9\u6458\u8981\u3002
+
+### \u4F55\u65F6\u641C\u7D22
+- \u5F53\u524D/\u65F6\u6548\u6027\u4E8B\u5B9E\uFF08\u6700\u65B0\u53D1\u5E03\u3001breaking changes\u3001\u4ECA\u65E5\u72B6\u6001\uFF09
+- \u4F60\u4E0D\u8BA4\u8BC6\u6216\u8BB0\u4E0D\u51C6\u7684\u7279\u5B9A\u5E93/\u7248\u672C/API/\u62A5\u9519
+- \u4EFB\u4F55\u53EF\u80FD\u5728\u4F60\u8BAD\u7EC3\u622A\u6B62\u540E\u53D1\u751F\u53D8\u5316\u7684\u5185\u5BB9
+- \u4E0D\u8BA4\u8BC6\u7684\u9996\u5B57\u6BCD\u5927\u5199\u540D\u79F0\uFF08\u4EA7\u54C1\u3001\u5DE5\u5177\u3001\u5305\uFF09\uFF1A\u964C\u751F\u540D\u5B57\u66F4\u53EF\u80FD\u662F\u8BAD\u7EC3\u4E4B\u540E\u624D\u51FA\u73B0\u7684\u771F\u5B9E\u4E8B\u7269\uFF0C\u800C\u4E0D\u662F\u53EF\u4EE5\u81C6\u6D4B\u7684\u5BF9\u8C61\u2014\u2014\u641C\u7D22\uFF0C\u4E0D\u8981\u7F16\u9020
+
+### \u4F55\u65F6\u4E0D\u8981\u641C\u7D22
+- \u7A33\u5B9A\u4E8B\u5B9E\u3001\u8BED\u8A00\u8BED\u6CD5\uFF0C\u6216\u4F60\u5DF2\u638C\u63E1\u7684\u6210\u719F\u6982\u5FF5
+- \u672C\u4ED3\u5E93\u5DF2\u6709\u7684\u4EE3\u7801\u2014\u2014\u6539\u7528 grep/read_file/semantic_search
+
+### \u4F7F\u7528\u7ED3\u679C\uFF08\u7F72\u540D\u4E0E\u7248\u6743\uFF09
+- \u7528\u81EA\u5DF1\u7684\u8BDD\u7EFC\u5408\u8F6C\u8FF0\uFF1B\u975E\u663E\u800C\u6613\u89C1\u7684\u8BBA\u65AD\u8981\u6CE8\u660E\u6765\u6E90 URL
+- \u76F4\u63A5\u5F15\u7528\u4FDD\u6301\u7B80\u77ED\uFF08\u7EA6 15 \u8BCD\u4EE5\u5185\uFF09\uFF0C\u6BCF\u4E2A\u6765\u6E90\u6700\u591A\u5F15\u7528\u4E00\u5904
+- \u7EDD\u4E0D\u8981\u9010\u5B57\u590D\u5236\u6587\u7AE0\u6BB5\u843D\u3001\u6B4C\u8BCD\u6216\u8BD7\u6B4C
+- \u6458\u8981\u4E0D\u591F\u7528\u65F6\uFF0C\u7528 web_fetch \u8BFB\u53D6\u5B8C\u6574\u9875\u9762`,
+      input_schema: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "\u641C\u7D22\u67E5\u8BE2\u5B57\u7B26\u4E32"
+          },
+          count: {
+            type: "number",
+            description: "\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF\uFF08\u9ED8\u8BA4\uFF1A10\uFF0C\u6700\u5927\uFF1A20\uFF09\u3002\u4F20 0 \u6216\u8D1F\u6570\u6309\u9ED8\u8BA4 10 \u5904\u7406\u3002"
+          }
+        },
+        required: ["query"]
+      }
+    },
+    async execute(params) {
+      const queryCandidate = lenientString(params.input.query);
+      if (queryCandidate === void 0 || queryCandidate.trim().length === 0) {
+        return { content: "\u9519\u8BEF\uFF1Aquery \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32\u3002", isError: true };
+      }
+      const query = queryCandidate.trim();
+      const count = Math.min(
+        Math.max(1, lenientPositiveNumber(params.input.count) ?? 10),
+        MAX_RESULTS
+      );
+      const { backend, results, errors } = await runBackendChain(backends, query, count, timeoutMs);
+      if (results.length === 0) {
+        const hardErrors = errors.filter((e) => e.message !== "no results" && e.message !== OFF_TOPIC_ERROR);
+        if (hardErrors.length > 0) {
+          const detail = hardErrors.map((e) => `${e.backend}: ${e.message}`).join("; ");
+          return { content: `\u641C\u7D22\u5931\u8D25\uFF08${detail}\uFF09`, isError: true };
+        }
+        return { content: `\u672A\u627E\u5230\u4E0E\u300C${query}\u300D\u76F8\u5173\u7684\u641C\u7D22\u7ED3\u679C` };
+      }
+      const formatted = results.map((r, i) => {
+        const meta = [r.siteName, r.publishedAt].filter(Boolean).join(" \xB7 ");
+        const snippet = r.snippet + (meta ? `\uFF08${meta}\uFF09` : "");
+        return `${i + 1}. [${r.title}](${r.url})
+   ${snippet}`;
+      }).join("\n\n");
+      const via = backend ? `\uFF08\u7ECF ${backend}\uFF09` : "";
+      return { content: `\u300C${query}\u300D\u7684\u7F51\u9875\u641C\u7D22\u7ED3\u679C${via}\uFF1A
+
+${formatted}` };
+    },
+    requiresApproval() {
+      return true;
+    },
+    isConcurrencySafe() {
+      return true;
+    },
+    isEnabled() {
+      return true;
+    }
+  };
+}
+var WEB_SEARCH_TOOL = createWebSearchTool();
+
+export {
+  createWebSearchTool,
+  WEB_SEARCH_TOOL
+};