@davmash/bygone 0.10.1 → 0.11.1

package/out/gitComparison.js

@@ -45,11 +45,13 @@ var import_child_process = require("child_process");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var DEFAULT_GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+var DEFAULT_GIT_TIMEOUT_MS = 3e4;
 function createGitRunner(maxBuffer = readGitMaxBuffer()) {
   return (args, cwd) => (0, import_child_process.execFileSync)("git", [...args], {
     cwd,
     encoding: "utf8",
     maxBuffer,
+    timeout: DEFAULT_GIT_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "pipe"]
   }).trimEnd();
 }
@@ -306,6 +308,7 @@ function readGitBlob(repoRoot, commit, relativePath) {
     cwd: repoRoot,
     encoding: "buffer",
     maxBuffer: readGitMaxBuffer(),
+    timeout: DEFAULT_GIT_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "pipe"]
   });
 }
@@ -314,6 +317,7 @@ function runGitText(repoRoot, args) {
     cwd: repoRoot,
     encoding: "utf8",
     maxBuffer: readGitMaxBuffer(),
+    timeout: DEFAULT_GIT_TIMEOUT_MS,
     stdio: ["ignore", "pipe", "pipe"]
   });
 }

package/out/requirements.js

@@ -0,0 +1,427 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/strand/src/input.js
+var require_input = __commonJS({
+  "packages/strand/src/input.js"(exports2, module2) {
+    "use strict";
+    var LIMITS = Object.freeze({ maxFiles: 50, maxFileBytes: 1048576, maxBytes: 4194304, maxRecords: 2e4, timeoutMs: 3e4, maxOutputBytes: 16777216 });
+    function inputProblem(before, after, limits) {
+      if (!before || !after || typeof before !== "object" || typeof after !== "object" || Array.isArray(before) || Array.isArray(after)) return "invalid-snapshot-map";
+      if ((/* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])).size > Math.min(limits.maxFiles, LIMITS.maxFiles)) return "file-budget";
+      let bytes = 0;
+      for (const files of [before, after]) for (const value of Object.values(files)) {
+        if (typeof value !== "string") return "invalid-snapshot-text";
+        const size = Buffer.byteLength(value);
+        bytes += size;
+        if (size > Math.min(limits.maxFileBytes, LIMITS.maxFileBytes)) return "file-byte-budget";
+      }
+      return bytes > Math.min(limits.maxBytes, LIMITS.maxBytes) ? "comparison-byte-budget" : null;
+    }
+    function boundedProcessOptions(options, timeoutKey, outputKey, defaultTimeout) {
+      const timeout = options[timeoutKey] === void 0 ? defaultTimeout : options[timeoutKey];
+      const maxBuffer = options[outputKey] === void 0 ? LIMITS.maxOutputBytes : options[outputKey];
+      if (![timeout, maxBuffer].every((value) => Number.isSafeInteger(value) && value > 0)) return null;
+      return { timeout: Math.min(timeout, defaultTimeout), maxBuffer: Math.min(maxBuffer, LIMITS.maxOutputBytes) };
+    }
+    module2.exports = { LIMITS, inputProblem, boundedProcessOptions };
+  }
+});
+
+// packages/strand/src/source-references.js
+var require_source_references = __commonJS({
+  "packages/strand/src/source-references.js"(exports2, module2) {
+    "use strict";
+    var { createHash: createHash2 } = require("node:crypto");
+    var { inputProblem, LIMITS } = require_input();
+    var digest2 = (text) => createHash2("sha256").update(text, "utf8").digest("hex");
+    var key = (ref) => JSON.stringify([ref.revision, ref.path, ref.start, ref.end, ref.digest]);
+    function identifier(value) {
+      if (typeof value !== "string" || !value.trim() || value.length > 1e5) {
+        throw new TypeError("Expected bounded nonempty identifier");
+      }
+      return value;
+    }
+    function parseSourceRef2(value) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Expected source reference");
+      const revision2 = identifier(value.revision), path = identifier(value.path);
+      if (path.startsWith("/") || /^[A-Za-z]:/.test(path) || path.includes("\\") || path.includes("\0") || path.split("/").some((part) => !part || part === "." || part === "..")) {
+        throw new TypeError("Invalid relative source path");
+      }
+      if (!Number.isSafeInteger(value.start) || !Number.isSafeInteger(value.end) || value.start < 0 || value.end <= value.start) {
+        throw new TypeError("Invalid UTF-16 range");
+      }
+      if (typeof value.digest !== "string" || !/^[a-f0-9]{64}$/.test(value.digest)) throw new TypeError("Expected SHA-256");
+      return { revision: revision2, path, start: value.start, end: value.end, digest: value.digest };
+    }
+    function checkSnapshot(snapshot) {
+      if (!snapshot || typeof snapshot !== "object" || Array.isArray(snapshot)) throw new TypeError("Expected snapshot");
+      identifier(snapshot.revision);
+      const problem = inputProblem(snapshot.files, {}, LIMITS);
+      if (problem) throw new TypeError(problem);
+    }
+    function sourceAt(snapshot, path) {
+      return Object.prototype.hasOwnProperty.call(snapshot.files, path) ? snapshot.files[path] : void 0;
+    }
+    function pinSourceRef(snapshot, path, start, end) {
+      checkSnapshot(snapshot);
+      const ref = parseSourceRef2({ revision: snapshot.revision, path, start, end, digest: "0".repeat(64) });
+      const text = sourceAt(snapshot, ref.path);
+      if (typeof text !== "string" || end > text.length) throw new TypeError("Source is unavailable or range exceeds file");
+      return { ...ref, digest: digest2(text.slice(start, end)) };
+    }
+    function resolveChecked(ref, snapshot) {
+      if (snapshot.revision !== ref.revision) return { status: "broken", reason: "Revision unavailable in this comparison" };
+      const text = sourceAt(snapshot, ref.path);
+      if (typeof text !== "string" || ref.end > text.length) return { status: "broken", reason: "Source path or range unavailable" };
+      const slice = text.slice(ref.start, ref.end);
+      if (digest2(slice) !== ref.digest) return { status: "broken", reason: "Source digest mismatch" };
+      return { status: "valid", text: slice };
+    }
+    function resolveSourceRef2(value, snapshot) {
+      const ref = parseSourceRef2(value);
+      checkSnapshot(snapshot);
+      return resolveChecked(ref, snapshot);
+    }
+    function boundedList(value) {
+      if (!Array.isArray(value) || value.length > LIMITS.maxRecords) throw new TypeError("Expected bounded reference array");
+      return value;
+    }
+    function relocateSourceRefs2(values, before, after, pairs) {
+      checkSnapshot(before);
+      checkSnapshot(after);
+      const problem = inputProblem(before.files, after.files, LIMITS);
+      if (problem) throw new TypeError(problem);
+      if (before.revision === after.revision) throw new TypeError("Relocation requires distinct snapshot revisions");
+      const refs = boundedList(values).map(parseSourceRef2);
+      const candidates = boundedList(pairs).map((pair) => {
+        if (!pair || typeof pair !== "object") throw new TypeError("Expected correspondence pair");
+        return { before: parseSourceRef2(pair.before), after: parseSourceRef2(pair.after) };
+      });
+      const destinations = /* @__PURE__ */ new Map(), usedAfter = /* @__PURE__ */ new Set();
+      for (const pair of candidates) {
+        const from = key(pair.before), to = key(pair.after);
+        if (destinations.has(from) || usedAfter.has(to)) throw new TypeError("Duplicate correspondence endpoint");
+        destinations.set(from, pair.after);
+        usedAfter.add(to);
+      }
+      for (const pair of candidates) {
+        if (resolveChecked(pair.before, before).status !== "valid" || resolveChecked(pair.after, after).status !== "valid") {
+          throw new TypeError("Invalid correspondence endpoint");
+        }
+      }
+      return refs.map((ref) => {
+        let destination;
+        if (resolveChecked(ref, before).status === "valid") {
+          destination = sourceAt(before, ref.path) === sourceAt(after, ref.path) ? { ...ref, revision: after.revision } : destinations.get(key(ref));
+        }
+        if (!destination) return { status: "unresolved", before: ref };
+        const status = ref.digest !== destination.digest ? "changed" : ref.path !== destination.path || ref.start !== destination.start ? "relocated" : "unchanged";
+        return { status, before: ref, after: { ...destination } };
+      });
+    }
+    module2.exports = { parseSourceRef: parseSourceRef2, pinSourceRef, resolveSourceRef: resolveSourceRef2, relocateSourceRefs: relocateSourceRefs2 };
+  }
+});
+
+// packages/strand/source-references.js
+var require_source_references2 = __commonJS({
+  "packages/strand/source-references.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_source_references();
+  }
+});
+
+// src/requirements.ts
+var requirements_exports = {};
+__export(requirements_exports, {
+  correspondenceEvidence: () => correspondenceEvidence,
+  digest: () => digest,
+  fingerprint: () => fingerprint,
+  inspect: () => inspect,
+  parseReview: () => parseReview,
+  refresh: () => refresh,
+  requirementFingerprint: () => requirementFingerprint
+});
+module.exports = __toCommonJS(requirements_exports);
+var import_crypto = require("crypto");
+var import_source_references = __toESM(require_source_references2());
+var digest = (text) => (0, import_crypto.createHash)("sha256").update(text, "utf8").digest("hex");
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected object");
+  return value;
+}
+function string(value) {
+  if (typeof value !== "string" || !value.trim() || value.length > 1e5) throw new Error("Expected bounded nonempty string");
+  return value;
+}
+function list(value) {
+  if (!Array.isArray(value) || value.length > 1e3) throw new Error("Expected bounded array");
+  return value;
+}
+function choice(value, choices) {
+  if (!choices.includes(value)) throw new Error(`Expected ${choices.join("/")}`);
+  return value;
+}
+function hash(value) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/.test(value)) throw new Error("Expected SHA-256");
+  return value;
+}
+function revision(value) {
+  if (typeof value !== "string" || !/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(value)) throw new Error("Expected immutable Git revision");
+  return value;
+}
+function sourceRef(value) {
+  const ref = (0, import_source_references.parseSourceRef)(value);
+  revision(ref.revision);
+  return ref;
+}
+function unique(values) {
+  if (new Set(values).size !== values.length) throw new Error("Duplicate ID");
+}
+function sources(value) {
+  const result = list(value).map((value2) => {
+    const s = record(value2);
+    const source = { title: string(s.title), text: string(s.text), quote: string(s.quote) };
+    if (!source.text.includes(source.quote)) throw new Error("Source quotation does not exist");
+    return source;
+  });
+  if (!result.length) throw new Error("Expected at least one source");
+  return result;
+}
+function parseAnalysis(value) {
+  const a = record(value), scope = list(a.scope).map(string);
+  if (!scope.length) throw new Error("Expected analysis scope");
+  return {
+    base: revision(a.base),
+    head: revision(a.head),
+    producer: string(a.producer),
+    status: choice(a.status, ["complete", "partial", "unavailable"]),
+    scope,
+    limitations: list(a.limitations).map(string),
+    artifactDigest: hash(a.artifactDigest)
+  };
+}
+function parseRequirement(value) {
+  const r = record(value);
+  return { id: string(r.id), text: string(r.text), sources: sources(r.sources) };
+}
+function parseQuestion(value, requirement = string) {
+  const q = record(value);
+  const alternatives = list(q.alternatives).map((value2) => {
+    const a = record(value2);
+    return { text: string(a.text), sources: sources(a.sources) };
+  });
+  const common = { id: string(q.id), requirement: requirement(q.requirement), text: string(q.text), alternatives };
+  const status = choice(q.status, ["open", "resolved"]);
+  if (status === "open" && q.resolution !== void 0) throw new Error("Open question cannot have a resolution");
+  return status === "open" ? { ...common, status } : { ...common, status, resolution: string(q.resolution) };
+}
+function parseLink(value, requirement = string) {
+  const x = record(value);
+  return { id: string(x.id), requirement: requirement(x.requirement), role: choice(x.role, ["implementation", "test", "context", "counterexample"]), rationale: string(x.rationale), ref: sourceRef(x.ref) };
+}
+function parseRun(value, requirement = string) {
+  const x = record(value), associations = list(x.requirements).map((value2) => {
+    const a = record(value2);
+    return { requirement: requirement(a.requirement), fingerprint: hash(a.fingerprint), scope: string(a.scope) };
+  });
+  unique(associations.map((a) => a.requirement));
+  return { revision: revision(x.revision), requirements: associations, command: string(x.command), outcome: choice(x.outcome, ["passed", "failed"]), outputDigest: hash(x.outputDigest) };
+}
+function correspondenceEvidence(artifact, scope) {
+  const ref = (side, id) => {
+    const symbol = artifact.symbols[side].find((s) => s.id === id);
+    if (!symbol) throw new Error("Unknown correspondence symbol");
+    return sourceRef({
+      revision: side === "before" ? artifact.range.baseOid : artifact.range.headOid,
+      path: symbol.path,
+      start: symbol.start,
+      end: symbol.end,
+      digest: symbol.digest
+    });
+  };
+  return {
+    pairs: artifact.relations.map((r) => ({ before: ref("before", r.sourceId), after: ref("after", r.destinationId) })),
+    analysis: parseAnalysis({
+      base: artifact.range.baseOid,
+      head: artifact.range.headOid,
+      producer: artifact.producer,
+      status: artifact.status,
+      scope: [...scope, ...artifact.diagnostics?.scope || []],
+      limitations: artifact.limitations,
+      artifactDigest: digest(JSON.stringify(artifact))
+    })
+  };
+}
+function parseReview(value) {
+  const r = record(value);
+  if (r.version !== 2) throw new Error("Unsupported review version");
+  const requirements = list(r.requirements).map(parseRequirement);
+  unique(requirements.map((r2) => r2.id));
+  const requirement = (value2) => {
+    const id = string(value2);
+    if (!requirements.some((r2) => r2.id === id)) throw new Error(`Unknown requirement: ${id}`);
+    return id;
+  };
+  const questions = list(r.questions).map((value2) => parseQuestion(value2, requirement));
+  unique(questions.map((q) => q.id));
+  const links = list(r.links).map((value2) => parseLink(value2, requirement));
+  unique(links.map((l) => l.id));
+  const runs = list(r.runs).map((value2) => parseRun(value2, requirement));
+  const decisions = list(r.decisions).map((value2) => {
+    const x = record(value2);
+    return { requirement: requirement(x.requirement), fingerprint: hash(x.fingerprint), note: string(x.note) };
+  });
+  unique(decisions.map((d) => d.requirement));
+  return { version: 2, repository: string(r.repository), base: revision(r.base), head: revision(r.head), requirements, questions, links, runs, analyses: list(r.analyses).map(parseAnalysis), decisions };
+}
+function snapshotsMatch(review, base, head) {
+  if (review.repository !== base.repository || review.repository !== head.repository || review.base !== base.revision || review.head !== head.revision) throw new Error("Repository or comparison mismatch");
+}
+function sourceSubset(snapshot, paths) {
+  const present = [...new Set(paths)].filter((path) => Object.prototype.hasOwnProperty.call(snapshot.files, path));
+  return { revision: snapshot.revision, files: Object.fromEntries(present.map((path) => [path, snapshot.files[path]])) };
+}
+function resolveReference(ref, snapshot) {
+  return (0, import_source_references.resolveSourceRef)(ref, sourceSubset(snapshot, [ref.path]));
+}
+function requirementFingerprint(review, id) {
+  const requirement = review.requirements.find((r) => r.id === id);
+  if (!requirement) throw new Error(`Unknown requirement: ${id}`);
+  return digest(JSON.stringify({
+    repository: review.repository,
+    requirement: parseRequirement(requirement),
+    questions: review.questions.filter((q) => q.requirement === id).map((q) => parseQuestion(q))
+  }));
+}
+function fingerprint(review, id) {
+  return digest(JSON.stringify({
+    repository: review.repository,
+    base: review.base,
+    head: review.head,
+    requirement: requirementFingerprint(review, id),
+    links: review.links.filter((l) => l.requirement === id).map((l) => parseLink(l)),
+    runs: review.runs.filter((r) => r.requirements.some((a) => a.requirement === id)).map((r) => parseRun(r)),
+    analyses: review.analyses.map(parseAnalysis)
+  }));
+}
+function inspect(review, base, head) {
+  snapshotsMatch(review, base, head);
+  const links = review.links.map((link) => ({ ...link, resolution: resolveReference(link.ref, link.ref.revision === base.revision ? base : head) }));
+  const requirements = review.requirements.map((requirement) => {
+    const attached = links.filter((l) => l.requirement === requirement.id);
+    const valid = attached.filter((l) => l.resolution.status === "valid");
+    const key = requirementFingerprint(review, requirement.id);
+    const runs = review.runs.flatMap((run) => run.requirements.filter((a) => a.requirement === requirement.id).map((association) => ({
+      ...run,
+      association,
+      applicability: run.revision !== head.revision ? "historical-revision" : association.fingerprint === key ? "current" : "stale-requirement"
+    })));
+    const currentRuns = runs.filter((r) => r.applicability === "current");
+    const decision = review.decisions.find((d) => d.requirement === requirement.id);
+    return {
+      ...requirement,
+      questions: review.questions.filter((q) => q.requirement === requirement.id),
+      runs,
+      links: attached,
+      implementationLinked: valid.some((l) => l.role === "implementation"),
+      testLinked: valid.some((l) => l.role === "test"),
+      counterexampleLinked: valid.some((l) => l.role === "counterexample"),
+      verification: currentRuns.length ? currentRuns.some((r) => r.outcome === "failed") ? "recorded-failure" : "recorded-pass" : runs.some((r) => r.applicability === "stale-requirement") ? "needs-reassessment" : "not-recorded",
+      reviewer: !decision ? "unreviewed" : decision.fingerprint === fingerprint(review, requirement.id) && attached.every((l) => l.resolution.status === "valid") ? "inspected" : "needs-review",
+      note: decision?.note
+    };
+  });
+  const changedPaths = [.../* @__PURE__ */ new Set([...Object.keys(base.files), ...Object.keys(head.files)])].filter((p) => base.files[p] !== head.files[p]).sort();
+  return {
+    requirements,
+    analyses: review.analyses.map((analysis) => ({
+      ...analysis,
+      relevance: analysis.head !== review.head ? "historical" : analysis.base === review.base ? "current-comparison" : "current-head-delta"
+    })),
+    changedPathsWithoutLinks: changedPaths.filter((p) => !links.some((l) => l.ref.path === p && l.resolution.status === "valid"))
+  };
+}
+function refresh(review, oldHead, newHead, evidence, requirements = review.requirements) {
+  if (review.repository !== oldHead.repository || review.repository !== newHead.repository || review.head !== oldHead.revision) throw new Error("Repository or old head mismatch");
+  revision(oldHead.revision);
+  revision(newHead.revision);
+  if (evidence !== void 0) {
+    record(evidence);
+    if (!Array.isArray(evidence.pairs)) throw new Error("Expected correspondence pairs");
+  }
+  const analysis = evidence === void 0 ? void 0 : parseAnalysis(evidence.analysis);
+  const pairs = evidence === void 0 ? [] : evidence.pairs;
+  if (analysis && (analysis.base !== oldHead.revision || analysis.head !== newHead.revision)) throw new Error("Analysis comparison mismatch");
+  if (analysis?.status === "unavailable" && pairs.length) throw new Error("Unavailable analysis cannot supply pairs");
+  const current = review.links.filter((link) => link.ref.revision !== review.base);
+  let relocated;
+  if (oldHead.revision === newHead.revision) {
+    if (pairs.length) throw new Error("Same-revision updates cannot supply correspondence pairs");
+    relocated = current.map(({ ref }) => resolveReference(ref, oldHead).status === "valid" && resolveReference(ref, newHead).status === "valid" ? { status: "unchanged", before: ref, after: ref } : { status: "unresolved", before: ref });
+  } else {
+    const paths = current.map((link) => link.ref.path);
+    const before = sourceSubset(oldHead, [...paths, ...pairs.map((pair) => pair.before.path)]);
+    const after = sourceSubset(newHead, [...paths, ...pairs.map((pair) => pair.after.path)]);
+    relocated = (0, import_source_references.relocateSourceRefs)(current.map((link) => link.ref), before, after, pairs);
+  }
+  const transitions = [];
+  let index = 0;
+  const links = review.links.map((link) => {
+    const before = link.ref;
+    if (before.revision === review.base) {
+      transitions.push({ link: link.id, status: "base-evidence", before });
+      return link;
+    }
+    const transition = relocated[index++];
+    transitions.push({ ...transition, link: link.id });
+    return transition.status === "unresolved" ? link : { ...link, ref: transition.after };
+  });
+  const next = parseReview({ ...review, head: newHead.revision, requirements, links, analyses: analysis ? [...review.analyses, analysis] : review.analyses });
+  return { review: next, transitions };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  correspondenceEvidence,
+  digest,
+  fingerprint,
+  inspect,
+  parseReview,
+  refresh,
+  requirementFingerprint
+});
+//# sourceMappingURL=requirements.js.map