@printpractical/cruze 0.0.13 → 0.0.15

package/dist/domain/land/merge_plan.js

@@ -1,137 +0,0 @@
-import { settledIds } from "../approvals/rebase.js";
-import { sectionForKind } from "../architecture_sections.js";
-import { CruzeError } from "../cruze_error.js";
-import { setStatus } from "../edits/status_lines.js";
-import { headingElements, statusOf,              } from "../elements.js";
-import { elementHash } from "../hashing.js";
-import { STATUS_KINDS, kindOf, scopeOf } from "../ids.js";
-import { findSection, parseMarkdown } from "../markdown.js";
-import { readDelta,                 } from "../project/deltas.js";
-import { PATHS, specPath } from "../project/layout.js";
-import { readScope } from "../project/plan_parts.js";
-                                                              
-                                                         
-import { REMOVED_MARK, capabilityKey } from "../validation/delta_rules.js";
-import { appendBlock, relevel, removeElement, replaceElement } from "./text_ops.js";
-
-                            
-                                                             
-                             
-                                                                                
-                                 
-                      
-                  
-                    
- 
-
-/**
- * Merges a change's work into the living docs. The first change of a feature to land merges
- * the whole delta; elements it doesn't build arrive as planned, and later changes flip what
- * they build to built. Text is replaced only when nobody else changed it since this work merged it,
- * and an element merged and unchanged in the delta since keeps its living text, whoever edited it.
- */
-export function planMerge(view             , change          , source          )            {
-  const scope = readScope(change.doc);
-  const inScope = new Set([...(scope?.delivers ?? []), ...(scope?.builds ?? [])]);
-  const delta = readDelta(source.doc);
-  const merged = { ...(view.approvals.get(source.folder)?.merged ?? {}) };
-  const files = new Map                ();
-  const text = (path        )         => files.get(path) ?? view.snapshot.get(path) ?? "";
-  const plan            = { files, merged, mergedIds: [], built: [], removed: [] };
-  const settled = settledIds(source.doc, merged);
-
-  for (const op of delta.capabilities) {
-    const key = capabilityKey(op.capability);
-    if (merged[key] !== undefined || view.snapshot.has(specPath(op.capability))) continue;
-    const body = source.doc.lines.slice(op.start + 1, op.end).join("\n").trim();
-    files.set(specPath(op.capability), `# ${op.title}\n\n${body}\n`);
-    merged[key] = "created";
-  }
-
-  for (const entry of delta.entries) {
-    const { id } = entry.element;
-    const path = entry.section === "spec" ? specPath(scopeOf(id) ?? "") : PATHS.architecture;
-    if (entry.element.op === "REMOVED") {
-      if (scope?.removes.includes(id) === true) {
-        files.set(path, removeElement(text(path), id));
-        merged[id] = REMOVED_MARK;
-        plan.removed.push(id);
-      }
-      continue;
-    }
-    const kept = settled.has(id) && view.living.elements.has(id);
-    if (!kept) mergeEntry(view, source, entry, path, text, files, merged, plan);
-    for (const target of [entry.element, ...entry.scenarios].filter((e) => STATUS_KINDS.includes(e.kind))) {
-      if (kept && !inScope.has(target.id)) continue;
-      files.set(path, setStatus(text(path), target.id, statusAfterMerge(view, source, target, inScope)));
-      if (inScope.has(target.id)) plan.built.push(target.id);
-    }
-  }
-
-  for (const id of [...inScope].filter((id) => !delta.ids.has(id) && STATUS_KINDS.includes(kindOf(id)))) {
-    const living = view.living.elements.get(id);
-    if (living === undefined) continue;
-    files.set(living.path, setStatus(text(living.path), id, "built"));
-    plan.built.push(id);
-  }
-  verifyMerged(source, delta.entries, text, plan);
-  return plan;
-}
-
-function mergeEntry(
-  view             ,
-  source          ,
-  entry            ,
-  path        ,
-  text                          ,
-  files                     ,
-  merged                        ,
-  plan           ,
-)       {
-  const { id } = entry.element;
-  const block = relevel(source.doc, entry.element.start, entry.element.end, entry.section === "spec" ? 2 : 3);
-  const deltaHash = elementHash(source.doc, entry.element);
-  const doc = parseMarkdown(text(path));
-  const living = headingElements(doc).find((e) => e.id === id);
-  const previous = merged[id];
-  if (living !== undefined) {
-    const livingHash = elementHash(doc, living);
-    if (previous !== undefined && previous !== REMOVED_MARK && livingHash !== previous) {
-      throw new CruzeError("merge-conflict", `${id} in ${path} changed since ${source.ref} merged it; rethink before landing`);
-    }
-    if (livingHash !== deltaHash) {
-      files.set(path, replaceElement(text(path), id, block));
-      plan.mergedIds.push(id);
-    }
-  } else {
-    if (previous !== undefined && previous !== REMOVED_MARK) {
-      throw new CruzeError("merge-conflict", `${id} was removed from ${path} after ${source.ref} merged it; rethink before landing`);
-    }
-    const section = entry.section === "spec" ? undefined : sectionForKind(entry.element.kind);
-    if (section !== undefined && findSection(doc, section) === null) throw new CruzeError("merge-conflict", `${path} has no "## ${section}" section for ${id}`);
-    files.set(path, appendBlock(text(path), block, section));
-    plan.mergedIds.push(id);
-  }
-  merged[id] = deltaHash;
-  for (const scenario of entry.scenarios) merged[scenario.id] = elementHash(source.doc, scenario);
-}
-
-/** Built when this change builds it, or when it was built and its text is unchanged; planned otherwise. */
-function statusAfterMerge(view             , source          , target         , inScope             )                      {
-  if (inScope.has(target.id)) return "built";
-  const before = view.living.elements.get(target.id);
-  if (before === undefined || statusOf(before.doc, before.element) !== "built") return "planned";
-  return elementHash(before.doc, before.element) === elementHash(source.doc, target) ? "built" : "planned";
-}
-
-/** After merging, every merged element must hash exactly as it did in the delta. */
-function verifyMerged(source          , entries              , text                          , plan           )       {
-  for (const entry of entries.filter((e) => plan.mergedIds.includes(e.element.id))) {
-    const path = entry.section === "spec" ? specPath(scopeOf(entry.element.id) ?? "") : PATHS.architecture;
-    const doc = parseMarkdown(text(path));
-    const living = headingElements(doc).find((e) => e.id === entry.element.id);
-    if (living === undefined || elementHash(doc, living) !== elementHash(source.doc, entry.element)) {
-      throw new Error(`merge check failed: ${entry.element.id} in ${path} does not match the delta`);
-    }
-  }
-}

package/dist/domain/land/text_ops.js

@@ -1,66 +0,0 @@
-import { headingElements, isStatusLine } from "../elements.js";
-import { parseMarkdown,                  } from "../markdown.js";
-
-/** Line-level edits land makes to living documents. Every function takes and returns whole text. */
-
-/**
- * A delta block ready for a living document: headings shifted so the element's own heading
- * sits at `level`, the operation prefix dropped, status lines removed, trailing blanks trimmed.
- */
-export function relevel(doc             , start        , end        , level        )           {
-  const own = /^(#{1,6}) /.exec(doc.lines[start] ?? "")?.[1]?.length ?? level;
-  const shift = level - own;
-  const out           = [];
-  for (let i = start; i < end; i++) {
-    let line = doc.lines[i] ?? "";
-    if (!doc.inFence[i]) {
-      if (isStatusLine(line)) continue;
-      const heading = /^(#{1,6}) (.*)$/.exec(line);
-      if (heading?.[1] !== undefined && heading[2] !== undefined) {
-        const text = i === start ? heading[2].replace(/^(ADDED|MODIFIED|REMOVED) /, "") : heading[2];
-        line = `${"#".repeat(heading[1].length + shift)} ${text}`;
-      }
-    }
-    out.push(line);
-  }
-  while (out.length > 0 && out[out.length - 1]?.trim() === "") out.pop();
-  return out;
-}
-
-/** Replaces an element's whole block, keeping one blank line before whatever follows. */
-export function replaceElement(text        , id        , block          )         {
-  const doc = parseMarkdown(text);
-  const element = headingElements(doc).find((e) => e.id === id);
-  if (element === undefined) throw new Error(`${id} is not in the document`);
-  const lines = [...doc.lines];
-  const follows = element.end < lines.length;
-  lines.splice(element.start, element.end - element.start, ...block, ...(follows ? [""] : []));
-  return lines.join("\n");
-}
-
-export function removeElement(text        , id        )         {
-  const doc = parseMarkdown(text);
-  const element = headingElements(doc).find((e) => e.id === id);
-  if (element === undefined) return text;
-  const lines = [...doc.lines];
-  lines.splice(element.start, element.end - element.start);
-  return lines.join("\n");
-}
-
-/** Appends a block at the end of a `##` section, or at the end of the document when none is named. */
-export function appendBlock(text        , block          , section         )         {
-  const doc = parseMarkdown(text);
-  const lines = [...doc.lines];
-  let at = lines.length;
-  if (section !== undefined) {
-    const heading = doc.headings.find((h) => h.level === 2 && h.text === section);
-    if (heading === undefined) throw new Error(`the document has no "## ${section}" section`);
-    at = doc.headings.find((h) => h.line > heading.line && h.level <= 2)?.line ?? lines.length;
-  }
-  let insertAt = at;
-  while (insertAt > 0 && lines[insertAt - 1]?.trim() === "") insertAt--;
-  const trailing = at < lines.length ? [""] : [];
-  lines.splice(insertAt, at - insertAt, "", ...block, ...trailing);
-  const joined = lines.join("\n");
-  return joined.endsWith("\n") ? joined : `${joined}\n`;
-}

package/dist/domain/line_diff.js

@@ -1,56 +0,0 @@
-/**
- * A line diff of two texts as unified-diff lines: "  " for a kept line, "- " removed, "+ " added.
- * Only the changes and `context` kept lines around each are shown; "…" marks the lines left out.
- */
-export function lineDiff(before          , after          , context = 2)           {
-  const ops = diffOps(before, after);
-  const near = new Set        ();
-  ops.forEach((op, i) => {
-    if (op.kind === " ") return;
-    for (let j = Math.max(0, i - context); j <= Math.min(ops.length - 1, i + context); j++) near.add(j);
-  });
-  const lines           = [];
-  let skipped = false;
-  ops.forEach((op, i) => {
-    if (!near.has(i)) {
-      skipped = true;
-      return;
-    }
-    if (skipped && lines.length > 0) lines.push("…");
-    skipped = false;
-    lines.push(`${op.kind} ${op.line}`);
-  });
-  if (skipped && lines.length > 0) lines.push("…");
-  return lines;
-}
-
-              
-                        
-               
- 
-
-/** The edit script of a longest common subsequence: documents are small enough for the quadratic table. */
-function diffOps(a          , b          )       {
-  const width = b.length + 1;
-  const table = new Int32Array((a.length + 1) * width);
-  const at = (i        , j        )         => table[i * width + j] ?? 0;
-  for (let i = a.length - 1; i >= 0; i--) {
-    for (let j = b.length - 1; j >= 0; j--) {
-      table[i * width + j] = a[i] === b[j] ? at(i + 1, j + 1) + 1 : Math.max(at(i + 1, j), at(i, j + 1));
-    }
-  }
-  const ops       = [];
-  let i = 0;
-  let j = 0;
-  while (i < a.length || j < b.length) {
-    if (i < a.length && j < b.length && a[i] === b[j]) {
-      ops.push({ kind: " ", line: a[i++] ?? "" });
-      j++;
-    } else if (j >= b.length || (i < a.length && at(i + 1, j) >= at(i, j + 1))) {
-      ops.push({ kind: "-", line: a[i++] ?? "" });
-    } else {
-      ops.push({ kind: "+", line: b[j++] ?? "" });
-    }
-  }
-  return ops;
-}

package/dist/domain/project/artifact_ref.js

@@ -1,42 +0,0 @@
-import { CruzeError } from "../cruze_error.js";
-import { PATHS } from "./layout.js";
-                                                     
-import { findWorkItem,               } from "./work_items.js";
-
-const NAMED                         = { vision: PATHS.vision, architecture: PATHS.architecture, roadmap: PATHS.roadmap };
-
-/**
- * Resolves what a person or skill names on the command line: `vision`, `architecture`,
- * `roadmap`, a work item ref such as `2026-09-25-open-console/01-local-serial`, the same ref
- * without its date (`open-console/local-serial`) when that names one active item, or a path.
- */
-export function resolveArtifact(view             , ref        )                                    {
-  const named = NAMED[ref];
-  if (named !== undefined) {
-    if (!view.snapshot.has(named)) throw new CruzeError("not-found", `${named} does not exist yet`);
-    return { path: named };
-  }
-  const item = findWorkItem(view.items, ref.replace(/\/$/, "")) ?? bySlug(view.items, ref.replace(/\/$/, ""));
-  if (item !== undefined) return { path: item.path, item };
-  if (view.snapshot.has(ref)) return { path: ref };
-  throw new CruzeError("not-found", `nothing called "${ref}"; use vision, architecture, roadmap, a feature or change ID, or a path`);
-}
-
-/** An active item named by its slug, without the date or the change number. */
-function bySlug(items            , ref        )                       {
-  const [head = "", change] = ref.split("/");
-  const undated = (name        )         => name.replace(/^\d{4}-\d{2}-\d{2}-/, "");
-  const matches = items.filter((i) => !i.archived && i.kind !== "change" && undated(i.folderName) === head);
-  if (matches.length > 1) throw new CruzeError("ambiguous", `"${head}" names ${matches.map((m) => m.ref).join(" and ")}; use the full ID`);
-  const base = matches[0];
-  if (base === undefined || change === undefined) return base;
-  return items.find((i) => i.featureRef === base.ref && (i.folderName === change || i.folderName.replace(/^\d\d-/, "") === change));
-}
-
-/** Resolves a change: a feature's change or a standalone change, never archived. */
-export function resolveChange(view             , ref        )           {
-  const { item } = resolveArtifact(view, ref);
-  if (item === undefined || item.kind === "feature") throw new CruzeError("not-a-change", `"${ref}" is not a change`);
-  if (item.archived) throw new CruzeError("archived", `${item.ref} has already landed`);
-  return item;
-}

package/dist/domain/project/deltas.js

@@ -1,49 +0,0 @@
-import { capabilityOps, headingElements,                                 } from "../elements.js";
-import { findSection,                  } from "../markdown.js";
-
-/** One delta operation on a living element, with its nested scenarios when it is a requirement. */
-                             
-                   
-                                   
-                                                                
-                       
- 
-
-                        
-                        
-                               
-                                                                         
-                   
- 
-
-export function readDelta(doc             )        {
-  const entries               = [];
-  const capabilities                 = [];
-  for (const [title, section] of [["Spec delta", "spec"], ["Architecture delta", "architecture"]]         ) {
-    const range = findSection(doc, title);
-    if (range === null) continue;
-    capabilities.push(...capabilityOps(doc, range.start, range.end));
-    const elements = headingElements(doc, range.start, range.end);
-    for (const element of elements.filter((e) => e.op !== undefined)) {
-      const scenarios = elements.filter((e) => e.op === undefined && e.start > element.start && e.start < element.end);
-      entries.push({ element, section, scenarios });
-    }
-  }
-  const ids = new Set(entries.flatMap((entry) => [entry.element.id, ...entry.scenarios.map((s) => s.id)]));
-  return { entries, capabilities, ids };
-}
-
-/** Scenario elements that sit under no requirement operation: always a format error. */
-export function orphanDeltaElements(doc             )            {
-  const orphans            = [];
-  for (const title of ["Spec delta", "Architecture delta"]) {
-    const range = findSection(doc, title);
-    if (range === null) continue;
-    const elements = headingElements(doc, range.start, range.end);
-    const ops = elements.filter((e) => e.op !== undefined);
-    for (const element of elements.filter((e) => e.op === undefined)) {
-      if (!ops.some((op) => element.start > op.start && element.start < op.end)) orphans.push(element);
-    }
-  }
-  return orphans;
-}

package/dist/domain/project/element_lookup.js

@@ -1,124 +0,0 @@
-import { elementLines, factsOf, statusOf,                                         } from "../elements.js";
-import { findIds, kindOf, scopeOf,           } from "../ids.js";
-                                                  
-import { readDelta } from "./deltas.js";
-import { PATHS } from "./layout.js";
-                                                     
-                                                    
-                                                
-
-/**
- * Elements one at a time, and an index of all of them, so a step that needs a few elements of a
- * large architecture fetches those instead of reading the whole file. One project's architecture
- * held 52k words, and a single architect run read all of it to find what it would extend.
- */
-
-                             
-             
-                
-             
-                                                                          
-                 
-                  
-                                                                           
-                 
-                                                        
-                     
-                                                          
-                      
-                                                        
-                   
- 
-
-                               
-                                                                                                        
-                                                 
-                        
- 
-
-const DOCS_INDEXED = (path        )          => path === PATHS.architecture || path.startsWith(`${PATHS.specsDir}/`);
-
-/**
- * Every element of the living architecture and specs, one entry each, with what in-flight work
- * adds. Without a scope, scenarios are counted under their requirement; with a context or
- * capability name, only its elements are listed, scenarios included.
- */
-export function elementIndex(view             , scope         )               {
-  const inScope = (id        )          => scope === undefined || scopeOf(id) === scope || id === `CTX-${scope}`;
-  const entries               = [];
-  const byId = new Map                    ();
-  for (const living of view.living.elements.values()) {
-    if (!DOCS_INDEXED(living.path) || !inScope(living.id) || (scope === undefined && kindOf(living.id) === "SCN")) continue;
-    const entry = entryOf(living.id, living.element, living.doc, living.path);
-    if (kindOf(living.id) === "REQ") entry.scenarios = scenarioCount(view, living.id);
-    entries.push(entry);
-    byId.set(entry.id, entry);
-  }
-  for (const item of inFlight(view)) {
-    for (const element of deltaElements(item)) {
-      if (!inScope(element.element.id) || (scope === undefined && element.element.kind === "SCN")) continue;
-      const known = byId.get(element.element.id);
-      if (known !== undefined) {
-        known.changedBy.push(item.ref);
-        continue;
-      }
-      const added = { ...entryOf(element.element.id, element.element, item.doc, item.ref), addedBy: item.ref };
-      entries.push(added);
-      byId.set(added.id, added);
-    }
-  }
-  return { words: livingWords(view), entries };
-}
-
-/** The bodies of the named elements: the living one, then each in-flight delta that changes it. */
-export function lookupElements(view             , ids          )                                                  {
-  const elements                 = [];
-  const missing           = [];
-  for (const id of ids) {
-    const found                 = [];
-    const living = view.living.elements.get(id);
-    if (living !== undefined) found.push(shown(living.doc, living.element, living.path));
-    for (const item of inFlight(view)) {
-      const delta = deltaElements(item).find((d) => d.element.id === id);
-      if (delta !== undefined) found.push({ ...shown(item.doc, delta.element, item.path), ...(delta.op === undefined ? {} : { op: delta.op }) });
-    }
-    if (found.length === 0) missing.push(id);
-    elements.push(...found);
-  }
-  return { elements, missing };
-}
-
-function entryOf(id        , element         , doc             , source        )             {
-  const facts = factsOf(doc, element);
-  const place = (facts.get("Module") ?? []).flatMap(findIds)[0] ?? (facts.get("Path") ?? [])[0];
-  const status = statusOf(doc, element);
-  return { id, title: element.title, kind: kindOf(id), source, changedBy: [], ...(status === undefined ? {} : { status }), ...(place === undefined ? {} : { place }) };
-}
-
-function shown(doc             , element         , path        )               {
-  return { id: element.id, title: element.title, source: `${path}:${element.start + 1}`, body: elementLines(doc, element) };
-}
-
-function inFlight(view             )             {
-  return view.items.filter((item) => !item.archived && item.kind !== "change");
-}
-
-/** Each element a work item's delta defines or changes, scenarios under a requirement included. */
-function deltaElements(item          )                                            {
-  return readDelta(item.doc).entries.flatMap((entry) => [
-    { element: entry.element, ...(entry.element.op === undefined ? {} : { op: entry.element.op }) },
-    ...entry.scenarios.map((scenario) => ({ element: scenario })),
-  ]);
-}
-
-function scenarioCount(view             , requirement        )         {
-  const living = view.living.elements.get(requirement);
-  if (living === undefined) return 0;
-  return [...view.living.elements.values()].filter((e) => e.path === living.path && e.id.startsWith("SCN-") && e.element.start > living.element.start && e.element.start < living.element.end).length;
-}
-
-function livingWords(view             )                                          {
-  const words = (path        )         => (view.snapshot.get(path) ?? "").split(/\s+/).filter((w) => w !== "").length;
-  const specs = [...view.living.docs.keys()].filter((path) => path.startsWith(`${PATHS.specsDir}/`));
-  return { architecture: words(PATHS.architecture), specs: specs.reduce((sum, path) => sum + words(path), 0) };
-}

package/dist/domain/project/living_model.js

@@ -1,55 +0,0 @@
-import { headingElements, rowElements,              } from "../elements.js";
-import { VISION_KINDS } from "../ids.js";
-import { parseMarkdown,                  } from "../markdown.js";
-import { PATHS, childFiles,               } from "./layout.js";
-
-/** An element of the living docs, with the document it lives in. */
-                                
-             
-               
-                   
-                   
- 
-
-/** The living docs: vision, architecture, specs and ADRs, indexed by element ID. */
-                              
-                                 
-                                       
-                                                                  
-                                                      
- 
-
-export function livingDocPaths(snapshot          )           {
-  const fixed = [PATHS.vision, PATHS.architecture].filter((path) => snapshot.has(path));
-  return [...fixed, ...childFiles(snapshot, PATHS.specsDir, ".md"), ...childFiles(snapshot, PATHS.adrDir, ".md")];
-}
-
-export function buildLivingModel(snapshot          )              {
-  const docs = new Map                     ();
-  const elements = new Map                       ();
-  const places = new Map                  ();
-
-  for (const path of livingDocPaths(snapshot)) {
-    const doc = parseMarkdown(snapshot.get(path) ?? "");
-    docs.set(path, doc);
-    for (const element of elementsOf(path, doc)) {
-      places.set(element.id, [...(places.get(element.id) ?? []), `${path}:${element.start + 1}`]);
-      if (!elements.has(element.id)) elements.set(element.id, { id: element.id, path, doc, element });
-    }
-  }
-  const duplicates = [...places].filter(([, at]) => at.length > 1).map(([id, at]) => ({ id, places: at }));
-  return { docs, elements, duplicates };
-}
-
-/** The ID an ADR file defines: `ADR-<file stem>`. */
-export function adrId(path        )         {
-  return `ADR-${path.slice(path.lastIndexOf("/") + 1, -".md".length)}`;
-}
-
-function elementsOf(path        , doc             )            {
-  if (path.startsWith(`${PATHS.adrDir}/`)) {
-    return [{ id: adrId(path), kind: "ADR", title: doc.headings[0]?.text ?? "", form: "heading", level: 1, start: 0, end: doc.lines.length }];
-  }
-  if (path === PATHS.vision) return rowElements(doc).filter((element) => VISION_KINDS.includes(element.kind));
-  return headingElements(doc);
-}

package/dist/domain/project/new_items.js

@@ -1,48 +0,0 @@
-import { CruzeError } from "../cruze_error.js";
-import { readChangesTable } from "./plan_parts.js";
-                                                     
-                                                
-
-const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
-export function requireSlug(slug        )       {
-  if (!SLUG.test(slug)) throw new CruzeError("invalid-slug", `"${slug}" must be lowercase words joined by single hyphens`);
-}
-
-/**
- * A new feature or standalone change ID: the date plus the slug, with `-2`, `-3`… added
- * on a clash with any live or archived work. IDs are never reused.
- */
-export function allocateId(view             , date        , slug        )         {
-  requireSlug(slug);
-  const taken = new Set(view.items.filter((item) => item.kind !== "change").map((item) => item.folderName));
-  const base = `${date}-${slug}`;
-  if (!taken.has(base)) return base;
-  for (let n = 2; ; n++) if (!taken.has(`${base}-${n}`)) return `${base}-${n}`;
-}
-
-/**
- * The change folder name for a feature's change: the row of the feature's Changes table it
- * names, by full name (`01-local-serial`) or slug (`local-serial`).
- */
-export function changeRow(view             , feature          , name        )                                              {
-  const rows = readChangesTable(feature.doc);
-  const row = rows.find((r) => r.change === name) ?? rows.find((r) => r.change.replace(/^\d\d-/, "") === name);
-  if (row === undefined) {
-    throw new CruzeError("change-not-listed", `${feature.ref} has no change "${name}" in its Changes table; add the row first`);
-  }
-  if (view.items.some((item) => item.featureRef === feature.ref && item.folderName === row.change)) {
-    throw new CruzeError("exists", `${feature.ref}/${row.change} already exists`);
-  }
-  return row;
-}
-
-/** Fills the template's frontmatter, title and scope lines for a new document. */
-export function fillTemplate(template        , values                                                              )         {
-  let text = template;
-  if (values.roadmap !== undefined) text = text.replace(/^roadmap: .*$/m, `roadmap: ${values.roadmap}`);
-  else text = text.replace(/^roadmap: <.*\n/m, "");
-  if (values.delivers !== undefined) text = text.replace(/^- Delivers: .*$/m, `- Delivers: ${values.delivers.join(", ")}`);
-  if (values.builds !== undefined) text = text.replace(/^- Builds: .*$/m, `- Builds: ${values.builds.join(", ")}`);
-  return text;
-}

package/dist/domain/project/notes.js

@@ -1,74 +0,0 @@
-import { findSection, parseMarkdown } from "../markdown.js";
-import { tablesIn } from "../markdown_tables.js";
-import { PATHS } from "./layout.js";
-                                            
-
-/**
- * Notes under `.cruze/notes/`: what the user brought, what explore captured, the evidence research
- * gathered, and the hand-off envision wrote from them. Each says what it is about, so a step reads
- * the notes for its work rather than guessing from file names: one project held 21 notes, and a
- * 9,500-word seed whose design sections no step was told to read.
- */
-
-export const NOTE_KINDS = ["input", "intake", "explore", "research"]         ;
-                                                   
-
-/** The step an intake row hands a part to, besides a feature on the map. */
-export const HANDOFF_STEPS = ["vision", "architect", "roadmap", "user"]         ;
-
-                             
-                                                                
-               
-                                                                                            
-                 
-                                                                                
-                 
-                                                                                                 
-                 
- 
-
-                       
-               
-                
-                
-                                                                   
-                  
-                        
- 
-
-export function readNotes(snapshot          )         {
-  return [...snapshot.keys()]
-    .filter((path) => path.startsWith(`${PATHS.notesDir}/`) && path.endsWith(".md"))
-    .sort()
-    .map((path) => readNote(path, snapshot.get(path) ?? ""));
-}
-
-function readNote(path        , text        )       {
-  const doc = parseMarkdown(text);
-  const title = doc.headings.find((h) => h.level === 1)?.text ?? path.slice(path.lastIndexOf("/") + 1, -".md".length);
-  const firstSection = doc.headings.find((h) => h.level === 2)?.line ?? doc.lines.length;
-  const fact = (key        )                     =>
-    doc.lines.slice(0, firstSection).map((line) => new RegExp(`^- ${key}: (.+)$`).exec(line)?.[1]?.trim()).find((v) => v !== undefined);
-  const about = (fact("About") ?? "").split(",").map((a) => a.trim()).filter((a) => a !== "");
-  const kind = fact("Kind");
-  const section = findSection(doc, "Hand-off");
-  const rows = section === null ? [] : (tablesIn(doc.lines, doc.inFence, section.start, section.end)[0]?.rows ?? []);
-  const handoff = rows.map(({ cells }) => ({ part: cells[0] ?? "", source: cells[1] ?? "", goesTo: (cells[2] ?? "").replace(/`/g, ""), status: cells[3] ?? "open" }));
-  return { path, title, about, handoff, ...(kind === undefined ? {} : { kind }) };
-}
-
-                           
-                                                                                        
-                
-                                                                                        
-                                                 
- 
-
-/** The notes and hand-off rows for a piece of work, named by its targets: `project`, a step, a feature slug or a context. */
-export function notesFor(notes        , targets          )           {
-  const wanted = new Set(targets);
-  return {
-    notes: notes.filter((note) => note.about.some((a) => wanted.has(a))),
-    handoffs: notes.flatMap((note) => note.handoff.filter((row) => wanted.has(row.goesTo)).map((row) => ({ ...row, note: note.path }))),
-  };
-}