tldr-experts 0.3.0

package/dist/hooks/chunk-j234zf0t.js

@@ -0,0 +1,339 @@
+import {
+  parseSrcToken
+} from "./chunk-g395gk7e.js";
+import {
+  PROJECT_FRAMEWORK_DIR,
+  PROJECT_WORK_DIR
+} from "./chunk-p274ckxv.js";
+
+// src/core/text/questions.ts
+var REQUIRED_METADATA_KEYS = ["id", "status", "area", "asked_by", "asked_at"];
+var HEADING_RE = /^##\s+(Q\d{1,6})\s+·\s+(.+?)\s*$/;
+var METADATA_RE = /^<!--\s*(.*?)\s*-->$/;
+var WHY_RE = /^Why asked:\s*(.*)$/;
+var OPTION_RE = /^-\s+([A-E])\)\s*(.*)$/;
+var ANSWER_RE = /^\[Answer\]:[ \t]*(\S.*)$/;
+var ANSWER_SLOT_RE = /^\[Answer\]:/;
+var FOOTER_KEYS = ["answered_by", "answered_at", "fact"];
+function parseQuestions(text) {
+  const trailingNewline = text.endsWith(`
+`);
+  const body = trailingNewline ? text.slice(0, -1) : text;
+  const lines = body === "" ? [] : body.split(`
+`);
+  const preamble = [];
+  const blocks = [];
+  let pending = null;
+  const close = () => {
+    if (pending === null)
+      return;
+    blocks.push(buildBlock(pending.start + 1, pending.lines));
+    pending = null;
+  };
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (HEADING_RE.test(line)) {
+      close();
+      pending = { start: i, lines: [line] };
+      continue;
+    }
+    if (pending === null)
+      preamble.push(line);
+    else
+      pending.lines.push(line);
+  }
+  close();
+  return { preamble, blocks, trailingNewline };
+}
+function buildBlock(startLine, lines) {
+  const heading = HEADING_RE.exec(lines[0] ?? "");
+  const id = heading?.[1] ?? "";
+  const title = heading?.[2] ?? "";
+  let metadata = null;
+  let metadataIndex = -1;
+  let whyAsked = null;
+  let whySrc = null;
+  const options = [];
+  let answer = "";
+  let answerIndex = -1;
+  let footer = null;
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const comment = METADATA_RE.exec(line);
+    if (comment !== null && comment[1] !== undefined) {
+      const pairs = parsePipeComment(comment[1]);
+      if (metadata === null && pairs.some(([k]) => k === "id")) {
+        metadata = toMetadata(pairs);
+        metadataIndex = i;
+      } else if (footer === null && pairs.some(([k]) => k === "answered_by")) {
+        footer = toFooter(pairs);
+      }
+      continue;
+    }
+    const why = WHY_RE.exec(line);
+    if (why !== null && whyAsked === null) {
+      whyAsked = why[1] ?? "";
+      whySrc = parseSrcToken(line);
+      continue;
+    }
+    const option = OPTION_RE.exec(line);
+    if (option !== null && option[1] !== undefined && option[2] !== undefined) {
+      options.push({ letter: option[1], text: option[2] });
+      continue;
+    }
+    if (ANSWER_SLOT_RE.test(line) && answerIndex === -1) {
+      answerIndex = i;
+      const captured = ANSWER_RE.exec(line);
+      answer = (captured?.[1] ?? "").trim();
+    }
+  }
+  return {
+    id,
+    title,
+    metadata,
+    metadataIndex,
+    whyAsked,
+    whySrc,
+    options,
+    answer,
+    answerIndex,
+    footer,
+    startLine,
+    lines: [...lines]
+  };
+}
+function parsePipeComment(inner) {
+  const pairs = [];
+  for (const part of inner.split("|")) {
+    const colon = part.indexOf(":");
+    if (colon === -1)
+      continue;
+    pairs.push([part.slice(0, colon).trim(), part.slice(colon + 1).trim()]);
+  }
+  return pairs;
+}
+function toMetadata(pairs) {
+  const map = new Map(pairs);
+  const extra = pairs.filter(([k]) => !REQUIRED_METADATA_KEYS.includes(k));
+  return {
+    id: map.get("id") ?? "",
+    status: map.get("status") ?? "",
+    area: map.get("area") ?? "",
+    asked_by: map.get("asked_by") ?? "",
+    asked_at: map.get("asked_at") ?? "",
+    extra
+  };
+}
+function toFooter(pairs) {
+  const map = new Map(pairs);
+  return {
+    answered_by: map.get("answered_by") ?? "",
+    answered_at: map.get("answered_at") ?? "",
+    fact: map.get("fact") ?? ""
+  };
+}
+function serializeQuestions(doc) {
+  const out = [...doc.preamble];
+  for (const block of doc.blocks)
+    out.push(...block.lines);
+  const text = out.join(`
+`);
+  return doc.trailingNewline ? `${text}
+` : text;
+}
+function detectAnswered(blocks) {
+  return blocks.filter((b) => b.metadata?.status === "open" && b.answer !== "");
+}
+function openBlocks(blocks) {
+  return blocks.filter((b) => b.metadata?.status === "open");
+}
+function recordAnswer(block, footer) {
+  const lines = [...block.lines];
+  if (block.metadataIndex >= 0) {
+    const line = lines[block.metadataIndex] ?? "";
+    lines[block.metadataIndex] = line.replace(/(\|\s*status:\s*)open(\s*\|)/, "$1answered$2");
+  }
+  const footerLine = `<!-- ${FOOTER_KEYS.map((k) => `${k}: ${footer[k]}`).join(" | ")} -->`;
+  const insertAt = block.answerIndex >= 0 ? block.answerIndex + 1 : lines.length;
+  lines.splice(insertAt, 0, footerLine);
+  const metadata = block.metadata === null ? null : { ...block.metadata, status: "answered" };
+  return { ...block, lines, metadata, footer };
+}
+function replaceBlock(doc, block) {
+  return {
+    ...doc,
+    blocks: doc.blocks.map((b) => b.id === block.id ? block : b)
+  };
+}
+
+// src/core/lock/workspaceLock.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, rmSync as rmSync2, writeSync, closeSync } from "node:fs";
+import { basename, dirname as dirname2, join as join2, resolve } from "node:path";
+
+// src/core/facilitator/Lock.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var LOCK_FILE = ".lock";
+function lockPath(runDir) {
+  return join(runDir, LOCK_FILE);
+}
+function readLock(runDir) {
+  const path = lockPath(runDir);
+  if (!existsSync(path))
+    return null;
+  try {
+    const doc = JSON.parse(readFileSync(path, "utf8"));
+    const pid = typeof doc.pid === "number" ? doc.pid : Number.NaN;
+    if (!Number.isInteger(pid))
+      return null;
+    return { pid, at: typeof doc.at === "string" ? doc.at : "" };
+  } catch {
+    return null;
+  }
+}
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+// src/core/lock/workspaceLock.ts
+var WORKSPACE_LOCK_FILE = ".lock";
+var WORKSPACE_LOCK_TIMEOUT_MS = 5000;
+var SPIN_MS = 25;
+
+class WorkspaceLockError extends Error {
+}
+function workspaceLockPath(root) {
+  return join2(resolve(root), PROJECT_FRAMEWORK_DIR, WORKSPACE_LOCK_FILE);
+}
+function workspaceRootOfRunDir(runDir) {
+  const parent = dirname2(resolve(runDir));
+  return parent.endsWith(`/${PROJECT_WORK_DIR}`) || parent.endsWith(`\\${PROJECT_WORK_DIR}`) ? dirname2(parent) : resolve(runDir);
+}
+function workspaceRootOfFactsPath(factsFile) {
+  const full = resolve(factsFile);
+  const memory = dirname2(full);
+  const framework = dirname2(memory);
+  return basename(memory) === "memory" && basename(framework) === PROJECT_FRAMEWORK_DIR ? dirname2(framework) : memory;
+}
+var held = new Map;
+function sleepSync(ms) {
+  const buffer = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(buffer, 0, 0, ms);
+}
+function acquire(path, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  mkdirSync2(dirname2(path), { recursive: true });
+  for (;; ) {
+    try {
+      const fd = openSync(path, "wx");
+      try {
+        writeSync(fd, `${JSON.stringify({ pid: process.pid, at: new Date().toISOString() }, null, 2)}
+`);
+      } finally {
+        closeSync(fd);
+      }
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    const holder = readHolder(path);
+    if (holder === null || !isAlive(holder.pid)) {
+      rmSync2(path, { force: true });
+      continue;
+    }
+    if (Date.now() >= deadline) {
+      throw new WorkspaceLockError(`${path} is held by live pid ${String(holder.pid)}` + (holder.at === "" ? "" : ` since ${holder.at}`) + ` — waited ${String(timeoutMs)}ms. Wait for it, or remove the file if that process is gone.`);
+    }
+    sleepSync(SPIN_MS);
+  }
+}
+function readHolder(path) {
+  if (!existsSync2(path))
+    return null;
+  try {
+    const doc = JSON.parse(readFileSync2(path, "utf8"));
+    const pid = typeof doc.pid === "number" ? doc.pid : Number.NaN;
+    if (!Number.isInteger(pid))
+      return null;
+    return { pid, at: typeof doc.at === "string" ? doc.at : "" };
+  } catch {
+    return null;
+  }
+}
+function withWorkspaceLock(root, fn, timeoutMs = WORKSPACE_LOCK_TIMEOUT_MS) {
+  const path = workspaceLockPath(root);
+  const depth = held.get(path) ?? 0;
+  if (depth === 0)
+    acquire(path, timeoutMs);
+  held.set(path, depth + 1);
+  try {
+    return fn();
+  } finally {
+    const now = (held.get(path) ?? 1) - 1;
+    if (now <= 0) {
+      held.delete(path);
+      rmSync2(path, { force: true });
+    } else {
+      held.set(path, now);
+    }
+  }
+}
+
+// src/core/facts/emitFactsYaml.ts
+var PLAIN_SAFE = /^[A-Za-z][A-Za-z0-9_./-]*$/;
+var YAML_KEYWORDS = new Set(["true", "false", "null", "yes", "no", "on", "off", "~"]);
+function yamlScalar(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "number")
+    return String(value);
+  if (PLAIN_SAFE.test(value) && !YAML_KEYWORDS.has(value.toLowerCase()))
+    return value;
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function inlineList(values) {
+  return `[${values.map((v) => yamlScalar(v)).join(", ")}]`;
+}
+function emitFact(fact, indent = "  ") {
+  const inner = `${indent}  `;
+  const lines = [
+    `${indent}- id: ${yamlScalar(fact.id)}`,
+    `${inner}fact: ${yamlScalar(fact.fact)}`,
+    `${inner}area: ${yamlScalar(fact.area)}`,
+    `${inner}repos: ${inlineList(fact.repos)}`,
+    `${inner}kind: ${yamlScalar(fact.kind)}`,
+    `${inner}confidence: ${yamlScalar(fact.confidence)}`,
+    `${inner}source: {who: ${yamlScalar(fact.source.who)}, when: ${yamlScalar(fact.source.when)}, ` + `run: ${yamlScalar(fact.source.run)}, q: ${yamlScalar(fact.source.q)}}`,
+    `${inner}supersedes: ${yamlScalar(fact.supersedes)}`,
+    `${inner}superseded_by: ${yamlScalar(fact.superseded_by)}`
+  ];
+  if (fact.retired === null) {
+    lines.push(`${inner}retired: null`);
+  } else {
+    lines.push(`${inner}retired: {at: ${yamlScalar(fact.retired.at)}, by: ${yamlScalar(fact.retired.by)}, ` + `reason: ${yamlScalar(fact.retired.reason)}}`);
+  }
+  return lines.join(`
+`);
+}
+function emitFactsYaml(file, header) {
+  const out = [];
+  if (header !== undefined && header !== "")
+    out.push(header.replace(/\n$/, ""));
+  out.push(`version: ${file.version}`);
+  out.push("facts:");
+  for (const fact of file.facts)
+    out.push(emitFact(fact));
+  return `${out.join(`
+`)}
+`;
+}
+
+export { readLock, isAlive, workspaceRootOfRunDir, workspaceRootOfFactsPath, withWorkspaceLock, yamlScalar, emitFactsYaml, parseQuestions, serializeQuestions, detectAnswered, openBlocks, recordAnswer, replaceBlock };

package/dist/hooks/chunk-kw4tffzf.js

@@ -0,0 +1,139 @@
+import {
+  hasSrcMarker,
+  parseSrcToken,
+  resolveSrc
+} from "./chunk-g395gk7e.js";
+
+// src/core/text/handoff.ts
+var HANDOFF_SECTIONS = ["Findings", "Decisions", "Unknowns", "Evidence ledger"];
+var H2_RE = /^##\s+(.+?)\s*$/;
+var BULLET_RE = /^(?: {0,3}-|\d{1,9}[.)])\s+(\S.*)$/;
+var CONTINUATION_RE = /^\s+\S/;
+function parseHandoff(text) {
+  const lines = text.split(`
+`);
+  const sections = [];
+  const headings = [];
+  let current = null;
+  let pending = null;
+  const flushBullet = () => {
+    if (pending === null)
+      return;
+    if (current !== null) {
+      const joined = pending.parts.join(" ");
+      current.bullets.push({ line: pending.line, text: joined, token: parseSrcToken(joined) });
+    }
+    pending = null;
+  };
+  const flush = () => {
+    flushBullet();
+    if (current !== null)
+      sections.push(current);
+    current = null;
+  };
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const heading = H2_RE.exec(line);
+    if (heading !== null && heading[1] !== undefined) {
+      flush();
+      headings.push(heading[1]);
+      current = { name: heading[1], headingLine: i + 1, bullets: [] };
+      continue;
+    }
+    if (line.startsWith("# ")) {
+      flush();
+      continue;
+    }
+    if (current === null)
+      continue;
+    const bullet = BULLET_RE.exec(line);
+    if (bullet !== null && bullet[1] !== undefined) {
+      flushBullet();
+      pending = { line: i + 1, parts: [bullet[1]] };
+      continue;
+    }
+    if (pending !== null && CONTINUATION_RE.test(line)) {
+      pending.parts.push(line.trim());
+      continue;
+    }
+    flushBullet();
+  }
+  flush();
+  return { sections, headings };
+}
+function isHandoff(text) {
+  return missingSections(parseHandoff(text)).length === 0;
+}
+function missingSections(handoff) {
+  const present = handoff.headings;
+  const missing = [];
+  let cursor = 0;
+  for (const required of HANDOFF_SECTIONS) {
+    const at = present.indexOf(required, cursor);
+    if (at === -1)
+      missing.push(required);
+    else
+      cursor = at + 1;
+  }
+  return missing;
+}
+var MAX_BULLETS = 200;
+function validateHandoff(text, ctx) {
+  const handoff = parseHandoff(text);
+  const missing = missingSections(handoff);
+  const emptySections = [];
+  const unsourced = [];
+  const malformed = [];
+  const unresolved = [];
+  const unverified = [];
+  let bulletCount = 0;
+  const required = new Set(HANDOFF_SECTIONS);
+  for (const section of handoff.sections) {
+    if (!required.has(section.name))
+      continue;
+    if (section.bullets.length === 0) {
+      emptySections.push({ name: section.name, line: section.headingLine });
+    }
+    for (const bullet of section.bullets) {
+      bulletCount++;
+      if (bullet.token === null) {
+        if (hasSrcMarker(bullet.text)) {
+          malformed.push({
+            line: bullet.line,
+            message: "malformed citation — the `[src: …]` token must be the last thing on the line " + "(closing quotes, brackets and a final `.` are allowed after it, words are not)"
+          });
+        } else {
+          unsourced.push(bullet.line);
+        }
+        continue;
+      }
+      for (const error of bullet.token.errors) {
+        unresolved.push({ line: bullet.line, message: `[src: ${error.raw}] — ${error.message}` });
+      }
+      const claim = bullet.text.replace(bullet.token.raw, " ").trim();
+      for (const ref of bullet.token.refs) {
+        const resolution = resolveSrc(ref, ctx, section.name, claim);
+        const issue = { line: bullet.line, message: `[src: ${ref.raw}] — ${resolution.message ?? "unresolvable"}` };
+        if (resolution.outcome === "refused")
+          unresolved.push(issue);
+        else if (resolution.outcome === "unverified")
+          unverified.push(issue);
+      }
+    }
+  }
+  if (bulletCount > MAX_BULLETS) {
+    unresolved.push({ line: 0, message: `${bulletCount} bullets exceeds the ${MAX_BULLETS} cap` });
+  }
+  return {
+    ok: missing.length === 0 && emptySections.length === 0 && unsourced.length === 0 && malformed.length === 0 && unresolved.length === 0,
+    missingSections: missing,
+    emptySections,
+    unsourced,
+    malformed,
+    unresolved,
+    unverified,
+    bulletCount
+  };
+}
+
+export { isHandoff, validateHandoff };