chaffjs 0.0.1 → 0.1.0

package/src/rule-load.ts

@@ -10,15 +10,25 @@ const isRecord = (value: unknown): value is Record<string, unknown> => typeof va
 
 const isLocalized = (value: unknown): value is Record<string, string> => isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
 
+const SEVERITY_BY_NAME: Readonly<Record<string, number>> = { info: 1, warning: 2, error: 3 };
+
+/** L4 は件数ではなく深刻度を段で持つ。error/warning/info を数に写して同じ器に入れる。 */
+const asNumber = (entry: unknown): number | undefined => {
+  if (typeof entry === "number") return entry;
+  return typeof entry === "string" ? SEVERITY_BY_NAME[entry] : undefined;
+};
+
 const isLevelTable = (value: unknown): value is LevelTable =>
-  isRecord(value) && Object.entries(value).every(([key, entry]) => ["strict", "normal", "relaxed"].includes(key) && typeof entry === "number");
+  isRecord(value) && Object.entries(value).every(([key, entry]) => ["strict", "normal", "relaxed"].includes(key) && asNumber(entry) !== undefined);
 
 /** 言語別の levels を、その言語のぶんだけに平坦化する。単位が言語で違う rule のため。 */
+const normalize = (table: LevelTable): LevelTable => Object.fromEntries(Object.entries(table).map(([key, entry]) => [key, asNumber(entry) ?? 0]));
+
 const flattenLevels = (raw: unknown, language: string): LevelTable | undefined => {
-  if (isLevelTable(raw)) return raw;
+  if (isLevelTable(raw)) return normalize(raw);
   if (!isRecord(raw)) return undefined;
   const forLanguage = raw[language] ?? raw["default"];
-  return isLevelTable(forLanguage) ? forLanguage : undefined;
+  return isLevelTable(forLanguage) ? normalize(forLanguage) : undefined;
 };
 
 const SEVERITIES: readonly Severity[] = ["error", "warning", "info"];
@@ -65,6 +75,7 @@ const toRule = (raw: unknown, language: string, file: string): RuleDefinition =>
     levels,
     how_to_find: String(raw["how_to_find"]),
     word_list: typeof raw["word_list"] === "string" ? raw["word_list"] : undefined,
+    what_to_check: isLocalized(raw["what_to_check"]) ? raw["what_to_check"] : undefined,
     where: typeof raw["where"] === "string" ? raw["where"] : undefined,
     use_for: Array.isArray(raw["use_for"]) ? raw["use_for"].map((entry) => String(entry)) : [],
     severity: isSeverity(raw["severity"]) ? raw["severity"] : "warning",

package/src/run-semantic.ts

@@ -0,0 +1,107 @@
+import { severityOf, type UserCheck } from "./checks.ts";
+import { ask, type JudgeOptions } from "./judge.ts";
+import { FILTERS, type Candidate } from "./semantic.ts";
+import { localized } from "./render/text.ts";
+import type { Finding, Level, ProseDocument, RuleDefinition, Severity } from "./plugin.ts";
+import { lineStarts, placeOf } from "./position.ts";
+
+export type SemanticResult = {
+  readonly findings: readonly Finding[];
+  readonly skipped: readonly { rule: string; why: string }[];
+  readonly asked: number;
+  readonly sentencesSeen: number;
+};
+
+type Job = {
+  readonly rule: string;
+  readonly name: string;
+  readonly rubric: string;
+  readonly howToFix: string;
+  readonly severity: Severity;
+  readonly candidates: readonly Candidate[];
+};
+
+const filterFor = (name: string | undefined): (typeof FILTERS)[string] => FILTERS[name ?? "whole-document"] ?? FILTERS["whole-document"] ?? (() => []);
+
+const SEVERITY_BY_VALUE: readonly Severity[] = ["info", "info", "warning", "error"];
+
+const severityFromLevel = (rule: RuleDefinition, level: Level): Severity => {
+  if (level === "off") return "info";
+  const value = rule.levels[level] ?? rule.levels.normal ?? 2;
+  return SEVERITY_BY_VALUE[Math.min(3, Math.max(1, Math.round(value)))] ?? "warning";
+};
+
+const builtInJobs = (doc: ProseDocument, rules: readonly RuleDefinition[], settings: Readonly<Record<string, Level>>, genre: string): Job[] =>
+  rules
+    .filter((rule) => rule.layer === "L4" && rule.use_for.some((target) => genre.startsWith(target)) && settings[rule.id] !== "off")
+    .flatMap((rule) => {
+      const rubric = rule.what_to_check === undefined ? undefined : localized(rule.what_to_check, doc.language);
+      if (rubric === undefined || rubric.length === 0) return [];
+      return [
+        {
+          rule: rule.id,
+          name: localized(rule.name, doc.language),
+          rubric,
+          howToFix: localized(rule.how_to_fix, doc.language),
+          severity: severityFromLevel(rule, settings[rule.id] ?? "normal"),
+          candidates: filterFor(rule.how_to_find)(doc),
+        },
+      ];
+    });
+
+const userJobs = (doc: ProseDocument, checks: readonly UserCheck[], genre: string): Job[] =>
+  checks
+    .filter((check) => check.level !== "off" && check.use_for.some((target) => genre.startsWith(target)))
+    .map((check) => ({
+      rule: check.id,
+      name: check.name,
+      // look_at は自然文なので、まだ絞り込みに変換できない。文書全体を渡す。spec §26-7。
+      rubric: check.look_at === undefined ? check.check : `${check.check}\n\n見るところ: ${check.look_at}`,
+      howToFix: check.how_to_fix,
+      severity: severityOf(check.level),
+      candidates: filterFor("whole-document")(doc),
+    }));
+
+const findingOf = (job: Job, candidate: Candidate, reason: string, confidence: number, threshold: number, starts: readonly number[]): Finding => {
+  const at = placeOf(starts, candidate.offset);
+  // 確からしさが低いものは指摘として出すが、重さを下げる。spec §14。
+  const severity = confidence < threshold ? "info" : job.severity;
+  return {
+    rule: job.rule,
+    severity,
+    line: at.line,
+    column: at.column,
+    quote: candidate.text.slice(0, 200),
+    values: { reason, confidence: confidence.toFixed(2), offset: candidate.offset },
+  };
+};
+
+export type SemanticOptions = JudgeOptions & { readonly confidenceThreshold: number };
+
+export const runSemantic = async (
+  doc: ProseDocument,
+  rules: readonly RuleDefinition[],
+  checks: readonly UserCheck[],
+  settings: Readonly<Record<string, Level>>,
+  genre: string,
+  options: SemanticOptions,
+): Promise<SemanticResult> => {
+  const jobs = [...builtInJobs(doc, rules, settings, genre), ...userJobs(doc, checks, genre)];
+  const starts = lineStarts(doc.source);
+  const skipped = jobs.filter((job) => job.candidates.length === 0).map((job) => ({ rule: job.rule, why: "見るところが無かったため" }));
+  const live = jobs.filter((job) => job.candidates.length > 0);
+  const answers = await Promise.all(
+    live.flatMap((job) =>
+      job.candidates.map(async (candidate) => {
+        const verdict = await ask({ rule: job.rule, rubric: job.rubric, candidate: candidate.text, language: doc.language }, options);
+        return verdict.violated ? findingOf(job, candidate, verdict.reason, verdict.confidence, options.confidenceThreshold, starts) : undefined;
+      }),
+    ),
+  );
+  return {
+    findings: answers.filter((finding) => finding !== undefined).sort((left, right) => left.line - right.line),
+    skipped,
+    asked: live.reduce((sum, job) => sum + job.candidates.length, 0),
+    sentencesSeen: doc.sentences.length,
+  };
+};

package/src/run.ts

@@ -36,6 +36,10 @@ export const runRules = (doc: ProseDocument, rules: readonly RuleDefinition[], s
     .map((rule) => rule.id);
   const outcome = applicable.reduce<{ findings: Finding[]; skipped: Skipped[] }>(
     (acc, rule) => {
+      // L4 は意味を読む検査。chaff test が扱う。ここで「検出器が無い」と言わせない。
+      if (rule.layer === "L4") {
+        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: "意味を読む検査のため（npx chaff test で動きます）" }] };
+      }
       const level = levelFor(rule, settings, experimental);
       if (level === "off") {
         const why = rule.status === "experimental" && settings[rule.id] === undefined ? "まだ試験中のため" : "設定で止めているため";

package/src/semantic.ts

@@ -0,0 +1,74 @@
+import type { ProseDocument, Section } from "./plugin.ts";
+
+/**
+ * 二段構えの 1 段目。文書全体を LLM に投げない。spec §14。
+ *
+ * 絞り込みを持たない L4 rule は登録できない。持たせないと、1 記事ごとに全文を
+ * 読ませることになり、速度もコストも成り立たない。
+ */
+export type Candidate = { readonly text: string; readonly offset: number };
+
+export type Filter = (doc: ProseDocument) => Candidate[];
+
+const heads = (doc: ProseDocument): string => doc.sections.map((section) => section.heading).join(" ");
+
+const sectionText = (doc: ProseDocument, section: Section): string => doc.source.slice(section.span.start, section.span.end).trim();
+
+/** 見出しに答えが書いてあるなら、本文を読ませる必要はない。 */
+const skipIfHeadingMatches = (doc: ProseDocument, pattern: RegExp): boolean => pattern.test(heads(doc));
+
+const RISK_HEADING = /リスク|懸念|デメリット|risk|tradeoff|downside/iu;
+
+/** 提案文書にリスクが書かれているか。見出しにあれば見ない。 */
+export const riskDisclosure: Filter = (doc) => {
+  if (skipIfHeadingMatches(doc, RISK_HEADING)) return [];
+  const body = doc.sentences.map((sentence) => sentence.text.trim()).join("");
+  if (body.length === 0) return [];
+  return [{ text: body.slice(0, 4000), offset: doc.sentences[0]?.span.start ?? 0 }];
+};
+
+const EVIDENCE = /\d|`|https?:\/\//u;
+
+/**
+ * 結びが本文の要約でしかないか。
+ * 最後の節だけを見て、そこに具体物が無いときにだけ問い合わせる。
+ */
+export const emptyConclusion: Filter = (doc) => {
+  const last = doc.sections.at(-1);
+  if (last === undefined || last.sentences.length === 0) return [];
+  const text = sectionText(doc, last);
+  if (EVIDENCE.test(text)) return [];
+  return [{ text: text.slice(0, 2000), offset: last.sentences[0]?.span.start ?? last.span.start }];
+};
+
+// \s* を挟むとバックトラックする。単位の前の空白は 1 つまでで足りる。
+const NUMBER = /\d ?(?:%|％|倍|割|件|人|円|ドル|時間|分|秒)/u;
+const EFFECT = /向上|改善|削減|短縮|増加|減少|成長|伸び/u;
+/**
+ * 根拠と認めるもの。ここを狭く取ると、根拠つきの文まで LLM に送ってしまう。
+ * 二段構えの 1 段目が防ぐべきなのは、まさにその無駄。
+ */
+const EVIDENCE_WORDS = ["出典", "調査", "自社調べ", "参考", "期間", "比較", "対比", "前年", "昨年", "同期", "前月", "前四半期", "vs"];
+const EVIDENCE_SHAPE = /n ?=|\[\d+\]|\d{4} ?年|Q[1-4]/iu;
+
+/** 語の照合は正規表現にしない。数が増えるほど式が読めなくなり、複雑度も上がる。 */
+const hasEvidence = (text: string): boolean => EVIDENCE_WORDS.some((word) => text.includes(word)) || EVIDENCE_SHAPE.test(text);
+
+/** 効果を主張する数値に根拠が無い文だけを渡す。 */
+export const unsourcedNumber: Filter = (doc) =>
+  doc.sentences
+    .filter((sentence) => NUMBER.test(sentence.text) && EFFECT.test(sentence.text) && !hasEvidence(sentence.text))
+    .map((sentence) => ({ text: sentence.text.trim(), offset: sentence.span.start }));
+
+/** 利用者が checks.yaml に書いた検査の既定。絞り込みを書かなければ文書全体。 */
+export const wholeDocument: Filter = (doc) => {
+  const body = doc.sentences.map((sentence) => sentence.text.trim()).join("");
+  return body.length === 0 ? [] : [{ text: body.slice(0, 4000), offset: doc.sentences[0]?.span.start ?? 0 }];
+};
+
+export const FILTERS: Readonly<Record<string, Filter>> = {
+  "risk-disclosure": riskDisclosure,
+  "empty-conclusion": emptyConclusion,
+  "unsourced-number": unsourcedNumber,
+  "whole-document": wholeDocument,
+};