tianshu-harness 3.23.0

package/dist/chunk-UXNLELW6.js

@@ -0,0 +1,25 @@
+#!/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/utils/safe-path.ts
+init_esm_shims();
+var ANSI_SEQ_RE = /\x1B(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[@-Z\\-_])/g;
+function stripTerminalEscapes(text) {
+  return text.replace(ANSI_SEQ_RE, "").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, " ");
+}
+var MAX_NAME_LENGTH = 200;
+function isSafeFileName(name) {
+  if (!name || name.length > MAX_NAME_LENGTH) return false;
+  if (name.includes("/") || name.includes("\\") || name.includes("\0")) return false;
+  if (name.startsWith(".")) return false;
+  if (name.includes("..")) return false;
+  return true;
+}
+
+export {
+  stripTerminalEscapes,
+  isSafeFileName
+};

package/dist/chunk-UXXS53EA.js

@@ -0,0 +1,166 @@
+#!/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/registry.ts
+init_esm_shims();
+
+// src/tools/did-you-mean.ts
+init_esm_shims();
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  const aLen = a.length;
+  const bLen = b.length;
+  if (aLen === 0) return bLen;
+  if (bLen === 0) return aLen;
+  let prev = new Array(bLen + 1);
+  let curr = new Array(bLen + 1);
+  for (let j = 0; j <= bLen; j++) prev[j] = j;
+  for (let i = 1; i <= aLen; i++) {
+    curr[0] = i;
+    const aCharCode = a.charCodeAt(i - 1);
+    for (let j = 1; j <= bLen; j++) {
+      const cost = aCharCode === b.charCodeAt(j - 1) ? 0 : 1;
+      const insert = (curr[j - 1] ?? 0) + 1;
+      const del = (prev[j] ?? 0) + 1;
+      const sub = (prev[j - 1] ?? 0) + cost;
+      const m1 = insert < del ? insert : del;
+      curr[j] = m1 < sub ? m1 : sub;
+    }
+    const tmp = prev;
+    prev = curr;
+    curr = tmp;
+  }
+  return prev[bLen] ?? 0;
+}
+function didYouMean(input, candidates, options = {}) {
+  if (candidates.length === 0 || input.length === 0) return [];
+  const topK = options.topK ?? 3;
+  const inputLen = input.length;
+  const maxDistance = options.maxDistance ?? Math.max(2, Math.floor(inputLen / 4));
+  const scored = [];
+  for (const candidate of candidates) {
+    if (candidate.length === 0) continue;
+    const d = levenshtein(input, candidate);
+    if (d <= maxDistance) scored.push({ name: candidate, distance: d });
+  }
+  if (scored.length > 0) {
+    scored.sort((a, b) => a.distance - b.distance || a.name.localeCompare(b.name));
+    return scored.slice(0, topK).map((s) => s.name);
+  }
+  const substringHits = [];
+  for (const candidate of candidates) {
+    if (candidate.length === 0) continue;
+    if (candidate.includes(input) || input.includes(candidate)) {
+      substringHits.push(candidate);
+    }
+  }
+  substringHits.sort((a, b) => a.localeCompare(b));
+  return substringHits.slice(0, topK);
+}
+function didYouMeanHint(input, allToolNames) {
+  if (allToolNames.length === 0) {
+    return "No tools are registered.";
+  }
+  const suggestions = didYouMean(input, allToolNames);
+  const parts = [];
+  if (suggestions.length > 0) {
+    parts.push(`Did you mean: ${suggestions.join(", ")}?`);
+  }
+  const sorted = allToolNames.slice().sort();
+  parts.push(`Available tools: ${sorted.join(", ")}`);
+  return parts.join(" ");
+}
+
+// src/tools/registry.ts
+var FOREIGN_ALIASES = {
+  todowrite: "todo",
+  task: "delegate_task",
+  agent: "delegate_task"
+};
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.definition.name, tool);
+  }
+  /** Remove a tool by name. No-op if not registered. Returns true if removed. */
+  remove(name) {
+    return this.tools.delete(name);
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  has(name) {
+    return this.tools.has(name);
+  }
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /** Names of every registered tool, sorted for stable did-you-mean hints. */
+  getAllNames() {
+    return Array.from(this.tools.keys()).sort();
+  }
+  getDefinitions() {
+    return this.getAll().filter((t) => t.isEnabled()).map((t) => t.definition).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  /**
+   * Resolve a possibly-foreign tool name to its canonical registered name.
+   * Returns the input unchanged when it is already registered or no alias
+   * matches. The tool pipeline calls this BEFORE its permission gates
+   * (plan-mode, deny rules, approval, risk) so aliases cannot slip past
+   * policies keyed on the canonical name.
+   */
+  resolveName(name) {
+    if (this.tools.has(name)) return name;
+    const aliasKey = FOREIGN_ALIASES[name.toLowerCase()];
+    if (aliasKey && this.tools.has(aliasKey)) return aliasKey;
+    return name;
+  }
+  async execute(name, params) {
+    let tool = this.tools.get(name);
+    let resolvedName = name;
+    let aliasNote;
+    if (!tool) {
+      const aliasKey = FOREIGN_ALIASES[name.toLowerCase()];
+      if (aliasKey) {
+        tool = this.tools.get(aliasKey);
+        if (tool) {
+          resolvedName = aliasKey;
+          aliasNote = `[NOTE: "${name}" \u81EA\u52A8\u6620\u5C04\u4E3A "${aliasKey}" \u2014 \u4E0B\u6B21\u8BF7\u76F4\u63A5\u8C03 ${aliasKey}]`;
+        }
+      }
+    }
+    if (!tool) {
+      const hint = didYouMeanHint(name, this.getAllNames());
+      throw new Error(`Unknown tool: ${name}. If this is an EXTENDED-layer tool, use delegate_task to dispatch a worker, or /tools enable <name> to mount it on the primary agent. ${hint}`);
+    }
+    if (!tool.isEnabled()) throw new Error(`Tool ${resolvedName} is disabled`);
+    const result = await tool.execute(params);
+    if (aliasNote) {
+      result.content = `${aliasNote}
+${result.content}`;
+    }
+    return result;
+  }
+  needsApproval(name, params) {
+    const tool = this.tools.get(name);
+    if (!tool) return false;
+    return tool.requiresApproval(params);
+  }
+};
+function filterToolRegistry(source, allowedNames) {
+  const filtered = new ToolRegistry();
+  for (const name of allowedNames) {
+    const tool = source.get(name);
+    if (!tool) throw new Error(`Cannot allowlist unknown tool: ${name}`);
+    filtered.register(tool);
+  }
+  return filtered;
+}
+
+export {
+  ToolRegistry,
+  filterToolRegistry
+};

package/dist/chunk-V5DHFGI7.js

@@ -0,0 +1,171 @@
+#!/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 {
+  redactText,
+  redactValue,
+  truncateUtf16Safe
+} from "./chunk-ML3UKMH3.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/event-tap.ts
+init_esm_shims();
+var RESULT_CAP = 2e3;
+var DELTA_FLUSH_CHARS = 4e3;
+function tapAgentCallbacks(inner, sink) {
+  let seq = 0;
+  let pending = null;
+  const write = (type, data) => {
+    seq += 1;
+    try {
+      sink({ seq, ts: Date.now(), type, data });
+    } catch {
+    }
+  };
+  const flush = () => {
+    if (!pending) return;
+    const buf = pending;
+    pending = null;
+    write(buf.type, { text: buf.text });
+  };
+  const emit = (type, data) => {
+    flush();
+    write(type, data);
+  };
+  const delta = (type, text) => {
+    if (!text) return;
+    if (pending && pending.type !== type) flush();
+    pending = { type, text: (pending?.text ?? "") + text };
+    if (pending.text.length >= DELTA_FLUSH_CHARS) flush();
+  };
+  const tapped = {
+    ...inner,
+    flush,
+    onTextDelta: (text) => {
+      delta("text_delta", redactText(text));
+      inner.onTextDelta(text);
+    },
+    onThinkingDelta: (thinking) => {
+      delta("thinking_delta", redactText(thinking));
+      inner.onThinkingDelta(thinking);
+    },
+    onToolUse: (id, name, input) => {
+      emit("tool_use", { id, name, input: redactValue(input) });
+      inner.onToolUse(id, name, input);
+    },
+    onToolResult: (id, name, result, isError, rawPath, uiContent) => {
+      if (isError !== void 0) {
+        emit("tool_result", {
+          id,
+          name,
+          isError: !!isError,
+          result: truncateUtf16Safe(redactText(result), RESULT_CAP)
+        });
+      }
+      inner.onToolResult(id, name, result, isError, rawPath, uiContent);
+    },
+    onTurnComplete: (usage, turnNumber, isFinal, evidenceSummary) => {
+      emit("turn_complete", { usage, turnNumber, isFinal: !!isFinal });
+      inner.onTurnComplete(usage, turnNumber, isFinal, evidenceSummary);
+    },
+    onError: (error) => {
+      emit("error", { error: redactText(error.message) });
+      inner.onError(error);
+    },
+    onAbort: (reason) => {
+      emit("status", { status: "aborted", ...reason ? { reason } : {} });
+      inner.onAbort(reason);
+    },
+    onApprovalRequired: async (id, name, input) => {
+      emit("approval_required", { requestId: id, toolName: name, input: redactValue(input) });
+      const result = await inner.onApprovalRequired(id, name, input);
+      const approved = typeof result === "boolean" ? result : result.approved;
+      emit("approval_resolved", { requestId: id, decision: approved ? "approve" : "reject" });
+      return result;
+    }
+  };
+  if (inner.onCheckpoint) {
+    const fn = inner.onCheckpoint.bind(inner);
+    tapped.onCheckpoint = (hash) => {
+      emit("checkpoint", { hash });
+      fn(hash);
+    };
+  }
+  if (inner.onPhaseChange) {
+    const fn = inner.onPhaseChange.bind(inner);
+    tapped.onPhaseChange = (phase, detail) => {
+      emit("phase", { phase, ...detail });
+      fn(phase, detail);
+    };
+  }
+  if (inner.onIntentNote) {
+    const fn = inner.onIntentNote.bind(inner);
+    tapped.onIntentNote = (intent) => {
+      emit("intent_note", redactValue(intent));
+      fn(intent);
+    };
+  }
+  if (inner.onDecisionShift) {
+    const fn = inner.onDecisionShift.bind(inner);
+    tapped.onDecisionShift = (shift) => {
+      emit("decision_shift", redactValue(shift));
+      fn(shift);
+    };
+  }
+  if (inner.onDomainDrift) {
+    const fn = inner.onDomainDrift.bind(inner);
+    tapped.onDomainDrift = (drift) => {
+      emit("domain_drift", redactValue(drift));
+      fn(drift);
+    };
+  }
+  if (inner.onDelegationActivity) {
+    const fn = inner.onDelegationActivity.bind(inner);
+    const delegationStartedAt = /* @__PURE__ */ new Map();
+    tapped.onDelegationActivity = (a) => {
+      let started = delegationStartedAt.get(a.workOrderId);
+      if (started === void 0) {
+        started = Date.now();
+        delegationStartedAt.set(a.workOrderId, started);
+      }
+      emit("delegation", {
+        workerId: a.workOrderId,
+        parentId: a.parentToolId,
+        // 嵌套委派的父 worker order id（与 sidecar emitDelegationActivity 对齐）。
+        parentWorkerId: a.parentWorkerId,
+        profile: a.profile,
+        authority: a.authority,
+        authorityReason: a.authorityReason,
+        objective: a.objective,
+        status: a.status,
+        phase: a.status === "running" ? "running" : a.status,
+        progressLine: a.progressLine ? redactText(a.progressLine) : void 0,
+        elapsedMs: Date.now() - started,
+        toolUseCount: a.toolUseCount,
+        tokenCount: a.tokenCount,
+        eventKind: a.eventKind,
+        eventDetail: a.eventDetail ? redactText(a.eventDetail) : void 0,
+        failureReason: a.failureReason,
+        model: a.model,
+        provider: a.provider,
+        usage: a.usage,
+        artifactId: a.artifactId,
+        changedFiles: a.changedFiles,
+        summary: a.summary ? redactText(a.summary) : void 0,
+        origin: a.origin,
+        contract: a.contract,
+        findingsCount: a.findingsCount,
+        topFinding: a.topFinding ? redactText(a.topFinding) : void 0,
+        verificationBrief: a.verificationBrief,
+        evidenceStatus: a.evidenceStatus
+      });
+      fn(a);
+    };
+  }
+  return tapped;
+}
+
+export {
+  tapAgentCallbacks
+};