tldr-experts 0.3.0

package/dist/hooks/dod-gate.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+import {
+  wouldBeContent
+} from "./chunk-t8tdv11p.js";
+import {
+  dodGateDeny,
+  dodGateInternalErrorDeny,
+  dodGateMissingBlockDeny,
+  dodGateRefusedCommandDeny
+} from "./chunk-9gb21660.js";
+import {
+  allow,
+  deny,
+  failOpen,
+  filePathOf,
+  isWriteOrEdit,
+  readPayload
+} from "./chunk-1zwcxd3f.js";
+import"./chunk-a8p2rc94.js";
+import"./chunk-ae6bkfs5.js";
+import"./chunk-0bt6yb2q.js";
+import {
+  loadWorkspace,
+  locateWork,
+  repoPath,
+  runtime
+} from "./chunk-p274ckxv.js";
+
+// src/hooks/dod-gate.ts
+import { basename, join } from "node:path";
+import { existsSync } from "node:fs";
+
+// src/core/schemas/story.ts
+var FENCE_OPEN_RE = /^\s*```+\s*dod\s*$/i;
+var FENCE_CLOSE_RE = /^\s*```+\s*$/;
+function parseDodBlock(text) {
+  const commands = [];
+  let present = false;
+  let inside = false;
+  for (const line of text.split(`
+`)) {
+    if (inside) {
+      if (FENCE_CLOSE_RE.test(line)) {
+        inside = false;
+        continue;
+      }
+      const command = line.trim();
+      if (command !== "" && !command.startsWith("#"))
+        commands.push(command);
+      continue;
+    }
+    if (FENCE_OPEN_RE.test(line)) {
+      present = true;
+      inside = true;
+    }
+  }
+  return { present, commands };
+}
+
+// src/hooks/lib/story.ts
+var DONE_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?status(?:\*\*)?\s*:\s*["'`]?done["'`]?\.?\s*$/i;
+var REPO_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?repo(?:\*\*)?\s*:\s*["'`]?([A-Za-z0-9._-]{1,64})["'`]?\s*$/i;
+var TIMEOUT_RE = /^\s*(?:[-*]\s*)?(?:\*\*)?timeout_s(?:\*\*)?\s*:\s*(\d{1,6})\s*$/i;
+var FENCE_OPEN_RE2 = /^\s*```+\s*dod\s*$/i;
+var FENCE_CLOSE_RE2 = /^\s*```+\s*$/;
+function readStory(text) {
+  const lines = text.split(`
+`);
+  const dod = parseDodBlock(text);
+  let setsDone = false;
+  let repo = null;
+  let timeoutS = null;
+  let inDod = false;
+  for (const line of lines) {
+    if (inDod) {
+      if (FENCE_CLOSE_RE2.test(line))
+        inDod = false;
+      continue;
+    }
+    if (FENCE_OPEN_RE2.test(line)) {
+      inDod = true;
+      continue;
+    }
+    if (!setsDone && DONE_RE.test(line))
+      setsDone = true;
+    if (repo === null) {
+      const m = REPO_RE.exec(line);
+      if (m?.[1] !== undefined)
+        repo = m[1];
+    }
+    if (timeoutS === null) {
+      const m = TIMEOUT_RE.exec(line);
+      if (m?.[1] !== undefined)
+        timeoutS = Number(m[1]);
+    }
+  }
+  return { setsDone, repo, dodCommands: dod.commands, hasDodBlock: dod.present, timeoutS };
+}
+function isAllowedDodCommand(command, allowed) {
+  return allowed.has(command);
+}
+var META_RE = /[|&;<>$`(){}*?~\\]/;
+function splitArgv(command) {
+  if (/[\n\r]/.test(command))
+    return null;
+  const argv = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s"']+)/g;
+  for (const match of command.matchAll(pattern)) {
+    if (match[1] !== undefined || match[2] !== undefined) {
+      argv.push(match[1] ?? match[2] ?? "");
+      continue;
+    }
+    const bare = match[3] ?? "";
+    if (META_RE.test(bare))
+      return null;
+    argv.push(bare);
+  }
+  return argv.length === 0 ? null : argv;
+}
+
+class DodCommandRefused extends Error {
+}
+async function runDodCommand(command, cwd, timeoutMs, allowed) {
+  if (!isAllowedDodCommand(command, allowed)) {
+    throw new DodCommandRefused(allowed.size === 0 ? `\`${command}\` cannot be run: .tldrx/workspace.yml declares no commands, so there is nothing ` + "to check it against. An empty allowlist is not a permit." : `\`${command}\` is not one of .tldrx/workspace.yml's commands. Declared: ` + `${[...allowed].map((c) => `\`${c}\``).join(", ")}.`);
+  }
+  const argv = splitArgv(command);
+  if (argv === null) {
+    throw new DodCommandRefused(`\`${command}\` needs a shell to run (it contains a metacharacter), and this gate does not open one. ` + "Put it in a script, declare the script under the repo's `commands:`, and cite that.");
+  }
+  const head = argv[0] ?? "";
+  const { exitCode, stdout, stderr, timedOut } = await runtime.spawn(head, argv.slice(1), {
+    cwd,
+    timeoutMs
+  });
+  return { command, exitCode, timedOut, tail: lastMeaningfulLine(`${stdout}
+${stderr}`) };
+}
+function lastMeaningfulLine(output, max = 200) {
+  const lines = output.split(`
+`).map((l) => l.trimEnd()).filter((l) => l.trim() !== "");
+  const last = lines[lines.length - 1] ?? "";
+  return last.length > max ? `${last.slice(0, max - 1)}…` : last;
+}
+
+// src/hooks/dod-gate.ts
+var DEFAULT_TIMEOUT_S = 900;
+var storyId = "?";
+try {
+  const payload = await readPayload();
+  if (!isWriteOrEdit(payload))
+    allow();
+  const filePath = filePathOf(payload);
+  const location = locateWork(filePath);
+  if (location === null || !filePath.endsWith(".md") || !location.relative.includes("stories/")) {
+    allow();
+  }
+  const wouldBe = wouldBeContent(payload, filePath);
+  if (wouldBe.kind !== "content")
+    allow();
+  const story = readStory(wouldBe.text);
+  if (!story.setsDone)
+    allow();
+  storyId = basename(filePath, ".md");
+  const relPath = `tldrx-work/${location.run}/${location.relative}`;
+  if (!story.hasDodBlock || story.dodCommands.length === 0) {
+    deny(dodGateMissingBlockDeny(storyId, relPath));
+  }
+  const workspace = loadWorkspace(location.root);
+  const repoName = story.repo ?? "";
+  const cwd = repoName === "" ? location.root : repoPath(workspace, repoName) ?? join(location.root, repoName);
+  if (!existsSync(cwd)) {
+    deny(dodGateInternalErrorDeny(storyId, `repo \`${repoName}\` resolves to ${cwd}, which does not exist`));
+  }
+  const timeoutMs = (story.timeoutS ?? DEFAULT_TIMEOUT_S) * 1000;
+  for (const command of story.dodCommands) {
+    let outcome;
+    try {
+      outcome = await runDodCommand(command, cwd, timeoutMs, workspace.commands);
+    } catch (error) {
+      if (error instanceof DodCommandRefused) {
+        deny(dodGateRefusedCommandDeny(storyId, command, error.message));
+      }
+      throw error;
+    }
+    if (outcome.timedOut) {
+      deny(dodGateDeny(storyId, command, repoName === "" ? "(root)" : repoName, outcome.exitCode, `timed out after ${story.timeoutS ?? DEFAULT_TIMEOUT_S}s. ${outcome.tail}`));
+    }
+    if (outcome.exitCode !== 0) {
+      deny(dodGateDeny(storyId, command, repoName === "" ? "(root)" : repoName, outcome.exitCode, outcome.tail));
+    }
+  }
+} catch (error) {
+  if (storyId === "?")
+    failOpen("dod-gate", error);
+  deny(dodGateInternalErrorDeny(storyId, error instanceof Error ? error.message : String(error)));
+}
+allow();

package/dist/hooks/no-reask.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import {
+  wouldBeContent
+} from "./chunk-t8tdv11p.js";
+import {
+  noReAskDeny
+} from "./chunk-9gb21660.js";
+import {
+  FactsStore
+} from "./chunk-x98qs959.js";
+import {
+  allow,
+  deny,
+  filePathOf,
+  isWriteOrEdit,
+  readPayload,
+  runHook
+} from "./chunk-1zwcxd3f.js";
+import"./chunk-a8p2rc94.js";
+import {
+  openBlocks,
+  parseQuestions
+} from "./chunk-j234zf0t.js";
+import"./chunk-t56k6146.js";
+import"./chunk-g395gk7e.js";
+import"./chunk-0bt6yb2q.js";
+import {
+  factsPath,
+  locateWork
+} from "./chunk-p274ckxv.js";
+
+// src/hooks/no-reask.ts
+import { existsSync, readFileSync } from "node:fs";
+await runHook("no-reask", async () => {
+  const payload = await readPayload();
+  if (!isWriteOrEdit(payload))
+    return;
+  const filePath = filePathOf(payload);
+  if (!filePath.endsWith("questions.md"))
+    return;
+  const location = locateWork(filePath);
+  if (location === null)
+    return;
+  const wouldBe = wouldBeContent(payload, filePath);
+  if (wouldBe.kind !== "content")
+    return;
+  const facts = factsPath(location.root);
+  if (!existsSync(facts))
+    return;
+  const store = FactsStore.load(facts);
+  if (store.active.length === 0)
+    return;
+  const existing = new Set;
+  if (existsSync(filePath)) {
+    for (const block of parseQuestions(readFileSync(filePath, "utf8")).blocks)
+      existing.add(block.id);
+  }
+  for (const block of openBlocks(parseQuestions(wouldBe.text).blocks)) {
+    if (existing.has(block.id))
+      continue;
+    const area = block.metadata?.area ?? "";
+    const hit = store.findDuplicate(block.title, area);
+    if (hit !== null)
+      deny(noReAskDeny(block.id, block.title, hit.fact));
+  }
+});
+allow();