chaffjs 0.24.0 → 0.26.0

package/src/detectors/vague-deadline.ts

@@ -0,0 +1,132 @@
+// A time limit a contract leaves to the reader (速やかに, 遅滞なく, promptly, within a reasonable time) where the same
+// contract writes most of its limits as numbers (7日以内, within thirty days): who decides whether 速やかに was met?
+// Which way to write limits is the drafter's choice; only the minority in one document is pointed at. A sentence that
+// also gives a number of days (速やかに、遅くとも7日以内に) has a deadline, and a sentence that grants a right (may
+// promptly suspend, 速やかに解除することができる) sets no deadline. The words come from the language package's word
+// lists: vague-deadline, concrete-deadline (a stated limit: 日以内, "within … days") and deadline-permission. Pure.
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type VagueDeadline = { readonly offset: number; readonly word: string };
+
+type Text = { readonly start: number; readonly text: string };
+
+type Hit = { readonly at: number; readonly word: string };
+
+/** What the three word lists give the decision. */
+export type DeadlineWords = {
+  readonly vague: readonly string[];
+  /** A phrase, or a frame "within … days": the second part within FRAME_REACH characters after the first. */
+  readonly concrete: readonly string[];
+  /** A right, not a duty: a word anywhere in the sentence, or (position: after) the sentence's ending. */
+  readonly permissions: readonly LexiconEntry[];
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const FRAME = "…";
+/** How far after "within" the unit of a frame may come: "within fourteen (14) business days". */
+const FRAME_REACH = 30;
+const SENTENCE_MARKS = new Set(["。", "．", ".", "!", "?", "！", "？"]);
+
+/** The sentence without its closing marks and spaces. */
+const withoutEnding = (text: string): string => {
+  const chars = [...text.trimEnd()];
+  const last = chars.findLastIndex((char) => !SENTENCE_MARKS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+/** An English word is not read inside a longer one (promptly in unpromptly, may in mayor). */
+const isWordAt = (text: string, word: string, at: number): boolean =>
+  !LATIN.test(word) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length)));
+
+const indexesOf = (text: string, word: string): number[] => {
+  const found: number[] = [];
+  if (word === "") return found;
+  let at = text.indexOf(word);
+  while (at !== -1) {
+    found.push(at);
+    at = text.indexOf(word, at + word.length);
+  }
+  return found;
+};
+
+const wordIn = (lower: string, word: string): boolean => indexesOf(lower, word.toLowerCase()).some((at) => isWordAt(lower, word, at));
+
+/** A phrase, or a frame whose second part follows its first within reach. */
+const concreteIn = (lower: string, entry: string): boolean => {
+  const [lead = "", tail, ...rest] = entry
+    .toLowerCase()
+    .split(FRAME)
+    .map((part) => part.trim());
+  if (rest.length > 0) return false;
+  if (tail === undefined) return lead !== "" && lower.includes(lead);
+  return (
+    lead !== "" &&
+    tail !== "" &&
+    indexesOf(lower, lead).some((at) => isWordAt(lower, lead, at) && lower.slice(at + lead.length, at + lead.length + FRAME_REACH).includes(tail))
+  );
+};
+
+const statesConcrete = (text: Text, concrete: readonly string[]): boolean => {
+  const lower = text.text.toLowerCase();
+  return concrete.some((entry) => concreteIn(lower, entry));
+};
+
+const grantsRight = (text: Text, permissions: readonly LexiconEntry[]): boolean => {
+  const lower = text.text.toLowerCase();
+  const ending = withoutEnding(lower);
+  return permissions
+    .filter((entry) => entry.pattern !== "")
+    .some((entry) => (entry.position === "after" ? ending.endsWith(entry.pattern.toLowerCase()) : wordIn(lower, entry.pattern)));
+};
+
+/** A hit inside a longer hit at the same place (速やかに in 可及的速やかに) is that longer word. */
+const isInsideLonger = (hit: Hit, hits: readonly Hit[]): boolean =>
+  hits.some((other) => other.word.length > hit.word.length && other.at <= hit.at && hit.at + hit.word.length <= other.at + other.word.length);
+
+/** The vague limits in one sentence, in order. Matching ignores case. */
+const vagueIn = (text: Text, vague: readonly string[]): VagueDeadline[] => {
+  const lower = text.text.toLowerCase();
+  const hits = vague
+    .filter((word) => word !== "")
+    .flatMap((word) =>
+      indexesOf(lower, word.toLowerCase())
+        .filter((at) => isWordAt(lower, word, at))
+        .map((at) => ({ at, word })),
+    );
+  return hits
+    .filter((hit) => !isInsideLonger(hit, hits))
+    .toSorted((left, right) => left.at - right.at)
+    .map((hit) => ({ offset: text.start + hit.at, word: text.text.slice(hit.at, hit.at + hit.word.length) }));
+};
+
+/**
+ * Each vague limit in a sentence that states no concrete one and grants no right, when more sentences of the document
+ * state a concrete one than hold such a vague one: the vague limits are then the document's minority.
+ */
+export const vagueDeadlines = (texts: readonly Text[], words: DeadlineWords): VagueDeadline[] => {
+  const perSentence = texts.map((text) => (statesConcrete(text, words.concrete) || grantsRight(text, words.permissions) ? [] : vagueIn(text, words.vague)));
+  const vagueSentences = perSentence.filter((hits) => hits.length > 0).length;
+  const concreteSentences = texts.filter((text) => statesConcrete(text, words.concrete)).length;
+  return concreteSentences > vagueSentences ? perSentence.flat() : [];
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+export const vagueDeadline: Detector = (doc): Finding[] =>
+  vagueDeadlines(
+    doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
+    {
+      vague: patternsOf(doc, "vague-deadline"),
+      concrete: patternsOf(doc, "concrete-deadline"),
+      permissions: doc.lexicons["deadline-permission"] ?? [],
+    },
+  ).map((hit) => ({
+    rule: "vague-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, hit.offset),
+    values: { word: hit.word, offset: hit.offset },
+  }));

package/src/furigana.ts

@@ -0,0 +1,20 @@
+import type { Span } from "./plugin.ts";
+
+/** ひらがなと、読みの中に書く長音・中黒・空白だけの括弧書き。 */
+const KANA_ASIDE = /[（(][\p{Script=Hiragana}ー・ \u3000]+[）)]/gu;
+
+const HIRAGANA = /\p{Script=Hiragana}/u;
+/** 読みを付ける語の終わりの字。ひらがなの後ろの括弧書きは読みではなく挟んだ言葉（「これは（たぶん）」）。 */
+const WORD_END = /[\p{L}\p{N}]/u;
+
+/**
+ * text の中の、語の直後のふりがなの括弧（「HTTP（えいちてぃーてぃーぴー）」「脆弱性（ぜいじゃくせい）」）の範囲。括弧を含む。
+ * 語の読みであって、語の書き方ではない。位置は text の先頭を 0 とする。
+ */
+export const furiganaSpans = (text: string): Span[] =>
+  [...text.matchAll(KANA_ASIDE)]
+    .filter((match) => {
+      const before = text.charAt(match.index - 1);
+      return HIRAGANA.test(match[0]) && WORD_END.test(before) && !HIRAGANA.test(before);
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/genre-load.ts

@@ -1,13 +1,11 @@
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
 import { parseGenres, presetLevelsOf, presetProfileOf, withRuleOffs, type GenreData, type PresetLevels } from "./genre-parse.ts";
 import { loadRuleOffs } from "./rule-offs.ts";
+import { PACKAGE_DIR, readText } from "./package-files.ts";
 
-const PACKAGE = join(dirname(fileURLToPath(import.meta.url)), "..");
-const GENRES_FILE = join(PACKAGE, "genres.yaml");
-const RULES_DIR = join(PACKAGE, "rules");
+const GENRES_FILE = join(PACKAGE_DIR, "genres.yaml");
+const RULES_DIR = join(PACKAGE_DIR, "rules");
 
 const loaded: { value: GenreData | undefined } = { value: undefined };
 
@@ -15,7 +13,7 @@ const loaded: { value: GenreData | undefined } = { value: undefined };
 export const loadGenres = (): GenreData => {
   if (loaded.value !== undefined) return loaded.value;
   try {
-    loaded.value = withRuleOffs(parseGenres(parse(readFileSync(GENRES_FILE, "utf8"))), loadRuleOffs(RULES_DIR));
+    loaded.value = withRuleOffs(parseGenres(parse(readText(GENRES_FILE))), loadRuleOffs(RULES_DIR));
   } catch (error) {
     throw new Error(`cannot read ${GENRES_FILE}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }

package/src/grade/ai-score.ts

@@ -0,0 +1,32 @@
+import { shownSignsOf, type AiLevel, type AiScore, type NotScored } from "../ai-score/score.ts";
+
+// The AI-likeness quick score as one output's result carries it, and its levels counted over many outputs. Pure.
+
+/** One output's quick score: its level (null when not scored, and why), the signs, and which showed. */
+export type GradeAiScore = {
+  readonly level: AiLevel | null;
+  readonly notScored: NotScored["reason"] | null;
+  readonly signs: number;
+  readonly compared: number;
+  /** The signs that counted: rule ids, and structure measures as structure:<id>. */
+  readonly shown: readonly string[];
+};
+
+/** How many outputs reached each level, and how many were not scored. */
+export type AiLevelCounts = Readonly<Record<AiLevel | "notScored", number>>;
+
+export const gradeAiScoreOf = (score: AiScore): GradeAiScore => ({
+  level: score.level ?? null,
+  notScored: score.notScored?.reason ?? null,
+  signs: score.signs,
+  compared: score.compared,
+  shown: shownSignsOf(score),
+});
+
+/** The levels of the outputs that carry a score, or undefined when none does (results written before the score existed). */
+export const aiLevelCountsOf = (scores: readonly (GradeAiScore | undefined)[]): AiLevelCounts | undefined => {
+  const scored = scores.filter((score) => score !== undefined);
+  if (scored.length === 0) return undefined;
+  const count = (level: AiLevel): number => scored.filter((score) => score.level === level).length;
+  return { low: count("low"), medium: count("medium"), high: count("high"), notScored: scored.filter((score) => score.level === null).length };
+};

package/src/grade/finding.ts

@@ -0,0 +1,16 @@
+import type { SourceCheck } from "../check-source.ts";
+import type { Finding } from "../plugin.ts";
+import { messageOf } from "../render/text.ts";
+import type { GradeFinding } from "./result.ts";
+
+/** One finding as `chaff grade` writes it: the rule, the level, where, and the message the command line prints. */
+export const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
+  const rule = check.rules.find((entry) => entry.id === finding.rule);
+  return {
+    rule: finding.rule,
+    level: finding.severity,
+    line: finding.line,
+    column: finding.column,
+    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
+  };
+};

package/src/grade/grade-item.ts

@@ -1,9 +1,8 @@
 import { checkSource, type SourceCheck } from "../check-source.ts";
 import type { Allowed } from "../compare/outcome.ts";
 import { missingSections } from "../detectors/team.ts";
-import { messageOf } from "../render/text.ts";
 import { uiLanguageOf, type UiLanguage } from "../ui.ts";
-import type { Finding } from "../plugin.ts";
+import { findingOf } from "./finding.ts";
 import { citationsAgainst, factsAgainst, OUTPUT_PATH, type CitationsRead, type ItemReading } from "./checks.ts";
 import { contextsAgainst, type ContextsRead } from "./contexts.ts";
 import type { GradeItem } from "./item.ts";
@@ -13,22 +12,13 @@ import type { Rubric } from "./rubric.ts";
 import { rubricVerdict } from "./rubric-verdict.ts";
 import type { GradeSettings } from "./stamp.ts";
 import { GRADE_TEXT } from "./text.ts";
+import { aiScoreOfDocument } from "../ai-score/of-document.ts";
+import { gradeAiScoreOf } from "./ai-score.ts";
 import { defaultVerdict, type Verdict } from "./verdict.ts";
 
 /** One run's settings, its `grade:` rubric when chaff.yaml has one, and its stamp, which every result carries. */
 export type GradeSetup = GradeSettings & { readonly stamp: Stamp; readonly rubric?: Rubric | undefined };
 
-const findingOf = (finding: Finding, check: SourceCheck): GradeFinding => {
-  const rule = check.rules.find((entry) => entry.id === finding.rule);
-  return {
-    rule: finding.rule,
-    level: finding.severity,
-    line: finding.line,
-    column: finding.column,
-    message: rule === undefined ? finding.rule : messageOf(rule, finding, check.language),
-  };
-};
-
 /** The fact kinds the rubric lets change (`allow_dropped`, `allow_added`), as compare's --allow-dropped and --allow-added. */
 const allowedBy = (rubric: Rubric | undefined): Allowed => ({
   dropped: new Set(rubric?.facts?.allowDropped ?? []),
@@ -126,6 +116,7 @@ export const gradeItem = async (item: GradeItem, setup: GradeSetup): Promise<Gra
     citations: citationsOf(checked),
     ...(checked.contexts === undefined ? {} : { contexts: checked.contexts.contexts }),
     ...(score === undefined ? {} : { score }),
+    aiScore: gradeAiScoreOf(aiScoreOfDocument(checked.check.doc, checked.check.rules, checked.check.genre.genre)),
     pass: verdict.pass,
     failedBecause: verdict.failedBecause,
     stamp: setup.stamp,

package/src/grade/render-variants.ts

@@ -14,11 +14,15 @@ type Rows = readonly (readonly string[])[];
 const passedCell = (column: VariantColumn, text: VariantText): string =>
   text.passedCell(column.passed, column.outputs, column.passRate === undefined ? "–" : `${String(column.passRate)}%`);
 
+const aiScoreCellOf = (column: VariantColumn, text: VariantText): string =>
+  column.aiScore === undefined ? "–" : text.aiScoreCell(column.aiScore.low, column.aiScore.medium, column.aiScore.high, column.aiScore.notScored);
+
 /** The header and one row per measure, a column per variant. */
 const measureRows = (comparison: VariantComparison, text: VariantText): Rows => {
   const { columns } = comparison;
   const scored = columns.some((column) => column.penalty !== undefined);
   const grounded = columns.some((column) => column.contexts !== undefined);
+  const aiScored = columns.some((column) => column.aiScore !== undefined);
   return [
     ["", ...comparison.variants],
     [text.passed, ...columns.map((column) => passedCell(column, text))],
@@ -29,6 +33,7 @@ const measureRows = (comparison: VariantComparison, text: VariantText): Rows =>
       ? [[text.unsupportedFacts, ...columns.map((column) => text.citationsCell(column.contexts?.unsupported ?? 0, column.contexts?.checked ?? 0))]]
       : []),
     ...(scored ? [[text.penalty, ...columns.map((column) => String(column.penalty ?? 0))]] : []),
+    ...(aiScored ? [[text.aiScore, ...columns.map((column) => aiScoreCellOf(column, text))]] : []),
   ];
 };
 

package/src/grade/render.ts

@@ -65,6 +65,7 @@ export const renderSummary = (path: string, summary: GradeSummary, text: GradeTe
     text.citations(summary.citations.checked, summary.citations.failed),
     ...contextsLine(summary, text),
     ...(summary.penalty === undefined ? [] : [text.penalty(summary.penalty)]),
+    ...(summary.aiScore === undefined ? [] : [text.aiScore(summary.aiScore.low, summary.aiScore.medium, summary.aiScore.high, summary.aiScore.notScored)]),
     ...block(text.notRunHeading(summary.notRun.length), table(summary.notRun.map((entry) => [entry.rule, text.inOutputs(entry.outputs), entry.reason]))),
     ...stampLines(summary, text),
   ].join("\n");

package/src/grade/result.ts

@@ -2,6 +2,7 @@ import type { AtomKind } from "../compare/atom.ts";
 import type { CitationStatus } from "../structure/cite.ts";
 import type { Severity } from "../plugin.ts";
 import type { OutputSize } from "./rates.ts";
+import type { GradeAiScore } from "./ai-score.ts";
 
 // The shape of one line of `chaff grade --out`, and of what `grade()` returns. Spec §29.3.
 
@@ -75,6 +76,8 @@ export type GradeResult = {
   readonly contexts?: GradeContexts | undefined;
   /** Only with a `grade:` rubric. */
   readonly score?: GradeScore | undefined;
+  /** The AI-likeness quick score. Absent only in results written before it existed. Never part of pass or fail. */
+  readonly aiScore?: GradeAiScore | undefined;
   readonly pass: boolean;
   /** Each condition the output failed, with how far: `facts.dropped 3 > 0`. */
   readonly failedBecause: readonly string[];

package/src/grade/results-read.ts

@@ -52,6 +52,19 @@ const isScoreItem = (value: unknown): boolean => isRecord(value) && isNumber(val
 
 const isScore = (value: unknown): boolean => value === undefined || (isRecord(value) && isNumber(value["penalty"]) && isArrayOf(value["items"], isScoreItem));
 
+const AI_LEVELS: ReadonlySet<unknown> = new Set(["low", "medium", "high", null]);
+const NOT_SCORED: ReadonlySet<unknown> = new Set(["too-short", "no-baseline", null]);
+
+/** Absent in results written before the quick score existed. */
+const isAiScore = (value: unknown): boolean =>
+  value === undefined ||
+  (isRecord(value) &&
+    AI_LEVELS.has(value["level"]) &&
+    NOT_SCORED.has(value["notScored"]) &&
+    isNumber(value["signs"]) &&
+    isNumber(value["compared"]) &&
+    isArrayOf(value["shown"], isString));
+
 const isNotRun = (value: unknown): boolean => isRecord(value) && isString(value["rule"]) && isString(value["reason"]);
 
 const isRates = (value: unknown): boolean => isRecord(value) && Object.values(value).every(isNumber);
@@ -59,6 +72,9 @@ const isRates = (value: unknown): boolean => isRecord(value) && Object.values(va
 /** The id, and the variant when the output had one. */
 const isLabel = (value: Record<string, unknown>): boolean => isString(value["id"]) && (value["variant"] === undefined || isString(value["variant"]));
 
+/** The parts a result carries only sometimes: contexts, a rubric's score, the quick score. Each is checked when present. */
+const hasOptionalParts = (value: Record<string, unknown>): boolean => isContexts(value["contexts"]) && isScore(value["score"]) && isAiScore(value["aiScore"]);
+
 /** A line `--out` writes, every field checked: a line that only looks like one would be compared as if it had been graded. */
 export const isGradeResult = (value: unknown): value is GradeResult =>
   isRecord(value) &&
@@ -71,8 +87,7 @@ export const isGradeResult = (value: unknown): value is GradeResult =>
   isArrayOf(value["notRun"], isNotRun) &&
   isFacts(value["facts"]) &&
   isCitations(value["citations"]) &&
-  isContexts(value["contexts"]) &&
-  isScore(value["score"]) &&
+  hasOptionalParts(value) &&
   typeof value["pass"] === "boolean" &&
   isArrayOf(value["failedBecause"], isString) &&
   isStamp(value["stamp"]);

package/src/grade/summary.ts

@@ -2,6 +2,7 @@ import type { LengthUnit } from "../plugin.ts";
 import { compareText, sortedByKey, tally } from "./order.ts";
 import { rateOf } from "./rates.ts";
 import type { GradeFact, GradeResult, NotRunEntry, Stamp } from "./result.ts";
+import { aiLevelCountsOf, type AiLevelCounts } from "./ai-score.ts";
 
 // The summary of a run (spec §29.3), from the per-output results alone, so the same results always sum the same way.
 
@@ -23,6 +24,8 @@ export type GradeSummary = {
   readonly notRun: readonly (NotRunEntry & { readonly outputs: number })[];
   /** The penalty points of every output, added up. Only with a `grade:` rubric. */
   readonly penalty?: number | undefined;
+  /** How many outputs reached each level of the AI-likeness quick score. Absent when no result carries one. */
+  readonly aiScore?: AiLevelCounts | undefined;
   readonly stamp: Stamp | undefined;
 };
 
@@ -86,6 +89,11 @@ const contextsOf = (results: readonly GradeResult[]): Pick<GradeSummary, "contex
   };
 };
 
+const aiScoreOf = (results: readonly GradeResult[]): Pick<GradeSummary, "aiScore"> => {
+  const counts = aiLevelCountsOf(results.map((result) => result.aiScore));
+  return counts === undefined ? {} : { aiScore: counts };
+};
+
 export const summaryOf = (results: readonly GradeResult[]): GradeSummary => {
   const sizes = sizesOf(results);
   return {
@@ -107,6 +115,7 @@ export const summaryOf = (results: readonly GradeResult[]): GradeSummary => {
     ...contextsOf(results),
     notRun: notRunOf(results),
     ...penaltyOf(results),
+    ...aiScoreOf(results),
     stamp: results[0]?.stamp,
   };
 };

package/src/grade/text.ts

@@ -13,6 +13,8 @@ export type GradeText = {
   readonly unknownRule: string;
   readonly rubricProblem: (problem: RubricProblem) => string;
   readonly penalty: (total: number) => string;
+  /** The outputs at each level of the AI-likeness quick score. */
+  readonly aiScore: (low: number, medium: number, high: number, notScored: number) => string;
   readonly noStructure: (source: string, language: string) => string;
   readonly unreadable: (path: string, why: string) => string;
   readonly problem: (problem: ItemProblem) => string;
@@ -110,6 +112,8 @@ export const GRADE_TEXT: Texts<GradeText> = {
     unknownRule: "grade: に書かれているが、chaff の知らないルール",
     rubricProblem: (problem) => `chaff.yaml の ${problem.path} は${EXPECTED_JA[problem.expected]}で書いてください（書かれていたのは ${problem.written}）`,
     penalty: (total) => `減点の和: ${String(total)}`,
+    aiScore: (low, medium, high, notScored) =>
+      `AI らしさ: 低 ${String(low)}、中 ${String(medium)}、高 ${String(high)}、測っていない ${String(notScored)}（書いたのが AI かどうかの判定ではありません。合否には入りません）`,
     noStructure: (source, language) => `原文 ${source} の言語 ${language} のパッケージは文書の構造を読めない`,
     unreadable: (path, why) => `${path} を読めませんでした: ${why}`,
     problem: (problem) => PROBLEM_JA[problem.kind](problem),
@@ -142,6 +146,8 @@ export const GRADE_TEXT: Texts<GradeText> = {
     unknownRule: "named under grade: but not a rule chaff knows",
     rubricProblem: (problem) => `chaff.yaml: ${problem.path} must be ${EXPECTED_EN[problem.expected]} (found ${problem.written})`,
     penalty: (total) => `Penalty points: ${String(total)}`,
+    aiScore: (low, medium, high, notScored) =>
+      `AI-likeness: low ${String(low)}, medium ${String(medium)}, high ${String(high)}, not scored ${String(notScored)} (not a verdict on whether AI wrote them; not part of pass or fail)`,
     noStructure: (source, language) => `the ${language} package cannot read the structure of source ${source}`,
     unreadable: (path, why) => `Could not read ${path}: ${why}`,
     problem: (problem) => PROBLEM_EN[problem.kind](problem),

package/src/grade/variants-text.ts

@@ -10,6 +10,9 @@ export type VariantText = {
   readonly citationsCell: (failed: number, checked: number) => string;
   readonly unsupportedFacts: string;
   readonly penalty: string;
+  /** The row of the AI-likeness quick score, and its cell: outputs at low / medium / high, then (not scored). */
+  readonly aiScore: string;
+  readonly aiScoreCell: (low: number, medium: number, high: number, notScored: number) => string;
   readonly ratesHeading: (unit: string) => string;
   readonly unit: Readonly<Record<"char" | "word", string>>;
   readonly disagreeHeading: (count: number) => string;
@@ -40,6 +43,8 @@ export const VARIANT_TEXT: Texts<VariantText> = {
     citationsCell: (failed, checked) => `${String(failed)}/${String(checked)}`,
     unsupportedFacts: "一節に無い事実",
     penalty: "減点の和",
+    aiScore: "AI らしさ 低/中/高",
+    aiScoreCell: (low, medium, high, notScored) => `${String(low)}/${String(medium)}/${String(high)}（${String(notScored)}）`,
     ratesHeading: (unit) => `ルールごとの率（1,000 ${unit}あたり）`,
     unit: { char: "字", word: "語" },
     disagreeHeading: (count) => `合否が分かれた出力 ${String(count)} 件`,
@@ -68,6 +73,8 @@ export const VARIANT_TEXT: Texts<VariantText> = {
     citationsCell: (failed, checked) => `${String(failed)}/${String(checked)}`,
     unsupportedFacts: "Unsupported facts",
     penalty: "Penalty points",
+    aiScore: "AI low/med/high",
+    aiScoreCell: (low, medium, high, notScored) => `${String(low)}/${String(medium)}/${String(high)} (${String(notScored)})`,
     ratesHeading: (unit) => `Rule rates (per 1,000 ${unit})`,
     unit: { char: "characters", word: "words" },
     disagreeHeading: (count) => `${String(count)} ${count === 1 ? "output" : "outputs"} where pass or fail differs`,

package/src/grade/variants.ts

@@ -1,6 +1,7 @@
 import type { LengthUnit } from "../plugin.ts";
 import { rateRows, sameReading } from "./pairing.ts";
 import type { GradeResult } from "./result.ts";
+import type { AiLevelCounts } from "./ai-score.ts";
 import { summaryOf } from "./summary.ts";
 import { variantGroupsOf, type VariantGroups } from "./variants-input.ts";
 
@@ -21,6 +22,8 @@ export type VariantColumn = {
   readonly contexts?: { readonly checked: number; readonly unsupported: number } | undefined;
   /** Only with a `grade:` rubric. */
   readonly penalty?: number | undefined;
+  /** The outputs at each level of the AI-likeness quick score. Absent when no result carries one. */
+  readonly aiScore?: AiLevelCounts | undefined;
 };
 
 /** One rule's rate per 1,000 units in each variant, by variant label; 0 where the variant had no finding of it. */
@@ -66,6 +69,7 @@ const columnOf = (variant: string, results: readonly GradeResult[]): VariantColu
     citations: summary.citations,
     ...(summary.contexts === undefined ? {} : { contexts: { checked: summary.contexts.checked, unsupported: sum(summary.contexts.unsupported) } }),
     ...(summary.penalty === undefined ? {} : { penalty: summary.penalty }),
+    ...(summary.aiScore === undefined ? {} : { aiScore: summary.aiScore }),
   };
 };
 

package/src/grade-api.ts

@@ -5,7 +5,8 @@ import { statSync } from "node:fs";
 import { resolve } from "node:path";
 import { packageFor } from "./adapter-load.ts";
 import { CLI_TEXT } from "./cli-text.ts";
-import { EMPTY, loadConfig, type Config } from "./config/load.ts";
+import { EMPTY, type Config } from "./config/load.ts";
+import { loadConfig } from "./config/read.ts";
 import { withStyle } from "./config/style.ts";
 import { withExtensions } from "./extension/load.ts";
 import { GENRES } from "./genre.ts";
@@ -35,6 +36,7 @@ export type {
   SupportedFact,
 } from "./grade/result.ts";
 export type { OutputSize } from "./grade/rates.ts";
+export type { AiLevelCounts, GradeAiScore } from "./grade/ai-score.ts";
 export { toScorer, type ChaffScore } from "./grade/scorer.ts";
 export type { Disagreement, VariantColumn, VariantComparison, VariantRates } from "./grade/variants.ts";
 export type { VariantInput } from "./grade/variants-input.ts";

package/src/judge.ts

@@ -78,8 +78,6 @@ export type JudgeOptions = {
 const judgeFor = (options: JudgeOptions): Judge =>
   options.backend === "openai" ? openai.judge(options.openaiClient) : anthropic.judge(options.anthropicClient);
 
-export const defaultModel = (backend: BackendName): string => (backend === "openai" ? openai.DEFAULT_MODEL : anthropic.DEFAULT_MODEL);
-
 export const hasCredentials = (backend: BackendName): boolean => (backend === "openai" ? openai.hasCredentials() : anthropic.hasCredentials());
 
 export const isAuthFailure = (backend: BackendName, error: unknown): boolean =>

package/src/known-genres.ts

@@ -1,6 +1,6 @@
-import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { exists, readText } from "./package-files.ts";
 import { loadGenres } from "./genre-load.ts";
 import { parseGenres, type GenreData } from "./genre-parse.ts";
 
@@ -15,5 +15,5 @@ export const knownGenres = (): string[] => idsOf(loadGenres());
  */
 export const genresBeside = (rulesDir: string): string[] => {
   const file = join(rulesDir, "..", "genres.yaml");
-  return existsSync(file) ? idsOf(parseGenres(parse(readFileSync(file, "utf8")))) : knownGenres();
+  return exists(file) ? idsOf(parseGenres(parse(readText(file)))) : knownGenres();
 };

package/src/package-files.ts

@@ -0,0 +1,15 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Every read of a file chaff ships (rules, genres, profiles, styles) goes through here, so a build without a file
+// system can put its own reads in this module's place. The functions take any path, as the callers always have.
+
+/** The package's folder: src/ and dist/ both sit right under it. */
+export const PACKAGE_DIR = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+export const readText = (path: string): string => readFileSync(path, "utf8");
+
+export const readDir = (path: string): string[] => readdirSync(path);
+
+export const exists = (path: string): boolean => existsSync(path);

package/src/profile/load.ts

@@ -1,22 +1,21 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { parse } from "yaml";
+import { PACKAGE_DIR, readDir, readText } from "../package-files.ts";
 import { parseProfile, type ProfileDefinition } from "./parse.ts";
 
-const PROFILES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "profiles");
+const PROFILES_DIR = join(PACKAGE_DIR, "profiles");
 
 const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: undefined };
 
 /** 同梱の profiles/*.yaml。一度だけ読む。 */
 export const loadProfiles = (): readonly ProfileDefinition[] => {
-  loaded.value ??= readdirSync(PROFILES_DIR)
+  loaded.value ??= readDir(PROFILES_DIR)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right))
     .flatMap((file) => {
       const path = join(PROFILES_DIR, file);
       try {
-        const definition = parseProfile(parse(readFileSync(path, "utf8")));
+        const definition = parseProfile(parse(readText(path)));
         return definition === undefined ? [] : [definition];
       } catch (error) {
         throw new Error(`cannot read the profile ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });

package/src/rule-load.ts

@@ -1,6 +1,4 @@
-import { readFileSync, readdirSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { parse } from "yaml";
 import type { LanguageLevels, LevelSets, LevelTable, RuleDefinition, Severity } from "./plugin.ts";
 import { rankOfSeverity, severityAt } from "./levels.ts";
@@ -8,8 +6,9 @@ import { optionsOf } from "./rule-options.ts";
 import { ruleGuideOf } from "./rule-guide.ts";
 import { fieldProblemSentence, fieldProblems } from "./rule-fields.ts";
 import { genresBeside } from "./known-genres.ts";
+import { PACKAGE_DIR, readDir, readText } from "./package-files.ts";
 
-const RULES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "rules");
+const RULES_DIR = join(PACKAGE_DIR, "rules");
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
 
@@ -191,7 +190,7 @@ const ruleOf = (raw: Record<string, unknown>, levels: LevelTable, levelSets: Lev
  */
 const parseRule = (dir: string, file: string): unknown => {
   try {
-    return parse(readFileSync(join(dir, file), "utf8"));
+    return parse(readText(join(dir, file)));
   } catch (error) {
     throw new Error(`${file} を読めません: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`, { cause: error });
   }
@@ -199,7 +198,7 @@ const parseRule = (dir: string, file: string): unknown => {
 
 export const loadRules = (language: string, dir: string = RULES_DIR): RuleDefinition[] => {
   const genres = genresBeside(dir);
-  return readdirSync(dir)
+  return readDir(dir)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right, "en"))
     .map((file) => toRule(parseRule(dir, file), language, file, genres));

package/src/rule-offs.ts

@@ -1,6 +1,6 @@
-import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { readDir, readText } from "./package-files.ts";
 
 /** One rule a group or genre turns off by default, from the rule file's off_for, with why. */
 export type RuleOff = { readonly rule: string; readonly target: string; readonly reason: string };
@@ -34,7 +34,7 @@ const offForBlock = (rule: string, text: string): string | undefined => {
 /** The offs of one rule file. The rule is named by the file, which is named by the rule's id. */
 const offsInFile = (dir: string, file: string): RuleOff[] => {
   const rule = file.replace(/\.yaml$/u, "");
-  const block = offForBlock(rule, readFileSync(join(dir, file), "utf8").replaceAll("\r\n", "\n"));
+  const block = offForBlock(rule, readText(join(dir, file)).replaceAll("\r\n", "\n"));
   const parsed: unknown = block === undefined ? undefined : parse(block);
   return ruleOffsOf(rule, isRecord(parsed) ? parsed["off_for"] : undefined);
 };
@@ -44,7 +44,7 @@ const offsInFile = (dir: string, file: string): RuleOff[] => {
  * at startup, before any rule is.
  */
 export const loadRuleOffs = (dir: string): RuleOff[] =>
-  readdirSync(dir)
+  readDir(dir)
     .filter((file) => file.endsWith(".yaml"))
     .toSorted((left, right) => left.localeCompare(right, "en"))
     .flatMap((file) => offsInFile(dir, file));