npm - truecourse - Versions diffs - 0.7.0-next.5 → 0.7.0-next.7 - Mend

truecourse 0.7.0-next.5 → 0.7.0-next.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/cli.mjs +281 -69
package/package.json +1 -1
package/public/assets/{index-CI8n7IHP.js → index-D7hFPhQQ.js} +203 -203
package/public/index.html +1 -1
package/roslyn-host/csharp-roslyn-host.dll +0 -0
package/roslyn-host/csharp-roslyn-host.pdb +0 -0
package/server.mjs +207 -21

package/public/index.html CHANGED Viewed

@@ -20,7 +20,7 @@
         } catch (e) {}
       })();
     </script>
-    <script type="module" crossorigin src="/assets/index-CI8n7IHP.js"></script>
+    <script type="module" crossorigin src="/assets/index-D7hFPhQQ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CMCPeAwv.css">
   </head>
   <body class="font-sans">

package/roslyn-host/csharp-roslyn-host.dll CHANGED Viewed

Binary file

package/roslyn-host/csharp-roslyn-host.pdb CHANGED Viewed

Binary file

package/server.mjs CHANGED Viewed

@@ -28409,6 +28409,153 @@ var init_guard = __esm({
   }
 });
+// packages/shared/dist/spec/overlap-resolution.js
+function coveringRelationInAreas(relations, a, b, areas) {
+  return relations.find((r) => {
+    const samePair = r.older === a && r.newer === b || r.older === b && r.newer === a;
+    return samePair && (r.scope === void 0 || areas.includes(r.scope));
+  });
+}
+function dedupeCrossAreaOverlaps(entries) {
+  const byPair = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key4 = unorderedPairKey(e.overlap.docs[0], e.overlap.docs[1]);
+    const list = byPair.get(key4);
+    if (list)
+      list.push(e);
+    else
+      byPair.set(key4, [e]);
+  }
+  const merged = [];
+  for (const members of byPair.values()) {
+    const parent = members.map((_, i) => i);
+    const find = (i) => {
+      while (parent[i] !== i) {
+        parent[i] = parent[parent[i]];
+        i = parent[i];
+      }
+      return i;
+    };
+    const union = (i, j) => {
+      const ri = find(i);
+      const rj = find(j);
+      if (ri !== rj)
+        parent[Math.max(ri, rj)] = Math.min(ri, rj);
+    };
+    const ptrOwner = /* @__PURE__ */ new Map();
+    members.forEach((m, i) => {
+      for (const ptr of sectionPointerKeys(m.overlap)) {
+        const owner = ptrOwner.get(ptr);
+        if (owner === void 0)
+          ptrOwner.set(ptr, i);
+        else
+          union(owner, i);
+      }
+    });
+    const components = /* @__PURE__ */ new Map();
+    members.forEach((_, i) => {
+      const root = find(i);
+      const list = components.get(root);
+      if (list)
+        list.push(i);
+      else
+        components.set(root, [i]);
+    });
+    for (const idxs of components.values()) {
+      const group = idxs.map((i) => members[i]);
+      const rep = [...group].sort((x, y) => {
+        const px = preambleCount(x.overlap);
+        const py = preambleCount(y.overlap);
+        if (px !== py)
+          return px - py;
+        if (x.area !== y.area)
+          return x.area < y.area ? -1 : 1;
+        return (x.overlap.note ?? "") < (y.overlap.note ?? "") ? -1 : 1;
+      })[0];
+      const span = /* @__PURE__ */ new Set();
+      for (const g of group) {
+        span.add(g.area);
+        for (const a of g.overlap.areas ?? [])
+          span.add(a);
+      }
+      merged.push({ area: rep.area, areas: [...span].sort(), overlap: rep.overlap });
+    }
+  }
+  merged.sort((x, y) => {
+    if (x.area !== y.area)
+      return x.area < y.area ? -1 : 1;
+    return unorderedPairKey(x.overlap.docs[0], x.overlap.docs[1]) < unorderedPairKey(y.overlap.docs[0], y.overlap.docs[1]) ? -1 : 1;
+  });
+  return merged;
+}
+function buildCorpusConflicts(corpus, decisions) {
+  const userRelations = decisions.relations ?? [];
+  const effectiveRels = [...corpus.relations, ...userRelations];
+  const excludes = new Set(decisions.manualExcludes ?? []);
+  const entries = [];
+  for (const area of corpus.areas)
+    for (const ov of area.overlaps)
+      entries.push({ area: area.id, overlap: ov });
+  const mergedOverlaps = dedupeCrossAreaOverlaps(entries);
+  const flagged = [];
+  for (const m of mergedOverlaps) {
+    const [a, b] = m.overlap.docs;
+    const relation = coveringRelationInAreas(effectiveRels, a, b, m.areas);
+    const userRelation = coveringRelationInAreas(userRelations, a, b, m.areas);
+    const excludedRef = excludes.has(a) ? a : excludes.has(b) ? b : void 0;
+    flagged.push({
+      area: m.area,
+      areas: m.areas,
+      a,
+      b,
+      note: m.overlap.note ?? "",
+      resolved: relation !== void 0 || excludedRef !== void 0,
+      synthesized: false,
+      ...relation ? { relation } : {},
+      ...userRelation ? { userRelation } : {},
+      ...excludedRef ? { excludedRef } : {}
+    });
+  }
+  const coversFlagged = (r) => flagged.some((o) => {
+    const samePair = o.a === r.older && o.b === r.newer || o.a === r.newer && o.b === r.older;
+    return samePair && (r.scope === void 0 || o.areas.includes(r.scope));
+  });
+  const synthesized = userRelations.filter((r) => !coversFlagged(r)).map((r) => ({
+    area: r.scope ?? "",
+    areas: r.scope ? [r.scope] : [],
+    a: r.older,
+    b: r.newer,
+    note: r.note ?? "",
+    resolved: true,
+    synthesized: true,
+    relation: r,
+    userRelation: r
+  }));
+  return [...flagged, ...synthesized];
+}
+function openConflicts(corpus, decisions) {
+  return buildCorpusConflicts(corpus, decisions).filter((c) => !c.resolved);
+}
+var PREAMBLE_PTR, NUL, unorderedPairKey, sectionPointerKeys, preambleCount;
+var init_overlap_resolution = __esm({
+  "packages/shared/dist/spec/overlap-resolution.js"() {
+    "use strict";
+    PREAMBLE_PTR = "\0preamble";
+    NUL = "\0";
+    unorderedPairKey = (a, b) => a < b ? `${a}${NUL}${b}` : `${b}${NUL}${a}`;
+    sectionPointerKeys = (ov) => (ov.sections ?? []).map((s) => `${s.doc}${NUL}${s.heading ?? PREAMBLE_PTR}`);
+    preambleCount = (ov) => (ov.sections ?? []).filter((s) => s.heading === null || s.heading === void 0).length;
+  }
+});
+// packages/shared/dist/spec/index.js
+var init_spec = __esm({
+  "packages/shared/dist/spec/index.js"() {
+    "use strict";
+    init_overlap_resolution();
+  }
+});
 // node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js
 var require_ignore = __commonJS({
   "node_modules/.pnpm/ignore@7.0.5/node_modules/ignore/index.js"(exports, module) {
@@ -28999,6 +29146,7 @@ var init_dist = __esm({
     init_types2();
     init_schemas();
     init_guard();
+    init_spec();
     init_tcignore();
     init_skip_dirs();
     init_spec_scope();
@@ -197014,7 +197162,16 @@ var OverlapSchema = external_exports.object({
   /** Short note on what may disagree ("auth0_id vs auth0_sub"). */
   note: external_exports.string().default(""),
   /** The specific conflicting sections per doc (markdown headings), when known. */
-  sections: external_exports.array(OverlapSectionSchema).default([])
+  sections: external_exports.array(OverlapSectionSchema).default([]),
+  /**
+   * The area ids this dispute spans. Detection runs per area, so one disagreement
+   * on a doc pair sharing several areas is flagged in each; the cross-area merge
+   * collapses those to this single record and lists every area it spanned here, so
+   * a resolution scoped to any of them clears the dispute everywhere. Empty for
+   * older corpora written before the merge — the read layer recomputes the span
+   * from the per-area placement of the (then-duplicated) records.
+   */
+  areas: external_exports.array(external_exports.string()).default([])
 });
 var AreaSchema = external_exports.object({
   /** Canonical area id, `product/concern`. */
@@ -197789,6 +197946,7 @@ init_zod();
 import { createHash as createHash6 } from "node:crypto";
 import fs28 from "node:fs";
 init_transport();
+init_dist();
 var DEFAULT_MAX_PAIRS_PER_AREA = 60;
 async function flagOverlaps(repoRoot, areas, docs, opts = {}) {
   const result = /* @__PURE__ */ new Map();
@@ -197860,7 +198018,7 @@ async function flagOverlaps(repoRoot, areas, docs, opts = {}) {
         examineOne(repoRoot, pair.areaId, pair.a, pair.b, runner2).then((verdict) => {
           if (verdict.overlap) {
             const list = result.get(pair.areaId) ?? [];
-            list.push({ docs: [pair.a.path, pair.b.path], note: verdict.note, sections: verdict.sections ?? [] });
+            list.push({ docs: [pair.a.path, pair.b.path], note: verdict.note, sections: verdict.sections ?? [], areas: [] });
             result.set(pair.areaId, list);
           }
         }).catch(() => {
@@ -197878,19 +198036,13 @@ async function flagOverlaps(repoRoot, areas, docs, opts = {}) {
     };
     launch();
   });
-  const seenKeys = /* @__PURE__ */ new Set();
-  for (const areaId of [...result.keys()].sort()) {
-    const kept = result.get(areaId).filter((ov) => {
-      const key4 = overlapDedupKey(ov);
-      if (seenKeys.has(key4))
-        return false;
-      seenKeys.add(key4);
-      return true;
-    });
-    if (kept.length === 0)
-      result.delete(areaId);
-    else
-      result.set(areaId, kept);
+  const entries = [...result].flatMap(([area, list]) => list.map((overlap) => ({ area, overlap })));
+  const merged = dedupeCrossAreaOverlaps(entries);
+  result.clear();
+  for (const m of merged) {
+    const list = result.get(m.area) ?? [];
+    list.push({ ...m.overlap, areas: m.areas });
+    result.set(m.area, list);
   }
   for (const [areaId, list] of result) {
     list.sort((x, y) => x.docs.join() < y.docs.join() ? -1 : 1);
@@ -197898,11 +198050,6 @@ async function flagOverlaps(repoRoot, areas, docs, opts = {}) {
   }
   return result;
 }
-function overlapDedupKey(ov) {
-  const docs = [...ov.docs].sort().join("::");
-  const secs = (ov.sections ?? []).map((s) => `${s.doc}|${s.heading}`).sort().join("::");
-  return `${docs}##${secs}`;
-}
 async function examineOne(repoRoot, areaId, a, b, runner2) {
   const cacheKey = computeCacheKey4(areaId, a, b);
   const cached = await readCache3(repoRoot, cacheKey);
@@ -232294,7 +232441,7 @@ function readToolVersion() {
   if (cachedVersion)
     return cachedVersion;
   if (true) {
-    cachedVersion = "0.7.0-next.5";
+    cachedVersion = "0.7.0-next.7";
     return cachedVersion;
   }
   try {
@@ -239986,7 +240133,41 @@ var guard_default = router13;
 var import_express14 = __toESM(require_express2(), 1);
 // packages/core/dist/commands/guard-in-process.js
+init_dist();
 init_transport();
+var OpenConflictsError = class extends Error {
+  conflicts;
+  constructor(conflicts2) {
+    super(formatOpenConflictsMessage(conflicts2));
+    this.conflicts = conflicts2;
+    this.name = "OpenConflictsError";
+  }
+};
+function formatOpenConflictsMessage(conflicts2) {
+  const lines = [
+    `${conflicts2.length} open spec conflict${conflicts2.length === 1 ? "" : "s"} must be resolved before guard generate.`,
+    "Extracting both sides of an unresolved overlap births a red finding that is really the dispute.",
+    ""
+  ];
+  for (const c of conflicts2) {
+    lines.push(`  ${c.area}`);
+    lines.push(`    ${c.a}  \u2194  ${c.b}`);
+    if (c.note)
+      lines.push(`    ${c.note}`);
+  }
+  lines.push("");
+  lines.push("Resolve them with `truecourse spec conflicts list` (or the dashboard Conflicts group), then re-run `truecourse guard generate`.");
+  return lines.join("\n");
+}
+async function assertNoOpenConflicts(repoRoot) {
+  const corpus = await getCorpus(repoRoot);
+  if (!corpus)
+    return;
+  const decisions = await getDecisions(repoRoot);
+  const open = openConflicts(corpus, decisions);
+  if (open.length > 0)
+    throw new OpenConflictsError(open);
+}
 var GUARD_GENERATE_STEPS = [
   { key: "index", label: "Indexing sections" },
   { key: "extract", label: "Extracting claims" },
@@ -240022,6 +240203,7 @@ function resolveTransport2(options) {
 }
 async function guardGenerateInProcess(repoRoot, options = {}) {
   const { tracker } = options;
+  await assertNoOpenConflicts(repoRoot);
   if (options.onLlmEstimate) {
     const prices = await getModelPrices();
     const estimate = await estimateGuardTokens(repoRoot, prices);
@@ -240270,6 +240452,10 @@ router14.post("/:id/guard/generate", async (req, res, next) => {
       res.json({ cancelled: true });
       return;
     }
+    if (e instanceof OpenConflictsError) {
+      res.status(422).json({ error: e.message });
+      return;
+    }
     emitSpecProgress(repoId, { step: "error", percent: 100, detail: e.message });
     next(e);
   } finally {