@printpractical/cruze 0.0.13 → 0.0.14

package/src/domain/project/artifact_ref.ts

@@ -1,42 +0,0 @@
-import { CruzeError } from "../cruze_error.ts";
-import { PATHS } from "./layout.ts";
-import type { ProjectView } from "./project_view.ts";
-import { findWorkItem, type WorkItem } from "./work_items.ts";
-
-const NAMED: Record<string, string> = { 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: ProjectView, ref: string): { path: string; item?: WorkItem } {
-  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: WorkItem[], ref: string): WorkItem | undefined {
-  const [head = "", change] = ref.split("/");
-  const undated = (name: string): string => 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: ProjectView, ref: string): WorkItem {
-  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/src/domain/project/deltas.ts

@@ -1,49 +0,0 @@
-import { capabilityOps, headingElements, type CapabilityOp, type Element } from "../elements.ts";
-import { findSection, type MarkdownDoc } from "../markdown.ts";
-
-/** One delta operation on a living element, with its nested scenarios when it is a requirement. */
-export interface DeltaEntry {
-  element: Element;
-  section: "spec" | "architecture";
-  /** Scenario elements nested under a requirement operation. */
-  scenarios: Element[];
-}
-
-export interface Delta {
-  entries: DeltaEntry[];
-  capabilities: CapabilityOp[];
-  /** Every ID a delta defines or changes, including nested scenarios. */
-  ids: Set<string>;
-}
-
-export function readDelta(doc: MarkdownDoc): Delta {
-  const entries: DeltaEntry[] = [];
-  const capabilities: CapabilityOp[] = [];
-  for (const [title, section] of [["Spec delta", "spec"], ["Architecture delta", "architecture"]] as const) {
-    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: MarkdownDoc): Element[] {
-  const orphans: Element[] = [];
-  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/src/domain/project/element_lookup.ts

@@ -1,124 +0,0 @@
-import { elementLines, factsOf, statusOf, type DeltaOp, type Element, type Status } from "../elements.ts";
-import { findIds, kindOf, scopeOf, type Kind } from "../ids.ts";
-import type { MarkdownDoc } from "../markdown.ts";
-import { readDelta } from "./deltas.ts";
-import { PATHS } from "./layout.ts";
-import type { ProjectView } from "./project_view.ts";
-import type { ShownElement } from "./scope_view.ts";
-import type { WorkItem } from "./work_items.ts";
-
-/**
- * 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.
- */
-
-export interface IndexEntry {
-  id: string;
-  title: string;
-  kind: Kind;
-  /** The living document that holds it, or the work item that adds it. */
-  source: string;
-  status?: Status;
-  /** Where its code lives: the `Module` it names, or a module's `Path`. */
-  place?: string;
-  /** For a requirement, how many scenarios it holds. */
-  scenarios?: number;
-  /** Work in flight whose delta changes or removes it. */
-  changedBy: string[];
-  /** Set when only in-flight work defines it so far. */
-  addedBy?: string;
-}
-
-export interface ElementIndex {
-  /** The words in the living architecture and specs, so a step can judge whether to read them whole. */
-  words: { architecture: number; specs: number };
-  entries: IndexEntry[];
-}
-
-const DOCS_INDEXED = (path: string): boolean => 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: ProjectView, scope?: string): ElementIndex {
-  const inScope = (id: string): boolean => scope === undefined || scopeOf(id) === scope || id === `CTX-${scope}`;
-  const entries: IndexEntry[] = [];
-  const byId = new Map<string, IndexEntry>();
-  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: ProjectView, ids: string[]): { elements: ShownElement[]; missing: string[] } {
-  const elements: ShownElement[] = [];
-  const missing: string[] = [];
-  for (const id of ids) {
-    const found: ShownElement[] = [];
-    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: string, element: Element, doc: MarkdownDoc, source: string): IndexEntry {
-  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: MarkdownDoc, element: Element, path: string): ShownElement {
-  return { id: element.id, title: element.title, source: `${path}:${element.start + 1}`, body: elementLines(doc, element) };
-}
-
-function inFlight(view: ProjectView): WorkItem[] {
-  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: WorkItem): Array<{ element: Element; op?: DeltaOp }> {
-  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: ProjectView, requirement: string): number {
-  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: ProjectView): { architecture: number; specs: number } {
-  const words = (path: string): number => (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/src/domain/project/living_model.ts

@@ -1,55 +0,0 @@
-import { headingElements, rowElements, type Element } from "../elements.ts";
-import { VISION_KINDS } from "../ids.ts";
-import { parseMarkdown, type MarkdownDoc } from "../markdown.ts";
-import { PATHS, childFiles, type Snapshot } from "./layout.ts";
-
-/** An element of the living docs, with the document it lives in. */
-export interface LivingElement {
-  id: string;
-  path: string;
-  doc: MarkdownDoc;
-  element: Element;
-}
-
-/** The living docs: vision, architecture, specs and ADRs, indexed by element ID. */
-export interface LivingModel {
-  docs: Map<string, MarkdownDoc>;
-  elements: Map<string, LivingElement>;
-  /** IDs defined more than once, with every place they appear. */
-  duplicates: Array<{ id: string; places: string[] }>;
-}
-
-export function livingDocPaths(snapshot: Snapshot): string[] {
-  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: Snapshot): LivingModel {
-  const docs = new Map<string, MarkdownDoc>();
-  const elements = new Map<string, LivingElement>();
-  const places = new Map<string, string[]>();
-
-  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: string): string {
-  return `ADR-${path.slice(path.lastIndexOf("/") + 1, -".md".length)}`;
-}
-
-function elementsOf(path: string, doc: MarkdownDoc): Element[] {
-  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/src/domain/project/new_items.ts

@@ -1,48 +0,0 @@
-import { CruzeError } from "../cruze_error.ts";
-import { readChangesTable } from "./plan_parts.ts";
-import type { ProjectView } from "./project_view.ts";
-import type { WorkItem } from "./work_items.ts";
-
-const SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-
-export function requireSlug(slug: string): void {
-  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: ProjectView, date: string, slug: string): string {
-  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: ProjectView, feature: WorkItem, name: string): ReturnType<typeof readChangesTable>[number] {
-  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: string, values: { roadmap?: string; delivers?: string[]; builds?: string[] }): string {
-  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/src/domain/project/notes.ts

@@ -1,74 +0,0 @@
-import { findSection, parseMarkdown } from "../markdown.ts";
-import { tablesIn } from "../markdown_tables.ts";
-import { PATHS } from "./layout.ts";
-import type { Snapshot } from "./layout.ts";
-
-/**
- * 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"] as const;
-export type NoteKind = (typeof NOTE_KINDS)[number];
-
-/** The step an intake row hands a part to, besides a feature on the map. */
-export const HANDOFF_STEPS = ["vision", "architect", "roadmap", "user"] as const;
-
-export interface HandoffRow {
-  /** The part of the input, by its heading or a short quote. */
-  part: string;
-  /** Where it is: a note path and heading, or "below" for text saved in the intake note. */
-  source: string;
-  /** A step from HANDOFF_STEPS, or the slug of the feature that takes it up. */
-  goesTo: string;
-  /** `open` until the step that takes it up settles it with the user: `settled` or `dropped`. */
-  status: string;
-}
-
-export interface Note {
-  path: string;
-  title: string;
-  kind?: string;
-  /** `project`, feature slugs, or context and capability names. */
-  about: string[];
-  handoff: HandoffRow[];
-}
-
-export function readNotes(snapshot: Snapshot): Note[] {
-  return [...snapshot.keys()]
-    .filter((path) => path.startsWith(`${PATHS.notesDir}/`) && path.endsWith(".md"))
-    .sort()
-    .map((path) => readNote(path, snapshot.get(path) ?? ""));
-}
-
-function readNote(path: string, text: string): Note {
-  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: string): string | undefined =>
-    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 }) };
-}
-
-export interface NotesFor {
-  /** Notes about one of the targets, or about the whole project when it is a target. */
-  notes: Note[];
-  /** Intake rows handed to one of the targets, with the intake note that holds them. */
-  handoffs: Array<HandoffRow & { note: string }>;
-}
-
-/** 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: Note[], targets: string[]): NotesFor {
-  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 }))),
-  };
-}

package/src/domain/project/plan_parts.ts

@@ -1,111 +0,0 @@
-import { findIds } from "../ids.ts";
-import { findSection, type MarkdownDoc } from "../markdown.ts";
-import { tablesIn } from "../markdown_tables.ts";
-
-/** The parts of feature.md and change.md that describe what gets built and how it is proved. */
-
-export interface Scope {
-  delivers: string[];
-  builds: string[];
-  removes: string[];
-  line: number;
-}
-
-export interface Task {
-  number: string;
-  owner: string;
-  paths: string[];
-  proves: string[];
-  line: number;
-}
-
-export interface TestPlanRow {
-  subject: string;
-  seam: string;
-  file: string;
-  kind: string;
-  line: number;
-}
-
-export interface ChangeRow {
-  change: string;
-  delivers: string[];
-  builds: string[];
-  removes: string[];
-  dependsOn: string[];
-  line: number;
-}
-
-const TASK = /^- (T\d+): `([^`]+)`[^`]*? in ((?:`[^`]+`(?:, )?)+), proves (.+)$/;
-
-export function readScope(doc: MarkdownDoc): Scope | null {
-  const section = findSection(doc, "Scope");
-  if (section === null) return null;
-  const scope: Scope = { delivers: [], builds: [], removes: [], line: section.heading.line };
-  for (let i = section.start; i < section.end; i++) {
-    const match = /^- (Delivers|Builds|Removes): (.*)$/.exec(doc.lines[i] ?? "");
-    if (match?.[1] === undefined || match[2] === undefined) continue;
-    const key = match[1].toLowerCase() as "delivers" | "builds" | "removes";
-    scope[key] = findIds(match[2]);
-  }
-  return scope;
-}
-
-/** Task lines, and the lines under `## Tasks` that don't parse as tasks. */
-export function readTasks(doc: MarkdownDoc): { tasks: Task[]; malformed: number[] } {
-  const section = findSection(doc, "Tasks");
-  const tasks: Task[] = [];
-  const malformed: number[] = [];
-  if (section === null) return { tasks, malformed };
-  for (let i = section.start; i < section.end; i++) {
-    const line = doc.lines[i] ?? "";
-    if (!line.startsWith("- ")) continue;
-    const match = TASK.exec(line);
-    if (match?.[1] === undefined || match[2] === undefined || match[3] === undefined || match[4] === undefined) {
-      malformed.push(i);
-      continue;
-    }
-    const paths = [...match[3].matchAll(/`([^`]+)`/g)].map((m) => m[1] ?? "");
-    tasks.push({ number: match[1], owner: match[2], paths, proves: findIds(match[4]), line: i });
-  }
-  return { tasks, malformed };
-}
-
-/**
- * Whether a change has been planned. A standalone change is designed first, with an
- * empty test plan and no tasks; plan fills both.
- */
-export function isPlanned(doc: MarkdownDoc): boolean {
-  const { tasks, malformed } = readTasks(doc);
-  return readTestPlan(doc).length > 0 || tasks.length > 0 || malformed.length > 0;
-}
-
-export function readTestPlan(doc: MarkdownDoc): TestPlanRow[] {
-  const section = findSection(doc, "Test plan");
-  if (section === null) return [];
-  const table = tablesIn(doc.lines, doc.inFence, section.start, section.end)[0];
-  return (table?.rows ?? []).map(({ cells, line }) => ({
-    subject: cells[0] ?? "",
-    seam: cells[1] ?? "",
-    file: (cells[2] ?? "").replace(/`/g, ""),
-    kind: cells[3] ?? "",
-    line,
-  }));
-}
-
-export function readChangesTable(doc: MarkdownDoc): ChangeRow[] {
-  const section = findSection(doc, "Changes");
-  if (section === null) return [];
-  const table = tablesIn(doc.lines, doc.inFence, section.start, section.end)[0];
-  if (table === undefined) return [];
-  const column = (name: string): number => table.header.findIndex((cell) => cell.toLowerCase() === name);
-  const cell = (cells: string[], name: string): string => cells[column(name)] ?? "";
-  return table.rows.map(({ cells, line }) => ({
-    change: cells[0] ?? "",
-    delivers: findIds(cell(cells, "delivers")),
-    builds: findIds(cell(cells, "builds")),
-    removes: findIds(cell(cells, "removes")),
-    dependsOn: cell(cells, "depends on").split(",").map((s) => s.trim()).filter((s) => s !== ""),
-    line,
-  }));
-}

package/src/domain/project/progress.ts

@@ -1,43 +0,0 @@
-import { MANAGED_CLOSE, MANAGED_OPEN, type MarkdownDoc } from "../markdown.ts";
-
-/** The managed `## Progress` block of a feature or change. */
-export interface Progress {
-  branch?: string;
-  /** Task number to the commit that completed it, or null while open. */
-  tasks: Map<string, string | null>;
-  deviations: string[];
-  landed?: string;
-  /** For a feature: each change's state line. */
-  changes: Map<string, string>;
-}
-
-export function readProgress(doc: MarkdownDoc): Progress {
-  const progress: Progress = { tasks: new Map(), deviations: [], changes: new Map() };
-  const range = progressRange(doc);
-  if (range === null) return progress;
-  for (let i = range.start; i < range.end; i++) {
-    const line = doc.lines[i] ?? "";
-    let match = /^- Branch: (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.branch = match[1].trim();
-    match = /^- \[([ x])\] (T\d+)(?: \(([0-9a-f]+)\))?/.exec(line);
-    if (match?.[2] !== undefined) progress.tasks.set(match[2], match[1] === "x" ? (match[3] ?? "") : null);
-    match = /^- Deviation (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.deviations.push(match[1]);
-    match = /^- Landed: (.+)$/.exec(line);
-    if (match?.[1] !== undefined) progress.landed = match[1];
-    match = /^- (\d\d-[a-z0-9-]+): (.+)$/.exec(line);
-    if (match?.[1] !== undefined && match[2] !== undefined) progress.changes.set(match[1], match[2]);
-  }
-  return progress;
-}
-
-/** Lines [start, end) inside the managed block that holds `## Progress`, or null. */
-export function progressRange(doc: MarkdownDoc): { open: number; start: number; end: number } | null {
-  const heading = doc.headings.find((h) => h.level === 2 && h.text === "Progress");
-  if (heading === undefined || !doc.inManaged[heading.line]) return null;
-  let open = heading.line;
-  while (open > 0 && doc.lines[open]?.trim() !== MANAGED_OPEN) open--;
-  let end = heading.line;
-  while (end < doc.lines.length && doc.lines[end]?.trim() !== MANAGED_CLOSE) end++;
-  return { open, start: heading.line + 1, end };
-}

package/src/domain/project/project_view.ts

@@ -1,72 +0,0 @@
-import { parseApprovals, type ApprovalsFile } from "../approvals/records.ts";
-import { parseConfig, type ConfigResult } from "../config.ts";
-import { journalPath, parseJournal, type JournalEntry } from "../journal.ts";
-import { PATHS, type Snapshot } from "./layout.ts";
-import { buildLivingModel, type LivingModel } from "./living_model.ts";
-import { readDelta } from "./deltas.ts";
-import { listWorkItems, type WorkItem } from "./work_items.ts";
-
-/** Everything the rules need, loaded once from a snapshot. */
-export interface ProjectView {
-  snapshot: Snapshot;
-  living: LivingModel;
-  items: WorkItem[];
-  config: ConfigResult | null;
-  /** Approvals by the folder (or `.cruze` for project documents) that holds them. */
-  approvals: Map<string, ApprovalsFile>;
-  /** Problems reading approvals files, by path. */
-  approvalProblems: Map<string, string>;
-  /** IDs retired by archived work: never to be reused. */
-  retired: Set<string>;
-  /** Every journal entry in the project, oldest first. */
-  journal: JournalEntry[];
-  /** Journal lines that are not valid entries, by path. */
-  journalProblems: Map<string, number[]>;
-}
-
-export function buildProjectView(snapshot: Snapshot): ProjectView {
-  const items = listWorkItems(snapshot);
-  const approvals = new Map<string, ApprovalsFile>();
-  const approvalProblems = new Map<string, string>();
-  for (const folder of [".cruze", ...items.map((item) => item.folder)]) {
-    const path = approvalsPath(folder);
-    const { file, problem } = parseApprovals(snapshot.get(path));
-    approvals.set(folder, file);
-    if (problem !== undefined) approvalProblems.set(path, problem);
-  }
-  const retired = new Set(
-    items
-      .filter((item) => item.archived)
-      .flatMap((item) => readDelta(item.doc).entries.filter((e) => e.element.op === "REMOVED").map((e) => e.element.id)),
-  );
-  const journal: JournalEntry[] = [];
-  const journalProblems = new Map<string, number[]>();
-  for (const folder of [".cruze", ...items.map((item) => item.folder)]) {
-    const path = journalPath(folder);
-    const { entries, badLines } = parseJournal(snapshot.get(path));
-    journal.push(...entries);
-    if (badLines.length > 0) journalProblems.set(path, badLines);
-  }
-  journal.sort((a, b) => a.at.localeCompare(b.at));
-  const configText = snapshot.get(PATHS.config);
-  return {
-    snapshot,
-    living: buildLivingModel(snapshot),
-    items,
-    config: configText === undefined ? null : parseConfig(configText),
-    approvals,
-    approvalProblems,
-    retired,
-    journal,
-    journalProblems,
-  };
-}
-
-export function approvalsPath(folder: string): string {
-  return `${folder}/approvals.json`;
-}
-
-/** The folder that holds an artifact's approval: the work item's folder, or `.cruze` for project documents. */
-export function approvalFolder(view: ProjectView, artifactPath: string): string {
-  return view.items.find((item) => item.path === artifactPath)?.folder ?? ".cruze";
-}

package/src/domain/project/roadmap.ts

@@ -1,43 +0,0 @@
-import { readRows } from "../edits/managed_tables.ts";
-import { parseMarkdown } from "../markdown.ts";
-import { tablesIn } from "../markdown_tables.ts";
-
-/** The items of `docs/roadmap.md`, as the cruze-formats skill defines them. */
-
-export interface RoadmapItem {
-  slug: string;
-  kind: string;
-  goals: string;
-  blockedBy: string[];
-  phase: number;
-  line: number;
-}
-
-export interface RoadmapStatusRow {
-  slug: string;
-  id: string;
-  state: string;
-}
-
-/** Every item in the roadmap's phases, in the order they appear. */
-export function readRoadmapItems(text: string): RoadmapItem[] {
-  const doc = parseMarkdown(text);
-  const items: RoadmapItem[] = [];
-  for (const phase of doc.headings.filter((h) => h.level === 3 && /^Phase \d+: /.test(h.text))) {
-    const number = Number(/^Phase (\d+)/.exec(phase.text)?.[1] ?? 0);
-    const end = doc.headings.find((h) => h.line > phase.line && h.level <= 3)?.line ?? doc.lines.length;
-    for (const table of tablesIn(doc.lines, doc.inFence, phase.line + 1, end)) {
-      for (const { cells, line } of table.rows) {
-        const [slug = "", kind = "", goals = "", blocked = ""] = cells;
-        const blockedBy = blocked.split(",").map((s) => s.trim()).filter((s) => s !== "");
-        items.push({ slug, kind, goals, blockedBy, phase: number, line });
-      }
-    }
-  }
-  return items;
-}
-
-/** The managed `## Status` rows: each started item's folder ID and state. */
-export function readRoadmapStatus(text: string): RoadmapStatusRow[] {
-  return readRows(text, "Status").map(([slug = "", id = "", state = ""]) => ({ slug, id, state }));
-}