tensor-cli 0.1.4-beta-lite → 0.1.5-beta-lite

package/dist/index.js

@@ -340793,6 +340793,222 @@ async function webSearch(query, budget, limit = DEFAULT_LIMIT) {
   }
 }
 
+// src/tools/harness-verify.ts
+var VERIFY_MAX_REVISIONS = 1;
+var VERIFY_MIN_CHARS = 400;
+var AUTO_FULL_MIN_CHARS = 1500;
+var VERIFY_CONTENT_CHAR_CAP = 24000;
+var VERIFY_SOURCE_CHAR_CAP = 12000;
+var VERIFIER_MAX_TOKENS = 600;
+function formatFindings(findings) {
+  return findings.map((f2, i2) => `${i2 + 1}. ${f2.issue}${f2.evidence ? ` (${f2.evidence})` : ""}`).join(`
+`);
+}
+var TOOL_TAG_RE = /<tool_call\b|<function=|<parameter=|<tool_use\b|<file_path>/i;
+var ELISION_RE = /^[ \t]*(?:\/\/|#|\/\*|<!--)[ \t]*(?:\.{3}|\u2026)[ \t]*(?:rest|existing|remaining|other|previous|unchanged|same)\b|^[ \t]*(?:\/\/|#|\/\*)[ \t]*(?:rest of|remaining|existing)[ \t]+(?:the[ \t]+)?(?:code|file|implementation|content)\b/im;
+var LOADERS = {
+  ".ts": "ts",
+  ".tsx": "tsx",
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx"
+};
+function extOf(file2) {
+  const dot = file2.lastIndexOf(".");
+  return dot > file2.lastIndexOf("/") ? file2.slice(dot).toLowerCase() : "";
+}
+function syntaxError(file2, content) {
+  const loader = LOADERS[extOf(file2)];
+  if (!loader)
+    return null;
+  const Transpiler = globalThis.Bun?.Transpiler;
+  if (!Transpiler)
+    return null;
+  try {
+    new Transpiler({ loader }).transformSync(content);
+    return null;
+  } catch (e3) {
+    const errs = e3.errors;
+    const msg = Array.isArray(errs) && errs.length > 0 ? errs.slice(0, 3).map((x) => x.message ?? String(x)).join("; ") : e3 instanceof Error ? e3.message : String(e3);
+    return clipText(msg, 300);
+  }
+}
+function deterministicChecks(file2, content, mode) {
+  if (content.trim() === "")
+    return [{ issue: "content is empty", hard: true }];
+  const out = [];
+  const ext = extOf(file2);
+  if (TOOL_TAG_RE.test(content)) {
+    out.push({ issue: "content contains leaked tool-call markup", hard: true });
+  }
+  if (/^```/.test(content.trimStart()) && ext !== ".md" && ext !== ".mdx") {
+    out.push({ issue: "content starts with a markdown code fence", hard: true });
+  }
+  if (mode === "write") {
+    const elision = DOC_EXT.has(ext) ? null : ELISION_RE.exec(content);
+    if (elision) {
+      out.push({
+        issue: "content contains an elision placeholder (e.g. 'rest of file unchanged'); a write must contain the complete file",
+        evidence: clipText(elision[0].trim(), 80)
+      });
+    }
+    if (ext === ".json" && !/(^|\/)(tsconfig|jsconfig)[^/]*\.json$/.test(file2)) {
+      try {
+        JSON.parse(content);
+      } catch (e3) {
+        out.push({
+          issue: "invalid JSON",
+          evidence: clipText(e3 instanceof Error ? e3.message : String(e3), 200),
+          hard: true
+        });
+      }
+    }
+    const se = syntaxError(file2, content);
+    if (se)
+      out.push({ issue: "syntax error", evidence: se, hard: true });
+  }
+  return out;
+}
+function parseVerifyMode(v) {
+  const x = (v ?? "").trim().toLowerCase();
+  if (x === "off" || x === "0" || x === "false")
+    return "off";
+  if (x === "checks")
+    return "checks";
+  if (x === "full" || x === "1" || x === "true")
+    return "full";
+  return "auto";
+}
+var DOC_EXT = new Set([".md", ".mdx", ".txt", ".rst"]);
+function chooseVerifyLevel(a2) {
+  if (a2.mode === "checks" || a2.mode === "full")
+    return a2.mode;
+  const shrinks = a2.tool === "write" && a2.currentFile.length >= 400 && a2.content.length < a2.currentFile.length * 0.5;
+  if (shrinks)
+    return "full";
+  if (DOC_EXT.has(extOf(a2.file)))
+    return "checks";
+  const overwrite = a2.tool === "write" && a2.currentFile.trim() !== "";
+  if (overwrite && a2.content.length >= VERIFY_MIN_CHARS)
+    return "full";
+  if (a2.content.length >= AUTO_FULL_MIN_CHARS)
+    return "full";
+  return "checks";
+}
+var VERIFIER_SYSTEM = `You are a strict reviewer. You did NOT write the proposed content below; your only job is to find concrete, checkable problems in it. Do not praise it.
+` + `Check ONLY these:
+` + `1. It does what the TASK and INTENT ask. Missing or contradicted requirements count.
+` + `2. It does not reference imports, functions, files, fields or APIs that appear in neither the SOURCES nor the standard library / well-known packages.
+` + `3. For a whole-file REPLACE: it does not silently drop existing behaviour from CURRENT FILE that the task did not ask to remove.
+` + `4. It is complete: no TODO stubs standing in for required logic, no "rest unchanged" elisions, no truncated ending.
+` + `Do NOT fail for style, naming, formatting or optional improvements. If you cannot tell from the SOURCES, pass.
+` + `Respond with ONLY one JSON object: {"pass": boolean, "failures": [{"issue": string, "evidence": string}]}. ` + `"failures" is empty when pass is true. Each evidence is a short quote or location from the content.`;
+async function modelVerify(a2, content) {
+  const target = a2.mode === "append" ? "the content below will be APPENDED to the end of the file" : a2.currentFile ? "the content below will REPLACE the whole file" : "this is a NEW file";
+  const sources = a2.sources.map((s2, i2) => `[Source ${i2 + 1}]
+${clipText(s2, 5000)}`).join(`
+
+`);
+  const user = `TASK (the user's request):
+${clipText(a2.task, 1500)}
+
+` + `INTENT of this step:
+${clipText(a2.intent, 500)}
+
+` + `TARGET FILE: ${a2.file} (${target})
+
+` + (a2.currentFile ? `CURRENT FILE ON DISK:
+${clipText(a2.currentFile, VERIFY_SOURCE_CHAR_CAP / 2)}
+
+` : "") + (sources ? `SOURCES (files the agent read):
+${sources}
+
+` : "") + `PROPOSED CONTENT:
+${clipText(content, VERIFY_CONTENT_CHAR_CAP)}`;
+  let raw = "";
+  try {
+    raw = await a2.chat([
+      { role: "system", content: VERIFIER_SYSTEM },
+      { role: "user", content: user }
+    ], VERIFIER_MAX_TOKENS);
+  } catch {
+    return { available: false, failures: [] };
+  }
+  const json3 = extractFirstJsonObject(raw);
+  if (!json3)
+    return { available: false, failures: [] };
+  let parsed;
+  try {
+    parsed = JSON.parse(json3);
+  } catch {
+    return { available: false, failures: [] };
+  }
+  if (!isRecord2(parsed) || typeof parsed.pass !== "boolean") {
+    return { available: false, failures: [] };
+  }
+  if (parsed.pass)
+    return { available: true, failures: [] };
+  const failures = (Array.isArray(parsed.failures) ? parsed.failures : []).filter(isRecord2).map((f2) => ({
+    issue: String(f2.issue ?? "").trim().slice(0, 300),
+    evidence: f2.evidence ? String(f2.evidence).trim().slice(0, 300) : undefined
+  })).filter((f2) => f2.issue !== "").slice(0, 5);
+  return { available: true, failures };
+}
+async function verifyBeforeWrite(a2) {
+  let content = a2.content;
+  let revisions = 0;
+  let verifierCalls = 0;
+  let verifierUnavailable = false;
+  let findings = [];
+  let cleanDraft = null;
+  let cleanDraftFindings = [];
+  const result = (c2, status, f2) => ({
+    content: c2,
+    status,
+    findings: f2,
+    revisions,
+    verifierCalls,
+    verifierUnavailable
+  });
+  for (;; ) {
+    const det = deterministicChecks(a2.file, content, a2.mode);
+    findings = det;
+    if (a2.level === "full" && det.length === 0 && !a2.isCancelled?.()) {
+      verifierCalls++;
+      const v = await modelVerify(a2, content);
+      if (v.available)
+        findings = v.failures;
+      else
+        verifierUnavailable = true;
+    }
+    if (!findings.some((f2) => f2.hard)) {
+      cleanDraft = content;
+      cleanDraftFindings = findings;
+    }
+    if (findings.length === 0)
+      return result(content, "verified", []);
+    if (revisions >= VERIFY_MAX_REVISIONS || a2.isCancelled?.())
+      break;
+    revisions++;
+    const first = findings[0];
+    a2.log?.(`Revising ${a2.file}: ${first?.issue ?? "failed check"}${first?.evidence ? ` [${first.evidence}]` : ""}`);
+    let revised = "";
+    try {
+      revised = await a2.revise(content, findings);
+    } catch {}
+    if (revised.trim() === "" || revised === content)
+      break;
+    content = revised;
+  }
+  if (findings.some((f2) => f2.hard)) {
+    if (cleanDraft !== null)
+      return result(cleanDraft, "unverified", cleanDraftFindings);
+    return result(content, "blocked", findings);
+  }
+  return result(content, "unverified", findings);
+}
+
 // src/tools/harness-orchestrator.ts
 function estimateMessagesTokens(messages) {
   let textTokens = 0;
@@ -340840,6 +341056,124 @@ class HarnessOrchestrator {
     this.totalUsedContext = countTokens2(this.buildDecisionPrompt(false));
   }
   filePluginHandler = null;
+  static VERIFY_MODE = parseVerifyMode("full");
+  verifyStats = {
+    checked: 0,
+    full: 0,
+    revised: 0,
+    verifierCalls: 0,
+    unverified: 0,
+    blocked: 0
+  };
+  getVerifyStats() {
+    return { ...this.verifyStats };
+  }
+  async* preWriteGate(ctx, a2) {
+    const mode = HarnessOrchestrator.VERIFY_MODE;
+    if (mode === "off") {
+      return {
+        content: a2.content,
+        status: "verified",
+        findings: [],
+        revisions: 0,
+        verifierCalls: 0,
+        verifierUnavailable: false
+      };
+    }
+    const currentFile = existsSync(a2.filePath) ? await readFileContent(a2.filePath).catch(() => "") : "";
+    const level = chooseVerifyLevel({
+      mode,
+      file: a2.displayPath,
+      tool: a2.tool,
+      content: a2.content,
+      currentFile
+    });
+    const lines = [];
+    const out = yield* this.pump(verifyBeforeWrite({
+      file: a2.displayPath,
+      mode: a2.tool,
+      content: a2.content,
+      task: ctx.userTask,
+      intent: a2.intent,
+      currentFile,
+      sources: level === "full" ? this.verifySources(ctx, a2.displayPath) : [],
+      level,
+      isCancelled: this.isCancelled,
+      log: (l) => lines.push(l),
+      chat: (messages, maxTokens) => this.routedChat(a2.verifierModelId, messages, 0.1, maxTokens).then((r) => r.content),
+      revise: (draft, findings) => this.reviseContent(ctx, a2, draft, findings)
+    }));
+    const s2 = this.verifyStats;
+    s2.checked++;
+    if (level === "full")
+      s2.full++;
+    s2.revised += out.revisions;
+    s2.verifierCalls += out.verifierCalls;
+    if (out.status === "unverified")
+      s2.unverified++;
+    if (out.status === "blocked")
+      s2.blocked++;
+    for (const l of lines)
+      yield { delta: `- ${l}
+` };
+    if (out.status === "unverified") {
+      yield {
+        delta: `- ${a2.displayPath} did not pass every check (${out.findings[0]?.issue ?? "see findings"}); writing it anyway and flagging it
+
+`
+      };
+    }
+    if (DEBUG_TRACE) {
+      yield {
+        delta: `[debug] pre-write gate: ${out.status}, ${out.verifierCalls} verifier call(s), ${out.revisions} revision(s)
+`
+      };
+    }
+    return out;
+  }
+  async reviseContent(ctx, a2, draft, findings) {
+    const res = await this.routedChat(ctx.modelId, [
+      {
+        role: "system",
+        content: `RAW CODE OUTPUT MODE. Respond with ONLY the raw ${a2.tool === "append" ? "text to append" : "complete file"}. ` + `No JSON, no markdown fences, no commentary. The first character of your response must be the first character of the content.`
+      },
+      ...this.memoryMessages(),
+      {
+        role: "user",
+        content: `Task: ${clipText(ctx.userTask, 3000)}
+` + `Target file: ${a2.targetFile}
+
+` + `Your previous draft was rejected for these problems:
+${formatFindings(findings)}
+
+` + `Previous draft:
+${draft}
+
+` + `Return the corrected ${a2.tool === "append" ? "text to append" : "complete file"}. ` + `Fix only the listed problems and keep everything else unchanged.`
+      }
+    ], 0.2, CONTENT_MAX_TOKENS);
+    if (res.content.startsWith("AGENT LOOP FAILED"))
+      return "";
+    let text = res.content.replace(/^```[a-z]*\n?|\n?```$/g, "").trim();
+    const { unwrapped, wasWrapper } = tryUnwrapDecisionJson(text);
+    if (wasWrapper)
+      text = (unwrapped ?? "").trim();
+    return text;
+  }
+  verifySources(ctx, displayPath) {
+    const out = [];
+    for (let i2 = ctx.contextMessages.length - 1;i2 >= 0 && out.length < 3; i2--) {
+      const c2 = ctx.contextMessages[i2]?.content;
+      if (typeof c2 !== "string" || !c2.startsWith("[Tool Output \u2014 read on "))
+        continue;
+      if (c2.includes(`read on ${displayPath}]`))
+        continue;
+      if (c2.includes("elided to save context"))
+        continue;
+      out.push(c2.slice(0, 5000));
+    }
+    return out;
+  }
   registerFileHandler(handler) {
     this.filePluginHandler = handler;
   }
@@ -342675,6 +343009,43 @@ ${truncateForContext(priorFileSnapshot)}
           }
         }
         ctx.updateThinkingWord?.("toolLeveraging");
+        if (HarnessOrchestrator.VERIFY_MODE !== "off" && (decision.tool === "write" || decision.tool === "append") && typeof decision.content === "string" && decision.content.trim() !== "") {
+          const draft = decision.content;
+          const gate = yield* this.preWriteGate(ctx, {
+            tool: decision.tool,
+            targetFile: decision.targetFile,
+            displayPath,
+            filePath,
+            content: draft,
+            intent: decision.reasoning ?? "",
+            verifierModelId: decisionModelId
+          });
+          if (gate.status === "blocked") {
+            this.settleToolCall(call, "refused", `pre-write check failed: ${gate.findings[0]?.issue ?? "invalid content"}`);
+            yield { delta: `- Not written: ${displayPath} failed pre-write checks
+
+` };
+            ctx.contextMessages.push({
+              role: "user",
+              content: `[System] The content for "${decision.targetFile}" failed checks and was NOT written:
+${formatFindings(gate.findings)}
+Fix these and try again, or return {"tool": null}.`
+            });
+            continue;
+          }
+          if (gate.content !== draft) {
+            decision = { ...decision, content: gate.content };
+            verifiedContentOverride = null;
+          }
+          if (gate.status === "unverified") {
+            ctx.contextMessages.push({
+              role: "user",
+              content: `[System] "${decision.targetFile}" is being written but did not pass every check:
+${formatFindings(gate.findings)}
+Tell the user about these in your final answer.`
+            });
+          }
+        }
         const breakOnSemicolons = (text, indent = "   ") => {
           return text.replace(/; ?/g, `;
 ${indent}`);
@@ -344476,7 +344847,7 @@ var Header = () => {
           }, undefined, false, undefined, this),
           /* @__PURE__ */ import_jsx_dev_runtime2.jsxDEV("text", {
             fg: t2.inkFaint,
-            children: "v0.1.4@beta-lite"
+            children: "v0.1.5@beta-lite"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tensor-cli",
-  "version": "0.1.4-beta-lite",
+  "version": "0.1.5-beta-lite",
   "type": "module",
   "bin": {
     "tensor": "./dist/index.js"