dravoice 0.1.2 → 0.1.4

package/src/v2/prompt.js

@@ -1,64 +1,65 @@
-import fs from "node:fs";
-import path from "node:path";
-import { loadVoicePackV2 } from "./profile.js";
-
-export function voicePromptPackV2({ voice, format = "agents", outPath }) {
-  const profile = typeof voice === "string" ? loadVoicePackV2(voice) : voice;
-  if (format !== "agents" && format !== "claude" && format !== "system") {
-    throw new Error(`Unsupported prompt format: ${format}`);
-  }
-  const rendered = renderPrompt(profile, format);
-  if (outPath) {
-    fs.mkdirSync(path.dirname(outPath), { recursive: true });
-    fs.writeFileSync(outPath, rendered, "utf8");
-  }
-  return rendered;
-}
-
-function renderPrompt(profile, format) {
-  const header = {
-    agents: "# Dravoice V2 Writing Guidance",
-    claude: "# CLAUDE.md guidance for Dravoice V2",
-    system: "System writing guidance: Dravoice V2",
-  }[format];
-  const preface = {
-    agents: "Use this as local, inspectable drafting guidance from the writer's own corpus. It is not an AI detector or a license to imitate a third party.",
-    claude: "Use these project-local voice notes when drafting or reviewing prose for this repository. Treat them as guidance, not identity proof.",
-    system: "Follow these local voice constraints when writing prose. Do not expose private source text or claim authorship identity from them.",
-  }[format];
-  const lines = [
-    header,
-    "",
-    preface,
-    "",
-    "## Summary",
-    "",
-    ...profile.guidance.summary.map((item) => `- ${item}`),
-    "",
-    "## Feature Families",
-    "",
-  ];
-
-  for (const [name, family] of Object.entries(profile.families)) {
-    lines.push(`- ${name}: ${family.confidence} confidence; ${family.revisionHandles[0]}`);
-  }
-
-  lines.push("", "## Drafting Rules", "");
-  for (const rule of profile.guidance.draftingRules) {
-    lines.push(`- ${rule}`);
-  }
-
-  lines.push("", "## Avoid", "");
-  for (const item of profile.guidance.avoid) {
-    lines.push(`- ${item}`);
-  }
-
-  if (profile.guidance.examples.length) {
-    lines.push("", "## Source-Backed Examples", "");
-    for (const example of profile.guidance.examples) {
-      lines.push(`- ${example}`);
-    }
-  }
-
-  return `${lines.join("\n")}\n`;
-}
+import fs from "node:fs";
+import path from "node:path";
+import { writeUtf8FileSafely } from "./io-utils.js";
+import { loadVoicePackV2 } from "./profile.js";
+
+export function voicePromptPackV2({ voice, format = "agents", outPath }) {
+  const profile = typeof voice === "string" ? loadVoicePackV2(voice) : voice;
+  if (format !== "agents" && format !== "claude" && format !== "system") {
+    throw new Error(`Unsupported prompt format: ${format}`);
+  }
+  const rendered = renderPrompt(profile, format);
+  if (outPath) {
+    fs.mkdirSync(path.dirname(outPath), { recursive: true });
+    writeUtf8FileSafely(outPath, rendered);
+  }
+  return rendered;
+}
+
+function renderPrompt(profile, format) {
+  const header = {
+    agents: "# Dravoice V2 Writing Guidance",
+    claude: "# CLAUDE.md guidance for Dravoice V2",
+    system: "System writing guidance: Dravoice V2",
+  }[format];
+  const preface = {
+    agents: "Use this as local, inspectable drafting guidance from the writer's own corpus. It is not an AI detector or a license to imitate a third party.",
+    claude: "Use these project-local voice notes when drafting or reviewing prose for this repository. Treat them as guidance, not identity proof.",
+    system: "Follow these local voice constraints when writing prose. Do not expose private source text or claim authorship identity from them.",
+  }[format];
+  const lines = [
+    header,
+    "",
+    preface,
+    "",
+    "## Summary",
+    "",
+    ...profile.guidance.summary.map((item) => `- ${item}`),
+    "",
+    "## Feature Families",
+    "",
+  ];
+
+  for (const [name, family] of Object.entries(profile.families)) {
+    lines.push(`- ${name}: ${family.confidence} confidence; ${family.revisionHandles[0]}`);
+  }
+
+  lines.push("", "## Drafting Rules", "");
+  for (const rule of profile.guidance.draftingRules) {
+    lines.push(`- ${rule}`);
+  }
+
+  lines.push("", "## Avoid", "");
+  for (const item of profile.guidance.avoid) {
+    lines.push(`- ${item}`);
+  }
+
+  if (profile.guidance.examples.length) {
+    lines.push("", "## Source-Backed Examples", "");
+    for (const example of profile.guidance.examples) {
+      lines.push(`- ${example}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/src/v2/review.js

@@ -1,173 +1,303 @@
-import fs from "node:fs";
-import path from "node:path";
-import { parseDocument } from "./document-model.js";
-import { buildVoiceProfileV2, loadVoicePackV2 } from "./profile.js";
-import { familyDiagnosticsFor, styleDistanceFromDiagnostics } from "./stylometry.js";
-
-const REVIEW_MODES = {
-  loose: {
-    findingThresholds: null,
-    exitOnDrift: false,
-  },
-  balanced: {
-    findingThresholds: { evidence: 65, rhythm: 55, rhetoricalShape: 50 },
-    exitOnDrift: false,
-  },
-  strict: {
-    findingThresholds: { evidence: 75, rhythm: 70, rhetoricalShape: 65 },
-    exitOnDrift: true,
-  },
-};
-
-export function reviewVoiceDraftV2({ file, voice, cwd = process.cwd(), mode = "balanced" }) {
-  const reviewMode = normalizeReviewMode(mode);
-  const sourceProfile = typeof voice === "string" ? loadVoicePackV2(voice) : voice;
-  const filePath = path.resolve(file);
-  const draftDocument = parseDocument({
-    filePath,
-    rootDir: cwd,
-    contents: fs.readFileSync(filePath, "utf8"),
-  });
-  const draftProfile = buildVoiceProfileV2({ documents: [draftDocument] });
-
-  if (
-    draftDocument.wordCount < sourceProfile.calibration.minimumDraftSize.words ||
-    draftDocument.sentences.length < sourceProfile.calibration.minimumDraftSize.sentences
-  ) {
-    return {
-      schemaVersion: 2,
-      file: displayPath(filePath, cwd),
-      summary: {
-        mode: reviewMode,
-        fit: { band: "insufficient-evidence", distance: 0 },
-        familyScores: {},
-        corpusConfidence: sourceProfile.source.confidence,
-      },
-      findings: [],
-      exitCode: 0,
-    };
-  }
-
-  const familyDiagnostics = familyDiagnosticsFor(sourceProfile, draftProfile);
-  const familyScores = Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.score]));
-  const distance = styleDistanceFromDiagnostics(familyDiagnostics);
-  const findings = reviewFindings(sourceProfile, draftProfile, familyScores, reviewMode);
-  const fit = {
-    band: fitBand(distance, findings, familyDiagnostics),
-    distance,
-  };
-
-  return {
-    schemaVersion: 2,
-    file: displayPath(filePath, cwd),
-    summary: {
-      mode: reviewMode,
-      fit,
-      familyScores,
-      familyDistances: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.distance])),
-      familyDrift: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.drift])),
-      thresholds: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.threshold])),
-      corpusConfidence: sourceProfile.source.confidence,
-    },
-    findings,
-    exitCode: REVIEW_MODES[reviewMode].exitOnDrift && fit.band === "drift" ? 1 : 0,
-  };
-}
-
-export function renderVoiceReviewV2(result) {
-  const lines = [
-    "Voice rewrite notes, not AI detection.",
-    "",
-    result.file,
-    `Voice fit: ${capitalize(result.summary.fit.band)} (${result.summary.fit.distance} distance)`,
-    `Corpus confidence: ${capitalize(result.summary.corpusConfidence.band)} - ${result.summary.corpusConfidence.message}`,
-    "Family scores:",
-  ];
-
-  for (const [family, score] of Object.entries(result.summary.familyScores)) {
-    lines.push(`- ${family}: ${score}`);
-  }
-
-  lines.push("");
-  if (result.findings.length === 0) {
-    lines.push("No high-confidence V2 voice drift findings.");
-    lines.push("");
-    return lines.join("\n");
-  }
-
-  lines.push("Start here:");
-  for (const finding of result.findings.slice(0, 6)) {
-    lines.push(`${finding.priority} ${finding.family} ${finding.id}`);
-    lines.push(`Why flagged: ${finding.why}`);
-    lines.push(`Revise by: ${finding.action}`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-
-function reviewFindings(source, draft, scores, mode) {
-  const modeConfig = REVIEW_MODES[mode];
-  if (source.source?.confidence?.band === "weak" || !modeConfig.findingThresholds) {
-    return [];
-  }
-  const findings = [];
-  if (scores.evidence < modeConfig.findingThresholds.evidence) {
-    findings.push({
-      id: "v2.evidence-drift",
-      family: "evidence",
-      priority: "review",
-      why: `Source evidence sentence rate is ${source.families.evidence.features.evidenceSentenceRate}; draft rate is ${draft.families.evidence.features.evidenceSentenceRate}.`,
-      action: "Add concrete support before broad claims: a scene, quote, number, citation, URL, sensory detail, or specific example.",
-    });
-  }
-  if (scores.rhythm < modeConfig.findingThresholds.rhythm) {
-    findings.push({
-      id: "v2.rhythm-drift",
-      family: "rhythm",
-      priority: "consider",
-      why: `Source median sentence/paragraph length is ${source.families.rhythm.features.sentenceWords.median}/${source.families.rhythm.features.paragraphWords.median}; draft is ${draft.families.rhythm.features.sentenceWords.median}/${draft.families.rhythm.features.paragraphWords.median}.`,
-      action: "Revise sentence and paragraph pacing toward the learned range.",
-    });
-  }
-  if (scores.rhetoricalShape < modeConfig.findingThresholds.rhetoricalShape) {
-    findings.push({
-      id: "v2.shape-drift",
-      family: "rhetoricalShape",
-      priority: "consider",
-      why: `Source opening shape is ${source.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ")}; draft opening shape is ${draft.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ")}.`,
-      action: "Rework the opening so it uses a compatible scene, claim, contrast, reflection, or example sequence.",
-    });
-  }
-  return findings;
-}
-
-function normalizeReviewMode(mode) {
-  const normalized = String(mode ?? "balanced").toLowerCase();
-  if (!Object.hasOwn(REVIEW_MODES, normalized)) {
-    throw new Error(`Unsupported review mode: ${mode}. Expected loose, balanced, or strict.`);
-  }
-  return normalized;
-}
-
-function fitBand(distance, findings, familyDiagnostics) {
-  const maxDrift = Math.max(0, ...Object.values(familyDiagnostics).map((item) => item.drift));
-  if (findings.some((finding) => finding.priority === "review") || distance >= 35 || maxDrift >= 1.25) {
-    return "drift";
-  }
-  if (findings.length > 0 || distance >= 20 || maxDrift > 0) {
-    return "watch";
-  }
-  return "close";
-}
-
-function displayPath(filePath, cwd) {
-  const relative = path.relative(cwd, filePath);
-  if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
-    return relative.split(path.sep).join("/");
-  }
-  return filePath.split(path.sep).join("/");
-}
-
-function capitalize(value) {
-  return value.charAt(0).toUpperCase() + value.slice(1);
-}
+import path from "node:path";
+import { parseDocument } from "./document-model.js";
+import { readUtf8FileBounded } from "./io-utils.js";
+import { buildVoiceProfileV2, loadVoicePackV2 } from "./profile.js";
+import { familyDiagnosticsFor, styleDistanceFromDiagnostics } from "./stylometry.js";
+
+const REVIEW_MODES = {
+  loose: {
+    findingThresholds: null,
+    exitOnDrift: false,
+  },
+  balanced: {
+    findingThresholds: { evidence: 65, rhythm: 55, rhetoricalShape: 50, discourse: 55, lexical: 55, register: 55, structure: 55 },
+    exitOnDrift: false,
+  },
+  strict: {
+    findingThresholds: { evidence: 75, rhythm: 70, rhetoricalShape: 65, discourse: 65, lexical: 65, register: 70, structure: 91 },
+    exitOnDrift: true,
+  },
+};
+
+export function reviewVoiceDraftV2({ file, voice, cwd = process.cwd(), mode = "balanced" }) {
+  const reviewMode = normalizeReviewMode(mode);
+  const sourceProfile = typeof voice === "string" ? loadVoicePackV2(voice) : voice;
+  const filePath = resolvePath(cwd, file);
+  const draftDocument = parseDocument({
+    filePath,
+    rootDir: cwd,
+    contents: readUtf8FileBounded(filePath, { label: "Draft file", maxBytes: 2 * 1024 * 1024 }),
+  });
+  const draftProfile = buildVoiceProfileV2({ documents: [draftDocument] });
+
+  if (
+    draftDocument.wordCount < sourceProfile.calibration.minimumDraftSize.words ||
+    draftDocument.sentences.length < sourceProfile.calibration.minimumDraftSize.sentences
+  ) {
+    const familyConfidence = familyConfidenceFor(sourceProfile, {});
+    return {
+      schemaVersion: 2,
+      file: displayPath(filePath, cwd),
+      summary: {
+        mode: reviewMode,
+        fit: { band: "insufficient-evidence", distance: 0 },
+        familyScores: {},
+        familyConfidence,
+        suppressedFindings: suppressedFindingsFor(sourceProfile, familyConfidence),
+        corpusConfidence: sourceProfile.source.confidence,
+      },
+      findings: [],
+      exitCode: 0,
+    };
+  }
+
+  const familyDiagnostics = familyDiagnosticsFor(sourceProfile, draftProfile);
+  const familyScores = Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.score]));
+  const distance = styleDistanceFromDiagnostics(familyDiagnostics);
+  const familyConfidence = familyConfidenceFor(sourceProfile, familyDiagnostics);
+  const findings = reviewFindings(sourceProfile, draftProfile, familyScores, reviewMode, familyConfidence);
+  const fit = {
+    band: fitBand(distance, findings, familyDiagnostics),
+    distance,
+  };
+
+  return {
+    schemaVersion: 2,
+    file: displayPath(filePath, cwd),
+    summary: {
+      mode: reviewMode,
+      fit,
+      familyScores,
+      familyConfidence,
+      suppressedFindings: suppressedFindingsFor(sourceProfile, familyConfidence),
+      familyDistances: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.distance])),
+      familyDrift: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.drift])),
+      thresholds: Object.fromEntries(Object.entries(familyDiagnostics).map(([family, item]) => [family, item.threshold])),
+      corpusConfidence: sourceProfile.source.confidence,
+    },
+    findings,
+    exitCode: REVIEW_MODES[reviewMode].exitOnDrift && fit.band === "drift" ? 1 : 0,
+  };
+}
+
+export function renderVoiceReviewV2(result) {
+  const lines = [
+    "Voice review notes, not AI detection.",
+    "",
+    result.file,
+    `Fit: ${capitalize(result.summary.fit.band)} (${result.summary.fit.distance} style distance)`,
+    `Corpus confidence: ${capitalize(result.summary.corpusConfidence.band)} - ${result.summary.corpusConfidence.message}`,
+    "Family scores:",
+  ];
+
+  for (const [family, score] of Object.entries(result.summary.familyScores)) {
+    lines.push(`- ${familyLabel(family)}: ${score}`);
+  }
+
+  lines.push("");
+  if (result.findings.length === 0) {
+    lines.push("No high-confidence voice drift findings.");
+    appendSuppressedFindings(lines, result.summary.suppressedFindings);
+    lines.push("");
+    return lines.join("\n");
+  }
+
+  lines.push("Start here:");
+  result.findings.slice(0, 6).forEach((finding, index) => {
+    lines.push(`${index + 1}. ${priorityLabel(finding.priority)} ${familyLabel(finding.family)}`);
+    if (finding.confidence) {
+      lines.push(`Confidence: ${capitalize(finding.confidence.band)}; stability ${finding.confidence.stability}`);
+    }
+    lines.push(`Why: ${finding.why}`);
+    lines.push(`Do this: ${finding.action}`);
+    lines.push("");
+  });
+  appendSuppressedFindings(lines, result.summary.suppressedFindings);
+  return lines.join("\n");
+}
+
+function reviewFindings(source, draft, scores, mode, familyConfidence) {
+  const modeConfig = REVIEW_MODES[mode];
+  if (source.source?.confidence?.band === "weak" || !modeConfig.findingThresholds) {
+    return [];
+  }
+  const findings = [];
+  if (shouldFlag("evidence", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.evidence-drift",
+      family: "evidence",
+      priority: "review",
+      confidence: familyConfidence.evidence,
+      why: `Source evidence sentence rate is ${source.families.evidence.features.evidenceSentenceRate}; draft rate is ${draft.families.evidence.features.evidenceSentenceRate}.`,
+      action: "Add concrete support before broad claims: a scene, quote, number, citation, URL, sensory detail, or specific example.",
+    });
+  }
+  if (shouldFlag("rhythm", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.rhythm-drift",
+      family: "rhythm",
+      priority: "consider",
+      confidence: familyConfidence.rhythm,
+      why: `Source median sentence/paragraph length is ${source.families.rhythm.features.sentenceWords.median}/${source.families.rhythm.features.paragraphWords.median}; draft is ${draft.families.rhythm.features.sentenceWords.median}/${draft.families.rhythm.features.paragraphWords.median}.`,
+      action: "Revise sentence and paragraph pacing toward the learned range.",
+    });
+  }
+  if (shouldFlag("rhetoricalShape", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.shape-drift",
+      family: "rhetoricalShape",
+      priority: "consider",
+      confidence: familyConfidence.rhetoricalShape,
+      why: `Source opening shape is ${source.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ")}; draft opening shape is ${draft.families.rhetoricalShape.features.openingMoves.slice(0, 3).join(" -> ")}.`,
+      action: "Rework the opening so it uses a compatible scene, claim, contrast, reflection, or example sequence.",
+    });
+  }
+  if (shouldFlag("discourse", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.discourse-drift",
+      family: "discourse",
+      priority: "consider",
+      confidence: familyConfidence.discourse,
+      why: `Source transition rates are ${rateMapLabel(source.families.discourse.features.transitionRates)}; draft rates are ${rateMapLabel(draft.families.discourse.features.transitionRates)}.`,
+      action: "Revise repeated sentence turns, callbacks, and transitions so the draft does not lean on a different discourse pattern.",
+    });
+  }
+  if (shouldFlag("lexical", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.lexical-drift",
+      family: "lexical",
+      priority: "consider",
+      confidence: familyConfidence.lexical,
+      why: `Function-word, masked character, punctuation, or boundary-token habits drift from the calibrated source profile.`,
+      action: "Revise diction and punctuation where it improves the article; do not stuff source topic words or add artificial imperfections.",
+    });
+  }
+  if (shouldFlag("register", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.register-drift",
+      family: "register",
+      priority: "consider",
+      confidence: familyConfidence.register,
+      why: `Source primary register is ${source.families.register.features.primary.value}; draft primary register is ${draft.families.register.features.primary.value}.`,
+      action: "Bring the stance closer to the learned genre mix while preserving the draft's real subject and audience.",
+    });
+  }
+  if (shouldFlag("structure", scores, modeConfig, familyConfidence)) {
+    findings.push({
+      id: "v2.structure-drift",
+      family: "structure",
+      priority: "consider",
+      confidence: familyConfidence.structure,
+      why: `Source heading/list/quote and section-size patterns differ from the draft's document structure.`,
+      action: "Adjust section shape, opening order, list use, or quote placement only where the article benefits from that structure.",
+    });
+  }
+  return findings;
+}
+
+function shouldFlag(family, scores, modeConfig, familyConfidence) {
+  return familyConfidence[family]?.usableForFindings &&
+    Number.isFinite(scores[family]) &&
+    scores[family] < modeConfig.findingThresholds[family];
+}
+
+function familyConfidenceFor(sourceProfile, familyDiagnostics) {
+  const profileDiagnostics = sourceProfile.calibration?.familyDiagnostics ?? {};
+  return Object.fromEntries(Object.keys(sourceProfile.families ?? {}).map((family) => {
+    const profile = profileDiagnostics[family] ?? {};
+    const runtime = familyDiagnostics[family] ?? {};
+    return [family, {
+      band: sourceProfile.families[family]?.confidence ?? "low",
+      stability: runtime.stability ?? profile.stability ?? 0.45,
+      observations: profile.observations ?? runtime.observations ?? 0,
+      usableForFindings: profile.usableForFindings ?? sourceProfile.source?.confidence?.band !== "weak",
+      minimumEvidence: profile.minimumEvidence ?? null,
+    }];
+  }));
+}
+
+function suppressedFindingsFor(sourceProfile, familyConfidence) {
+  return Object.entries(familyConfidence)
+    .filter(([, confidence]) => !confidence.usableForFindings)
+    .map(([family, confidence]) => ({
+      family,
+      reason: suppressedReasonFor(sourceProfile, confidence),
+    }));
+}
+
+function suppressedReasonFor(sourceProfile, confidence) {
+  if (sourceProfile.source?.confidence?.band === "weak") {
+    return "weak corpus confidence; add more representative source documents before trusting this family.";
+  }
+  const minimum = confidence.minimumEvidence;
+  if (minimum && (!minimum.documentsMet || !minimum.sentencesMet || !minimum.wordsMet)) {
+    return `minimum evidence not met; requires ${minimum.requiredDocuments} document(s), ${minimum.requiredSentences} sentence(s), and ${minimum.requiredWords} word(s).`;
+  }
+  return "calibration stability is too low for a high-confidence finding.";
+}
+
+function appendSuppressedFindings(lines, suppressedFindings = []) {
+  if (!suppressedFindings.length) {
+    return;
+  }
+  lines.push("");
+  lines.push("Suppressed findings:");
+  suppressedFindings.slice(0, 6).forEach((item) => {
+    lines.push(`- ${familyLabel(item.family)}: ${item.reason}`);
+  });
+}
+
+function rateMapLabel(value = {}) {
+  return Object.entries(value).map(([key, rate]) => `${key}:${rate}`).join(", ") || "none";
+}
+
+function normalizeReviewMode(mode) {
+  const normalized = String(mode ?? "balanced").toLowerCase();
+  if (!Object.hasOwn(REVIEW_MODES, normalized)) {
+    throw new Error(`Unsupported review mode: ${mode}. Expected loose, balanced, or strict.`);
+  }
+  return normalized;
+}
+
+function fitBand(distance, findings, familyDiagnostics) {
+  const maxDrift = Math.max(0, ...Object.values(familyDiagnostics).map((item) => item.drift));
+  if (findings.some((finding) => finding.priority === "review") || distance >= 35 || maxDrift >= 1.25) {
+    return "drift";
+  }
+  if (findings.length > 0 || distance >= 20 || maxDrift > 0) {
+    return "watch";
+  }
+  return "close";
+}
+
+function displayPath(filePath, cwd) {
+  const relative = path.relative(cwd, filePath);
+  if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) {
+    return relative.split(path.sep).join("/");
+  }
+  return filePath.split(path.sep).join("/");
+}
+
+function resolvePath(cwd, value) {
+  return path.isAbsolute(value) ? value : path.resolve(cwd, value);
+}
+
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+function familyLabel(family) {
+  return {
+    evidence: "Evidence",
+    rhythm: "Rhythm",
+    rhetoricalShape: "Rhetorical shape",
+    discourse: "Discourse",
+    lexical: "Lexical style",
+    register: "Register",
+    structure: "Structure",
+  }[family] ?? capitalize(family);
+}
+
+function priorityLabel(priority) {
+  return priority === "review" ? "Review" : "Consider";
+}