chaffjs 0.8.0 → 0.10.0

package/src/commands/feedback.ts

@@ -0,0 +1,210 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Finding, RuleDefinition } from "../plugin.ts";
+import type { Config } from "../config/load.ts";
+import { messageOf } from "../render/text.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+import { excerptsAround } from "../feedback/excerpt.ts";
+import { feedbackDraft, type FeedbackDraft, type FeedbackKind, type ReportedFinding } from "../feedback/draft.ts";
+
+export const FEEDBACK_FILE = ".chaff-feedback.md";
+const NEW_ISSUE = "https://github.com/isamu/lab/issues/new";
+/** GitHub cuts long titles, and a title can carry document text through a rule's message. */
+export const MAX_TITLE_LENGTH = 120;
+
+export type Checked = {
+  readonly findings: readonly Finding[];
+  readonly rules: readonly RuleDefinition[];
+  readonly language: string;
+  readonly genre: string;
+};
+
+export type FeedbackContext = {
+  readonly cwd: string;
+  readonly ui: UiLanguage;
+  readonly version: string;
+  readonly runtime: string;
+  readonly flag: (argv: readonly string[], name: string) => string | undefined;
+  readonly check: (path: string) => Promise<Checked>;
+  /** The reported rules' own settings in chaff.yaml (one line each), or undefined when none are set. */
+  readonly settingsOf: (ruleIds: readonly string[]) => string | undefined;
+};
+
+const TEXT: Texts<{
+  readonly usage: string;
+  readonly notFound: (path: string) => string;
+  readonly badLine: (lines: number) => string;
+  readonly noMatch: (list: string) => string;
+  readonly several: (list: string) => string;
+  readonly none: string;
+  readonly written: (file: string, lines: string) => string;
+  readonly send: string;
+  readonly link: (file: string) => string;
+  readonly neverSent: string;
+}> = {
+  ja: {
+    usage: [
+      "使い方: chaff feedback <file> --rule <rule-id> [--line N] [--with-config]   誤った指摘を報告する",
+      "        chaff feedback <file> --missed --line N [--with-config]           見逃しを報告する",
+    ].join("\n"),
+    notFound: (path) => `${path} がありません。`,
+    badLine: (lines) => `--line には 1〜${String(lines)} の行番号を書いてください。`,
+    noMatch: (list) => `その指摘が見つかりません。この文書の指摘:\n${list}`,
+    several: (list) => `その rule の指摘がいくつもあります。--line で一つ選んでください:\n${list}`,
+    none: "  （指摘はありません）",
+    written: (file, lines) => `報告の下書きを ${file} に書きました。文書から載せたのは ${lines} だけです。送る前に読んで、要らない所は消してください。`,
+    send: "送るには（どちらか）:",
+    link: (file) => `ブラウザで（開いたページに ${file} の中身を貼ります）:`,
+    neverSent: "chaff は何も送っていません。",
+  },
+  en: {
+    usage: [
+      "usage: chaff feedback <file> --rule <rule-id> [--line N] [--with-config]   report a wrong finding",
+      "       chaff feedback <file> --missed --line N [--with-config]           report something chaff missed",
+    ].join("\n"),
+    notFound: (path) => `${path} does not exist.`,
+    badLine: (lines) => `--line must be a line number from 1 to ${String(lines)}.`,
+    noMatch: (list) => `No such finding. The findings in this document:\n${list}`,
+    several: (list) => `That rule has several findings here. Pick one with --line:\n${list}`,
+    none: "  (no findings)",
+    written: (file, lines) =>
+      `Wrote a draft report to ${file}. From the document it includes only ${lines}. Read it before sending, and delete anything you do not want to share.`,
+    send: "To send it (either):",
+    link: (file) => `In a browser (paste the contents of ${file} into the page):`,
+    neverSent: "chaff has not sent anything.",
+  },
+};
+
+const lineList = (lines: readonly number[], ui: UiLanguage): string =>
+  ui === "ja" ? `${lines.join("、")} 行目の前後` : `the lines around ${lines.join(", ")}`;
+
+/** The findings the person picked: by rule, by line, or both. */
+const chosen = (findings: readonly Finding[], rule: string | undefined, line: number | undefined): Finding[] =>
+  findings.filter((finding) => (rule === undefined || finding.rule === rule) && (line === undefined || finding.line === line));
+
+const describe = (findings: readonly Finding[], none: string): string =>
+  findings.length === 0 ? none : findings.map((finding) => `  ${String(finding.line)}  ${finding.rule}`).join("\n");
+
+/** Pure: the reported rules' own lines of chaff.yaml's rules (a numeric limit wins over a level), or undefined when none is set. */
+export const settingsOf = (config: Pick<Config, "rules" | "limits">, ruleIds: readonly string[]): string | undefined => {
+  const lines = [...new Set(ruleIds)].flatMap((id) => {
+    const limit = config.limits[id];
+    const level = config.rules[id];
+    if (limit !== undefined) return [`  ${id}: ${String(limit)}`];
+    return level === undefined ? [] : [`  ${id}: ${level}`];
+  });
+  return lines.length === 0 ? undefined : ["rules:", ...lines].join("\n");
+};
+
+/** Pure: a title on one line, no longer than GitHub shows. */
+export const titleLine = (title: string): string => {
+  const flat = title.replace(/\s+/gu, " ").trim();
+  return flat.length <= MAX_TITLE_LENGTH ? flat : `${flat.slice(0, MAX_TITLE_LENGTH - 1)}…`;
+};
+
+/** Pure: a string a POSIX shell reads literally — single quotes, with any single quote closed, escaped and reopened. */
+export const shellQuoted = (text: string): string => `'${text.replaceAll("'", "'\\''")}'`;
+
+type Request = {
+  readonly path: string;
+  readonly kind: FeedbackKind;
+  readonly rule: string | undefined;
+  readonly line: number | undefined;
+  readonly withConfig: boolean;
+};
+
+/** What the person asked to report. A wrong finding is picked by rule or line; a miss needs the line. */
+const requestOf = (targets: readonly string[], argv: readonly string[], context: FeedbackContext): Request | undefined => {
+  const [path] = targets;
+  const kind: FeedbackKind = argv.includes("--missed") ? "missed" : "false-positive";
+  const rule = context.flag(argv, "--rule");
+  const lineFlag = context.flag(argv, "--line");
+  const line = lineFlag === undefined ? undefined : Number(lineFlag);
+  const lineMissing = kind === "missed" ? line === undefined : rule === undefined && line === undefined;
+  if (path === undefined || targets.length !== 1 || lineMissing || (line !== undefined && !Number.isInteger(line))) return undefined;
+  return { path, kind, rule, line, withConfig: argv.includes("--with-config") };
+};
+
+const reported = (findings: readonly Finding[], checked: Checked): ReportedFinding[] => {
+  const byId = new Map(checked.rules.map((definition) => [definition.id, definition]));
+  return findings.flatMap((finding) => {
+    const definition = byId.get(finding.rule);
+    return definition === undefined ? [] : [{ rule: finding.rule, line: finding.line, message: messageOf(definition, finding, checked.language) }];
+  });
+};
+
+/** The link carries the title only: the body holds document lines, and a URL ends up in history and logs. */
+const sendInstructions = (title: string, lines: readonly number[], ui: UiLanguage): string => {
+  const text = TEXT[ui];
+  return [
+    "",
+    `  ${text.written(FEEDBACK_FILE, lineList([...new Set(lines)], ui))}`,
+    "",
+    `  ${text.send}`,
+    `    gh issue create -R isamu/lab --title ${shellQuoted(title)} --body-file ${FEEDBACK_FILE}`,
+    `  ${text.link(FEEDBACK_FILE)}`,
+    `    ${NEW_ISSUE}?title=${encodeURIComponent(title)}`,
+    "",
+    `  ${text.neverSent}`,
+    "",
+  ].join("\n");
+};
+
+/** Why the request cannot be drafted, or the findings to report. */
+const pick = (request: Request, checked: Checked, lineCount: number, ui: UiLanguage): { readonly error: string } | { readonly findings: Finding[] } => {
+  const text = TEXT[ui];
+  if (request.line !== undefined && (request.line < 1 || request.line > lineCount)) return { error: text.badLine(lineCount) };
+  const picked = chosen(checked.findings, request.rule, request.line);
+  if (request.kind === "missed") return { findings: picked };
+  if (picked.length === 0) return { error: text.noMatch(describe(checked.findings, text.none)) };
+  // One finding per report: a rule picked alone could otherwise pull excerpts from all over the document.
+  if (picked.length > 1) return { error: text.several(describe(picked, text.none)) };
+  return { findings: picked };
+};
+
+/**
+ * `chaff feedback`: an issue draft from a run on the person's own document. It writes a file and prints how to
+ * send it; it never sends anything itself. Only the lines around the reported spot are copied from the document,
+ * and from chaff.yaml only the reported rules' settings unless --with-config is given.
+ */
+export const runFeedback = async (targets: readonly string[], argv: readonly string[], context: FeedbackContext): Promise<number> => {
+  const text = TEXT[context.ui];
+  const request = requestOf(targets, argv, context);
+  if (request === undefined) {
+    console.error(text.usage);
+    return 1;
+  }
+  if (!existsSync(request.path)) {
+    console.error(text.notFound(request.path));
+    return 1;
+  }
+  const source = readFileSync(request.path, "utf8");
+  const checked = await context.check(request.path);
+  const picked = pick(request, checked, source.split("\n").length, context.ui);
+  if ("error" in picked) {
+    console.error(picked.error);
+    return 1;
+  }
+  const findings = reported(picked.findings, checked);
+  const lines = request.kind === "missed" && request.line !== undefined ? [request.line] : findings.map((finding) => finding.line);
+  const configPath = join(context.cwd, "chaff.yaml");
+  const wholeConfig = request.withConfig && existsSync(configPath) ? readFileSync(configPath, "utf8") : undefined;
+  const draft: FeedbackDraft = feedbackDraft(
+    {
+      kind: request.kind,
+      version: context.version,
+      runtime: context.runtime,
+      fileName: basename(request.path),
+      language: checked.language,
+      genre: checked.genre,
+      findings,
+      line: lines[0] ?? 0,
+      excerpts: excerptsAround(source, lines),
+      config: wholeConfig ?? context.settingsOf(findings.map((finding) => finding.rule)),
+    },
+    context.ui,
+  );
+  writeFileSync(join(context.cwd, FEEDBACK_FILE), draft.body, "utf8");
+  console.log(sendInstructions(titleLine(draft.title), lines, context.ui));
+  return 0;
+};

package/src/commands/test.ts

@@ -14,6 +14,7 @@ import { MACHINE_BANNER, renderPlan, renderSemantic } from "../render/semantic.t
 import type { Config } from "../config/load.ts";
 import type { Finding, RuleDefinition } from "../plugin.ts";
 import type { Failure } from "../backends/types.ts";
+import { profileFor } from "../profile/for-file.ts";
 
 export type TestContext = {
   readonly config: Config;
@@ -35,7 +36,7 @@ const judgeAll = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config));
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
       const rules = loadRules(language);
       return { path, outcome: await runSemantic(doc, rules, checks, config.rules, genre, options), rules, language };
@@ -55,7 +56,7 @@ const dryRun = async (
       const source = await readFile(path, "utf8");
       const language = applyByPath(config.byPath, config.baseDir, path).language ?? config.language ?? guessLanguage(source).language;
       const adapter = await loadAdapter(language);
-      const doc = buildDocument(path, source, adapter, teamRules(config));
+      const doc = buildDocument(path, source, adapter, teamRules(config), profileFor(config, path, source, language));
       const { genre } = resolveGenre(path, source, config);
       return { path, jobs: planSemantic(doc, loadRules(language), checks, config.rules, genre), sentences: doc.sentences.length };
     }),

package/src/commands/tree.ts

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { loadAdapter } from "../adapter-load.ts";
 import { applyByPath } from "../config/by-path.ts";
+import { profileFor } from "../profile/for-file.ts";
 import { guessLanguage } from "../detect.ts";
 import { isMarkdownPath } from "../structure/markdown-path.ts";
 import { buildStructure } from "../structure/of.ts";
@@ -79,7 +80,8 @@ export const readTree = async (path: string, argv: readonly string[], context: T
   }
   // 日本語は形態素で数量と日付を読む。解析器が無ければ単位の表で読むので、木は作れる。
   await adapter.prepare?.({ pos: true });
-  return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path) }, adapter.structure) };
+  const profile = profileFor(context.config, path, source, language);
+  return { source, tree: buildStructure({ path, source, language, markdown: isMarkdownPath(path), profile }, adapter.structure) };
 };
 
 const printTree = async (path: string, argv: readonly string[], context: TreeContext): Promise<boolean> => {

package/src/config/by-path.ts

@@ -1,6 +1,11 @@
 import { relative, sep } from "node:path";
 
-export type PathRule = { readonly files: readonly string[]; readonly genre: string | undefined; readonly language: string | undefined };
+export type PathRule = {
+  readonly files: readonly string[];
+  readonly genre: string | undefined;
+  readonly language: string | undefined;
+  readonly profile?: string | undefined;
+};
 
 /**
  * glob を正規表現にする。使うのは 3 つだけ。
@@ -36,12 +41,15 @@ export const matches = (glob: string, base: string, path: string): boolean => to
  * 後に書いたものが勝つ。上から順に当て、最後に当たったものを使う。
  * 「全体はこう、ここだけは違う」と書けるようにするため。
  */
-export const applyByPath = (rules: readonly PathRule[], base: string, path: string): { genre?: string; language?: string } =>
-  rules.reduce<{ genre?: string; language?: string }>((acc, rule) => {
+type PathSettings = { genre?: string; language?: string; profile?: string };
+
+export const applyByPath = (rules: readonly PathRule[], base: string, path: string): PathSettings =>
+  rules.reduce<PathSettings>((acc, rule) => {
     if (!rule.files.some((glob) => matches(glob, base, path))) return acc;
     return {
       ...acc,
       ...(rule.genre === undefined ? {} : { genre: rule.genre }),
       ...(rule.language === undefined ? {} : { language: rule.language }),
+      ...(rule.profile === undefined ? {} : { profile: rule.profile }),
     };
   }, {});

package/src/config/load.ts

@@ -11,6 +11,8 @@ export const CONFIG_FILE = "chaff.yaml";
 
 export type Config = {
   readonly genre: string | undefined;
+  /** 文書の種類（profiles/*.yaml の id）。none なら内容からも選ばない。 */
+  readonly profile: string | undefined;
   readonly aiBackend: BackendName;
   readonly language: string | undefined;
   readonly rules: Readonly<Record<string, Level>>;
@@ -39,6 +41,7 @@ const DEFAULT_BACKEND: BackendName = "anthropic";
 
 export const EMPTY: Config = {
   genre: undefined,
+  profile: undefined,
   language: undefined,
   rules: {},
   limits: {},
@@ -93,7 +96,7 @@ const toPathRule = (raw: unknown): PathRule | undefined => {
   const files = raw["files"];
   const globs = globsOf(files);
   if (globs.length === 0) return undefined;
-  return { files: globs, genre: str(raw["genre"]), language: str(raw["language"]) };
+  return { files: globs, genre: str(raw["genre"]), language: str(raw["language"]), profile: str(raw["profile"]) };
 };
 
 /** 利用者が書く語の並び。空白だけのものは落とす。 */
@@ -121,6 +124,7 @@ export const loadConfig = (path: string): Config => {
   const backend: BackendName = isBackend(declared) ? declared : DEFAULT_BACKEND;
   return {
     genre: str(raw["genre"]),
+    profile: str(raw["profile"]),
     language: str(raw["language"]),
     rules: rulesOf(raw["rules"]),
     limits: limitsOf(raw["rules"]),

package/src/detectors/char-shape.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
+import { maskAddresses } from "../address-chain.ts";
 import { proseText } from "../measure.ts";
 
 /**
@@ -7,8 +8,8 @@ import { proseText } from "../measure.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-const longestKanji = (sentence: Sentence): string =>
-  [...proseText(sentence).matchAll(KANJI_RUN)].reduce((longest, match) => (match[0].length > longest.length ? match[0] : longest), "");
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined): string =>
+  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)].reduce((longest, match) => (match[0].length > longest.length ? match[0] : longest), "");
 
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
@@ -16,7 +17,7 @@ const longestKanji = (sentence: Sentence): string =>
  */
 export const kanjiRun: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",

package/src/detectors/index.ts

@@ -15,7 +15,7 @@ import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefined
 import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 import { latinSpacing, preferredTerm } from "./orthography.ts";
-import { danglingReference, duplicateDefinition, numberingGap } from "./structure-tree.ts";
+import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
 export const DETECTORS: Readonly<Record<string, Detector>> = {
@@ -58,6 +58,9 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "preferred-term": preferredTerm,
   "latin-spacing": latinSpacing,
   "dangling-reference": danglingReference,
+  "date-weekday-mismatch": dateWeekdayMismatch,
+  "date-order": dateOrder,
+  "total-mismatch": totalMismatch,
   "numbering-gap": numberingGap,
   "duplicate-definition": duplicateDefinition,
 };

package/src/detectors/lexicon.ts

@@ -1,3 +1,4 @@
+import { joinWords } from "./word-list.ts";
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
@@ -118,7 +119,16 @@ export const aiTell: Detector = (doc, options): Finding[] => {
       line: 0,
       column: 0,
       quote: first.text.trim(),
-      values: { word: found.map(([pattern]) => pattern).join("、"), count: found.length, density: score, limit: options.limit, offset: first.span.start },
+      values: {
+        word: joinWords(
+          found.map(([pattern]) => pattern),
+          doc.language,
+        ),
+        count: found.length,
+        density: score,
+        limit: options.limit,
+        offset: first.span.start,
+      },
     },
   ];
 };

package/src/detectors/structure-tree.ts

@@ -1,6 +1,9 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { danglingReferences, duplicateDefinitions, type StructureIssue } from "../structure/issues.ts";
+import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
+import { weekdayMismatches } from "../structure/weekday.ts";
+import { dateOrderBreaks } from "../structure/date-order.ts";
+import { totalMismatches, type Amount } from "../structure/total.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -30,3 +33,66 @@ const findingsOf =
 export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
 export const numberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
+
+/** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
+const dayName = (doc: ProseDocument, day: unknown): string => {
+  const index = Number(day);
+  return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
+};
+
+export const dateWeekdayMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : weekdayMismatches(doc.structure).map((issue) => ({
+        rule: "date-weekday-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: {
+          date: String(issue.values["date"]),
+          written: dayName(doc, issue.values["written"]),
+          actual: dayName(doc, issue.values["actual"]),
+          offset: issue.offset,
+        },
+      }));
+
+/** 木の日付を、原文の位置と一緒に並べる。 */
+const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, value: String(node.attrs["value"]) }] : []));
+
+/** 日程の並びに逆らう日付。並びの読み方は原文の行を見るので、木と原文の両方を渡す。 */
+export const dateOrder: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : dateOrderBreaks(doc.source, datedPoints(doc.structure)).map((issue) => ({
+        rule: "date-order",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));
+
+/** 木の数量を、原文の位置と一緒に並べる。 */
+const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
+  inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
+  );
+
+/** 合計の行が、上の金額の和と合わない。合計の語は言語パッケージの語彙表（total-label）から取る。 */
+export const totalMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : totalMismatches(
+        doc.source,
+        amountsOf(doc.structure),
+        (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
+      ).map((issue) => ({
+        rule: "total-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/team.ts

@@ -1,4 +1,5 @@
 import { proseText } from "../measure.ts";
+import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
 
@@ -12,7 +13,11 @@ import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
  * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
  * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
  */
-const matches = (sentence: Sentence, word: string): boolean => sentence.text.includes(word) || (sentence.tokens ?? []).some((token) => token.lemma === word);
+const matches = (sentence: Sentence, word: string): boolean => {
+  // 大文字小文字は区別しない。英語の文頭の「Circle back」も「circle back」として当てる。
+  const wanted = word.toLowerCase();
+  return sentence.text.toLowerCase().includes(wanted) || (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted);
+};
 
 export const internalJargon: Detector = (doc, options): Finding[] => {
   const words = (options.lexicon ?? []).map((entry) => entry.pattern);
@@ -53,7 +58,7 @@ export const requiredSections: Detector = (doc, options): Finding[] => {
       line: 0,
       column: 0,
       quote: headings.filter((heading) => heading.length > 0).join(" / "),
-      values: { word: missing.join("、"), count: missing.length, limit: options.limit, offset: 0 },
+      values: { word: joinWords(missing, doc.language), count: missing.length, limit: options.limit, offset: 0 },
     },
   ];
 };

package/src/detectors/word-list.ts

@@ -0,0 +1,2 @@
+/** 語の並べ方は文書の言語に合わせる。日本語は「、」、ほかは ", "。英語の画面に「Risks、Costs」と出さない。 */
+export const joinWords = (words: readonly string[], language: string): string => words.join(language === "ja" ? "、" : ", ");

package/src/document.ts

@@ -7,7 +7,7 @@ import { atxHeadingText, headingText } from "./heading-text.ts";
 import { maskSpans } from "./mask.ts";
 import { buildTree, NO_OUTLINE, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
-import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode } from "./plugin.ts";
+import type { BulletList, LanguageAdapter, Paragraph, ProseDocument, Section, Sentence, Span, StructureNode, DocumentProfile } from "./plugin.ts";
 
 type Place = { readonly offset?: number | undefined };
 type Node = {
@@ -253,7 +253,13 @@ export const teamRules = (config: {
   requiredSections: config.requiredSections,
 });
 
-export const buildDocument = (path: string, source: string, adapter: LanguageAdapter, team: TeamRules = EMPTY_TEAM): ProseDocument => {
+export const buildDocument = (
+  path: string,
+  source: string,
+  adapter: LanguageAdapter,
+  team: TeamRules = EMPTY_TEAM,
+  profile: DocumentProfile | undefined = undefined,
+): ProseDocument => {
   const root = parse(source);
   // 強調の記号は「本文でないもの」だが、太字の数を数えるときの「覆われた場所」ではない。
   // 同じ集合にすると、太字が自分の記号のせいで覆われた場所にあることになり、1 つも数えられなくなる。
@@ -289,9 +295,11 @@ export const buildDocument = (path: string, source: string, adapter: LanguageAda
       tree.value ??=
         patterns === undefined
           ? null
-          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE }, patterns);
+          : buildTree({ path, source, language: adapter.id, outline: isMarkdownPath(path) ? outlineOf(root, source) : NO_OUTLINE, profile }, patterns);
       return tree.value ?? undefined;
     },
+    profile,
+    prose,
   };
 };
 

package/src/feedback/draft.ts

@@ -0,0 +1,102 @@
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { Excerpt } from "./excerpt.ts";
+
+export type FeedbackKind = "false-positive" | "missed";
+
+export type ReportedFinding = { readonly rule: string; readonly line: number; readonly message: string };
+
+export type FeedbackInput = {
+  readonly kind: FeedbackKind;
+  readonly version: string;
+  readonly runtime: string;
+  readonly fileName: string;
+  readonly language: string;
+  readonly genre: string;
+  readonly findings: readonly ReportedFinding[];
+  /** The line the person reported: the finding's line, or for a miss the line they named. */
+  readonly line: number;
+  readonly excerpts: readonly Excerpt[];
+  readonly config: string | undefined;
+};
+
+export type FeedbackDraft = { readonly title: string; readonly body: string };
+
+const TEXT: Texts<{
+  readonly titleFalse: (rule: string, message: string) => string;
+  readonly titleMissed: (fileName: string, line: number) => string;
+  readonly what: Readonly<Record<FeedbackKind, string>>;
+  readonly environment: string;
+  readonly findings: string;
+  readonly excerpt: string;
+  readonly config: string;
+  readonly expected: string;
+  readonly expectedHint: Readonly<Record<FeedbackKind, string>>;
+  readonly lines: (from: number, to: number) => string;
+}> = {
+  ja: {
+    titleFalse: (rule, message) => `誤検出: ${rule} — ${message}`,
+    titleMissed: (fileName, line) => `見逃し: ${fileName} の ${String(line)} 行目`,
+    what: { "false-positive": "この指摘は誤りだと思います。", missed: "ここで chaff は何か言うべきだと思います。" },
+    environment: "環境",
+    findings: "指摘",
+    excerpt: "文書の該当箇所（この部分だけを載せています）",
+    config: "chaff.yaml",
+    expected: "期待すること",
+    expectedHint: {
+      "false-positive": "<!-- なぜ誤りか、本来どう読むべきかを書いてください -->",
+      missed: "<!-- 何が問題で、どの rule が言うべきだったかを書いてください -->",
+    },
+    lines: (from, to) => `${String(from)}〜${String(to)} 行目`,
+  },
+  en: {
+    titleFalse: (rule, message) => `False positive: ${rule} — ${message}`,
+    titleMissed: (fileName, line) => `Missed: ${fileName} line ${String(line)}`,
+    what: { "false-positive": "I think this finding is wrong.", missed: "I think chaff should say something here." },
+    environment: "Environment",
+    findings: "Findings",
+    excerpt: "The part of the document (only these lines are included)",
+    config: "chaff.yaml",
+    expected: "What I expected",
+    expectedHint: {
+      "false-positive": "<!-- Why it is wrong, and how the text should be read -->",
+      missed: "<!-- What is wrong in the text, and which rule should have said so -->",
+    },
+    lines: (from, to) => `lines ${String(from)}-${String(to)}`,
+  },
+};
+
+const fence = (content: string, language = ""): string => {
+  const longest = Math.max(2, ...[...content.matchAll(/`+/gu)].map((match) => match[0].length));
+  const ticks = "`".repeat(longest + 1);
+  return [`${ticks}${language}`, content, ticks].join("\n");
+};
+
+/** Pure: the issue title and body for a report. Nothing here reads files or the network. */
+export const feedbackDraft = (input: FeedbackInput, ui: UiLanguage): FeedbackDraft => {
+  const text = TEXT[ui];
+  const first = input.findings[0];
+  const title =
+    input.kind === "false-positive" && first !== undefined ? text.titleFalse(first.rule, first.message) : text.titleMissed(input.fileName, input.line);
+  const body = [
+    text.what[input.kind],
+    "",
+    `## ${text.environment}`,
+    "",
+    `- chaffjs ${input.version}`,
+    `- ${input.runtime}`,
+    `- ${input.fileName} · ${input.language} · ${input.genre}`,
+    ...(input.findings.length === 0
+      ? []
+      : ["", `## ${text.findings}`, "", ...input.findings.map((finding) => `- \`${finding.rule}\` (${String(finding.line)}): ${finding.message}`)]),
+    "",
+    `## ${text.excerpt}`,
+    ...input.excerpts.flatMap((excerpt) => ["", text.lines(excerpt.from, excerpt.to), "", fence(excerpt.lines.join("\n"))]),
+    ...(input.config === undefined ? [] : ["", `## ${text.config}`, "", fence(input.config.trimEnd(), "yaml")]),
+    "",
+    `## ${text.expected}`,
+    "",
+    text.expectedHint[input.kind],
+    "",
+  ].join("\n");
+  return { title, body };
+};