tldr-experts 0.9.2 → 0.11.0

package/dist/hooks/answer-capture.js

@@ -1,33 +1,41 @@
 #!/usr/bin/env node
 import {
-  FactsStore
-} from "./chunk-f6484ykg.js";
+  conflictOf
+} from "./chunk-bk7rkdzw.js";
+import {
+  FactsStore,
+  formatJaccard
+} from "./chunk-kqvbzyc0.js";
 import {
   parseHookInput,
   readStdin
-} from "./chunk-x3zy7zrn.js";
+} from "./chunk-6c84kjd7.js";
 import {
   EventLog,
   PHASE_ID_RE
-} from "./chunk-fv66tdsm.js";
-import"./chunk-5w5eg00k.js";
-import"./chunk-8awygmqw.js";
+} from "./chunk-9v45j71e.js";
+import"./chunk-tg7ppsxr.js";
 import {
+  ADVISORY_KEY,
   MAX_FACT_CHARS,
   detectAnswered,
   parseQuestions,
   recordAnswer,
+  renderQuestionBlock,
   replaceBlock,
   serializeQuestions
-} from "./chunk-vyvjbbmb.js";
-import"./chunk-39zh2e44.js";
+} from "./chunk-wzzywf6c.js";
 import {
+  ITERATION_ONLY_SLOT,
+  PROJECT_FRAMEWORK_DIR,
   PROJECT_WORK_DIR,
-  factsPath
-} from "./chunk-y3cxqvnx.js";
+  commandProbeIssues,
+  factsPath,
+  parseYaml
+} from "./chunk-r1efatxk.js";
 
 // src/hooks/answer-capture.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 
 // src/hooks/lib/decide.ts
 function allow() {
@@ -69,6 +77,7 @@ function filePathOf(payload) {
 }
 
 // src/hooks/lib/workspace.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 function locateWork(filePath) {
   if (filePath === "")
@@ -88,6 +97,111 @@ function locateWork(filePath) {
     relative: parts.slice(at + 2).join("/")
   };
 }
+var FALLBACK_DEFAULT_BRANCH = "main";
+function commandRolesOf(doc) {
+  const out = new Map;
+  const list = doc?.repos;
+  if (!Array.isArray(list))
+    return out;
+  for (const entry of list) {
+    if (typeof entry?.name !== "string")
+      continue;
+    const roles = new Map;
+    const cmds = entry.commands;
+    if (cmds !== null && typeof cmds === "object") {
+      for (const [role, value] of Object.entries(cmds)) {
+        if (typeof value !== "string" || value.trim() === "")
+          continue;
+        roles.set(role, value);
+      }
+    }
+    out.set(entry.name, roles);
+  }
+  return out;
+}
+function commandProbesOf(doc) {
+  const out = new Map;
+  const list = doc?.repos;
+  if (!Array.isArray(list))
+    return out;
+  for (const entry of list) {
+    if (typeof entry?.name !== "string")
+      continue;
+    const probes = new Map;
+    const raw = entry.command_probes;
+    if (raw !== null && typeof raw === "object" && !Array.isArray(raw)) {
+      for (const [slot, value] of Object.entries(raw)) {
+        if (commandProbeIssues(value, slot).length > 0)
+          continue;
+        probes.set(slot, value);
+      }
+    }
+    out.set(entry.name, probes);
+  }
+  return out;
+}
+function loadWorkspace(root) {
+  const repos = new Map;
+  const commands = new Set;
+  const repoCommands = new Map;
+  const commandRoles = new Map;
+  const commandProbes = new Map;
+  const iterationCommands = new Set;
+  const defaultBranches = new Map;
+  let seedTriageThresholdTokens = null;
+  const empty = () => ({
+    root,
+    repos,
+    commands,
+    repoCommands,
+    commandRoles,
+    commandProbes,
+    iterationCommands,
+    defaultBranches,
+    seedTriageThresholdTokens
+  });
+  const path = join(root, PROJECT_FRAMEWORK_DIR, "workspace.yml");
+  if (!existsSync(path))
+    return empty();
+  let doc;
+  try {
+    doc = parseYaml(readFileSync(path, "utf8"));
+  } catch {
+    return empty();
+  }
+  const triage = doc?.seed_triage;
+  if (triage !== null && typeof triage === "object") {
+    const tokens = triage.threshold_tokens;
+    if (typeof tokens === "number" && Number.isFinite(tokens) && tokens > 0) {
+      seedTriageThresholdTokens = tokens;
+    }
+  }
+  const list = doc?.repos;
+  if (!Array.isArray(list))
+    return empty();
+  const declared = commandRolesOf(doc);
+  const measured = commandProbesOf(doc);
+  for (const entry of list) {
+    if (typeof entry?.name !== "string")
+      continue;
+    repos.set(entry.name, typeof entry.path === "string" ? entry.path : ".");
+    defaultBranches.set(entry.name, typeof entry.default_branch === "string" && entry.default_branch !== "" ? entry.default_branch : FALLBACK_DEFAULT_BRANCH);
+    const own = [];
+    const roles = declared.get(entry.name) ?? new Map;
+    for (const value of roles.values()) {
+      commands.add(value);
+      if (!own.includes(value))
+        own.push(value);
+    }
+    repoCommands.set(entry.name, own);
+    commandRoles.set(entry.name, roles);
+    const fast = roles.get(ITERATION_ONLY_SLOT);
+    if (fast !== undefined)
+      iterationCommands.add(fast);
+    commandProbes.set(entry.name, measured.get(entry.name) ?? new Map);
+  }
+  return empty();
+}
 
 // src/hooks/lib/actor.ts
 function currentActor() {
@@ -99,10 +213,10 @@ function nowRfc3339() {
 }
 
 // src/core/answers/captureAnswers.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync } from "node:fs";
 
 // src/core/answers/stampSuperseded.ts
-import { appendFileSync, existsSync, readFileSync, statSync } from "node:fs";
+import { appendFileSync, existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
 import { isAbsolute as isAbsolute2, join as join2, relative } from "node:path";
 var STAMP_MARKER = "tldrx:superseded";
 var AFFECTS_KEY = "affects";
@@ -142,7 +256,7 @@ function stampSuperseded(runDir, questionsPath, block, fact, at) {
   const questionsRel = runRelative(runDir, questionsPath) ?? "questions.md";
   const stamped = [];
   for (const doc of affectedDocs(runDir, questionsPath, block)) {
-    const text = readFileSync(doc.abs, "utf8");
+    const text = readFileSync2(doc.abs, "utf8");
     if (isStamped(text, fact))
       continue;
     const lead = text === "" ? "" : text.endsWith(`
@@ -167,7 +281,7 @@ function resolveInRun(runDir, raw) {
     const rel = runRelative(runDir, candidate);
     if (rel === null)
       continue;
-    if (!existsSync(candidate) || !statSync(candidate).isFile())
+    if (!existsSync2(candidate) || !statSync2(candidate).isFile())
       continue;
     return rel;
   }
@@ -187,7 +301,113 @@ function isEarlier(phase, than) {
   return Number(phase.slice(0, 2)) < Number(than.slice(0, 2));
 }
 
+// src/core/answers/reposFromAffects.ts
+function uniqueRepos(names) {
+  return [...new Set(names)];
+}
+function reposFromAffects(affects, repoNames) {
+  const repos = [];
+  const unresolved = [];
+  for (const raw of affects) {
+    const entry = raw.trim();
+    if (entry === "")
+      continue;
+    if (repoNames.has(entry)) {
+      repos.push(entry);
+      continue;
+    }
+    const colon = entry.indexOf(":");
+    if (colon <= 0)
+      continue;
+    const prefix = entry.slice(0, colon);
+    if (repoNames.has(prefix)) {
+      repos.push(prefix);
+      continue;
+    }
+    unresolved.push(entry);
+  }
+  return { repos: uniqueRepos(repos), unresolved };
+}
+
+// src/core/answers/raiseConflict.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/core/run/questionCards.ts
+var QUESTION_PHASES = ["01-what", "02-how", "03-plan", "04-build", "05-watch"];
+
+// src/core/answers/raiseConflict.ts
+var RAISED_BY = "tldrx";
+function nextQuestionId(runDir) {
+  let highest = 0;
+  for (const phase of QUESTION_PHASES) {
+    const path = join3(runDir, phase, "questions.md");
+    if (!existsSync3(path))
+      continue;
+    let blocks;
+    try {
+      blocks = parseQuestions(readFileSync3(path, "utf8")).blocks;
+    } catch {
+      continue;
+    }
+    for (const block of blocks) {
+      const n = Number.parseInt(block.id.slice(1), 10);
+      if (Number.isFinite(n) && n > highest)
+        highest = n;
+    }
+  }
+  return `Q${String(highest + 1)}`;
+}
+function raiseConflictQuestion(args) {
+  const id = nextQuestionId(args.runDir);
+  const block = renderQuestionBlock({
+    id,
+    title: `Which is right about ${args.area}: ${args.newFactId} or ${args.oldFactId}?`,
+    metadata: {
+      id,
+      status: "open",
+      area: args.area,
+      asked_by: RAISED_BY,
+      asked_at: args.at,
+      extra: [[ADVISORY_KEY, "true"]]
+    },
+    metadataIndex: -1,
+    whyAsked: `answering ${args.answeredQ} recorded ${args.newFactId}, which overlaps ${args.oldFactId}'s ` + `text at Jaccard ${formatJaccard(args.score)} on the question's wording, in the same area, ` + `and answers it differently — ${args.oldFactId}: "${oneLine(args.oldFactText)}" ` + `[src: ${args.oldFactId}]`,
+    whySrc: null,
+    options: [
+      { letter: "A", text: `${args.newFactId} is right — supersede ${args.oldFactId}` },
+      { letter: "B", text: `${args.oldFactId} is right — supersede ${args.newFactId}` },
+      { letter: "C", text: "Both are partly right — write the correction below" }
+    ],
+    answer: "",
+    answerIndex: -1,
+    footer: null,
+    startLine: -1,
+    lines: []
+  });
+  appendFileSync2(args.questionsPath, `
+${block}
+`, "utf8");
+  return { q: id, fact: args.newFactId, conflictsWith: args.oldFactId, score: args.score };
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
 // src/core/answers/captureAnswers.ts
+function answerProvenance(block, overrides, repoNames, fallbackRepos) {
+  const override = overrides?.get(block.id);
+  const named = reposFromAffects(declaredAffects(block), repoNames ?? new Set);
+  const repos = override?.repos ?? (named.repos.length > 0 ? named.repos : fallbackRepos);
+  return {
+    repos,
+    unresolved: named.unresolved,
+    source: override?.decidedBy === undefined ? {} : { decided_by: override.decidedBy }
+  };
+}
+function unresolvedEntries(captured) {
+  return captured.flatMap((c) => c.unresolvedAffects.map((entry) => `${c.q}: affects: ${entry} names no repo in this workspace — it scoped nothing`));
+}
 var TRUNCATION_MARK = " …";
 function factTextFor(title, answer) {
   const whole = `${title} — ${answer}`;
@@ -199,28 +419,35 @@ function factWasTruncated(title, answer) {
   return `${title} — ${answer}`.length > MAX_FACT_CHARS;
 }
 function captureAnswers(questionsPath, ctx) {
-  if (!existsSync2(questionsPath))
+  if (!existsSync4(questionsPath))
     return [];
-  let doc = parseQuestions(readFileSync2(questionsPath, "utf8"));
+  let doc = parseQuestions(readFileSync4(questionsPath, "utf8"));
   const answered = detectAnswered(doc.blocks);
   if (answered.length === 0)
     return [];
   const log = EventLog.forRun(ctx.runDir);
   const captured = [];
   const recorded = [];
+  const clashes = [];
   FactsStore.update(factsPath(ctx.root), (store) => {
     for (const block of answered) {
       const area = block.metadata?.area ?? "unscoped";
       const truncated = factWasTruncated(block.title, block.answer);
+      const prov = answerProvenance(block, ctx.overrides, ctx.repoNames, []);
+      const text = factTextFor(block.title, block.answer);
+      const clash = conflictOf({ match: block.title, area, text }, store.active);
       const fact = store.append({
-        fact: factTextFor(block.title, block.answer),
+        fact: text,
         ...truncated ? { truncated: true } : {},
+        ...clash === null ? {} : { conflicts_with: [clash.fact.id] },
         area,
-        repos: [],
+        repos: prov.repos,
         kind: "answer",
         confidence: "stated",
-        source: { who: ctx.actor, when: ctx.at, run: ctx.run, q: block.id }
+        source: { who: ctx.actor, when: ctx.at, run: ctx.run, q: block.id, ...prov.source }
       });
+      if (clash !== null)
+        clashes.push({ block, area, factId: fact.id, hit: clash });
       doc = replaceBlock(doc, recordAnswer(block, { answered_by: ctx.actor, answered_at: ctx.at, fact: fact.id }));
       log.tryAppend({
         ts: ctx.at,
@@ -240,15 +467,58 @@ function captureAnswers(questionsPath, ctx) {
         cost_usd: 0,
         payload: { fact: fact.id, area: fact.area, kind: fact.kind, q: block.id }
       });
-      captured.push({ q: block.id, fact: fact.id, answer: block.answer, area });
+      captured.push({
+        q: block.id,
+        fact: fact.id,
+        answer: block.answer,
+        area,
+        unresolvedAffects: prov.unresolved
+      });
       recorded.push({ block, fact: fact.id });
     }
   });
   writeFileSync(questionsPath, serializeQuestions(doc), "utf8");
+  const raised = raiseAll(log, ctx, questionsPath, clashes);
   for (const item of recorded) {
     markSuperseded(log, ctx, questionsPath, item.block, item.fact);
   }
-  return captured;
+  return captured.map((answer) => {
+    const conflict = raised.get(answer.q);
+    return conflict === undefined ? answer : { ...answer, conflict };
+  });
+}
+function raiseAll(log, ctx, questionsPath, clashes) {
+  const raised = new Map;
+  for (const clash of clashes) {
+    const conflict = raiseConflictQuestion({
+      runDir: ctx.runDir,
+      questionsPath,
+      area: clash.area,
+      at: ctx.at,
+      newFactId: clash.factId,
+      oldFactId: clash.hit.fact.id,
+      oldFactText: clash.hit.fact.fact,
+      score: clash.hit.score,
+      answeredQ: clash.block.id
+    });
+    raised.set(clash.block.id, conflict);
+    log.tryAppend({
+      ts: ctx.at,
+      run: ctx.run,
+      stage: null,
+      type: "fact.conflict_raised",
+      actor: ctx.actor,
+      cost_usd: 0,
+      payload: {
+        fact: clash.factId,
+        conflicts_with: clash.hit.fact.id,
+        score: clash.hit.score,
+        q: clash.block.id,
+        raised: conflict.q
+      }
+    });
+  }
+  return raised;
 }
 function markSuperseded(log, ctx, questionsPath, block, fact) {
   try {
@@ -287,7 +557,7 @@ await runHook("answer-capture", async () => {
   if (event === "PostToolUse" && payload.tool_name !== "Write" && payload.tool_name !== "Edit")
     return;
   const filePath = filePathOf(payload);
-  if (!filePath.endsWith("questions.md") || !existsSync3(filePath))
+  if (!filePath.endsWith("questions.md") || !existsSync5(filePath))
     return;
   const location = locateWork(filePath);
   if (location === null)
@@ -297,10 +567,12 @@ await runHook("answer-capture", async () => {
     runDir: location.runDir,
     run: location.run,
     actor: currentActor(),
-    at: nowRfc3339()
+    at: nowRfc3339(),
+    repoNames: new Set(loadWorkspace(location.root).repos.keys())
   });
   if (captured.length === 0)
     return;
-  postContext(`tldrx: recorded ${captured.map((c) => `${c.q} \u2192 ${c.fact}`).join(", ")}`);
+  const unresolved = unresolvedEntries(captured);
+  postContext(`tldrx: recorded ${captured.map((c) => `${c.q} \u2192 ${c.fact}`).join(", ")}` + (unresolved.length === 0 ? "" : ` \u2014 ${unresolved.join("; ")}`));
 });
 allow();

package/dist/hooks/budget-gate.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import {
   budgetGateDeny
-} from "./chunk-cf4az0j5.js";
+} from "./chunk-stw0dxna.js";
 import {
   allow,
   deny,
   readPayload,
   runHook,
   toolInput
-} from "./chunk-2y3kwfrx.js";
-import"./chunk-x3zy7zrn.js";
+} from "./chunk-6ws778wq.js";
+import"./chunk-6c84kjd7.js";
 import {
   asRunBudget,
   currentActor,
@@ -29,23 +29,20 @@ import {
   validateRunBudget,
   wouldExceed,
   wouldExceedHostTokens
-} from "./chunk-hg43zexg.js";
+} from "./chunk-1c43349s.js";
 import {
   EventLog
-} from "./chunk-fv66tdsm.js";
-import"./chunk-rrkdfk7s.js";
-import"./chunk-5w5eg00k.js";
+} from "./chunk-9v45j71e.js";
 import {
   noteDeprecations
-} from "./chunk-vyvjbbmb.js";
-import"./chunk-39zh2e44.js";
+} from "./chunk-wzzywf6c.js";
 import {
   PROJECT_WORK_DIR,
   findWorkspaceRoot,
   locateWork,
   parseYaml,
   stageYamlPath
-} from "./chunk-y3cxqvnx.js";
+} from "./chunk-r1efatxk.js";
 
 // src/hooks/budget-gate.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";