chaffjs 0.25.0 → 0.26.0

package/src/ai-score/view.ts

@@ -0,0 +1,21 @@
+import type { LengthUnit, RuleDefinition } from "../plugin.ts";
+import { loadGenres } from "../genre-load.ts";
+import { localized } from "../render/text.ts";
+import { STRUCTURE_TEXT } from "../outline/structure-text.ts";
+import { uiLanguageOf } from "../ui.ts";
+import type { ScoreView } from "./render.ts";
+import { AI_SCORE_TEXT } from "./text.ts";
+
+/** The texts and names a score is shown with, in the document's language. */
+export const scoreViewOf = (language: string, unit: LengthUnit, group: string, rules: readonly RuleDefinition[]): ScoreView => {
+  const ui = uiLanguageOf(language);
+  const name = loadGenres().groups.find((entry) => entry.id === group)?.name;
+  return {
+    text: AI_SCORE_TEXT[ui],
+    structure: STRUCTURE_TEXT[ui],
+    language: ui,
+    unit,
+    groupName: name === undefined ? group : localized(name, ui),
+    ruleNames: Object.fromEntries(rules.map((rule) => [rule.id, rule.name])),
+  };
+};

package/src/backends/anthropic.ts

@@ -14,8 +14,6 @@ export type AnthropicClient = { readonly messages: { readonly create: (params: A
 const isTextBlock = (block: unknown): block is { readonly text: string } =>
   typeof block === "object" && block !== null && "text" in block && typeof block.text === "string";
 
-export const DEFAULT_MODEL = "claude-opus-5";
-
 /**
  * 認証情報があるか。
  *

package/src/backends/default-model.ts

@@ -0,0 +1,9 @@
+import type { BackendName } from "./types.ts";
+
+// Apart from the backends, so reading settings does not load the providers' SDKs.
+
+const ANTHROPIC_DEFAULT_MODEL = "claude-opus-5";
+
+const OPENAI_DEFAULT_MODEL = "gpt-5";
+
+export const defaultModel = (backend: BackendName): string => (backend === "openai" ? OPENAI_DEFAULT_MODEL : ANTHROPIC_DEFAULT_MODEL);

package/src/backends/openai.ts

@@ -10,8 +10,6 @@ export type OpenAIClient = {
   readonly chat: { readonly completions: { readonly create: (params: OpenAI.ChatCompletionCreateParamsNonStreaming) => Promise<OpenAIResponse> } };
 };
 
-export const DEFAULT_MODEL = "gpt-5";
-
 export const hasCredentials = (): boolean => (process.env["OPENAI_API_KEY"] ?? "").length > 0;
 
 export const isAuthFailure = (error: unknown): boolean => error instanceof OpenAI.APIError && error.status === 401;

package/src/browser/adapter-import.ts

@@ -0,0 +1,19 @@
+import { ensurePackageFiles } from "chaffjs/browser-files";
+
+// adapter-import.ts in a bundle: a bundler cannot follow an import by a name known only at run time, so the bundled
+// languages are named here, each loaded only when a document in it is checked, after its files.
+
+const ADAPTERS: Readonly<Record<string, () => Promise<unknown>>> = {
+  "@chaffjs/lang-ja": () => import("@chaffjs/lang-ja"),
+  "@chaffjs/lang-en": () => import("@chaffjs/lang-en"),
+};
+
+/** The error Node gives for a package that is not installed, which adapter-load.ts reads as "not installed". */
+const notInstalled = (specifier: string): Error => Object.assign(new Error(`Cannot find package '${specifier}'`), { code: "ERR_MODULE_NOT_FOUND" });
+
+export const importPackage = async (specifier: string): Promise<unknown> => {
+  const load = Object.hasOwn(ADAPTERS, specifier) ? ADAPTERS[specifier] : undefined;
+  if (load === undefined) throw notInstalled(specifier);
+  await ensurePackageFiles(specifier);
+  return load();
+};

package/src/browser/bounded-match.ts

@@ -0,0 +1,9 @@
+import type { TextMatches } from "../custom/pattern-timeout.ts";
+
+// custom/bounded-match.ts in a browser, which has no vm to stop a pattern: the same matches, without the time limit.
+// regex-safety.ts still refuses the shapes known to run away before a pattern is used.
+
+export const boundedMatches = (source: string, flags: string, texts: readonly string[]): TextMatches =>
+  texts.map((text) =>
+    [...text.matchAll(new RegExp(source, `g${flags}`))].filter((match) => match[0] !== "").map((match) => ({ index: match.index, text: match[0] })),
+  );

package/src/browser/check-text.ts

@@ -0,0 +1,106 @@
+import { aiScoreOfDocument } from "../ai-score/of-document.ts";
+import { aiScoreHeadline } from "../ai-score/render.ts";
+import { HIGH_SIGNS, MEDIUM_SIGNS } from "../ai-score/score.ts";
+import { scoreViewOf } from "../ai-score/view.ts";
+import { checkSource, type SourceCheck } from "../check-source.ts";
+import { configOf, CONFIG_FILE, EMPTY, type Config } from "../config/load.ts";
+import { withStyle } from "../config/style.ts";
+import { gradeAiScoreOf, type GradeAiScore } from "../grade/ai-score.ts";
+import { findingOf } from "../grade/finding.ts";
+import type { GradeFinding, NotRunEntry } from "../grade/result.ts";
+import type { Finding } from "../plugin.ts";
+import { filledText } from "../render/text.ts";
+import { loadStyles } from "../style-load.ts";
+import { uiLanguageOf, type Texts } from "../ui.ts";
+
+// One text checked as `chaff <file>` checks it, with no files around it: imported by browser.ts once chaff's own files
+// are in memory, because the modules below read them as they load.
+
+export type BrowserCheckOptions = {
+  /** ja or en. Guessed from the text when left out, as the command line guesses. */
+  readonly language?: string | undefined;
+  /** A genre (business/report…), as --genre. */
+  readonly genre?: string | undefined;
+  /** chaff.yaml's contents, already parsed. Without it chaff's defaults apply, as with no chaff.yaml. */
+  readonly config?: unknown;
+  /** The document's name: rules for Markdown run only on a .md name. document.md when left out. */
+  readonly path?: string | undefined;
+  /** Run the experimental rules too, as --experimental. */
+  readonly experimental?: boolean | undefined;
+};
+
+/** A finding as `chaff grade` gives it, with the rule's name and its explanation, filled as the command line fills them. */
+export type BrowserFinding = GradeFinding & {
+  readonly name: string;
+  readonly why: string;
+  readonly howToFix: string;
+  /** The passage the finding is about. */
+  readonly quote: string;
+};
+
+/**
+ * The AI-likeness quick score as chaff grade gives it, with the lint report's words in the document's language: the
+ * level or why it was not scored, the signs, and the note that it is not a verdict on who wrote the text.
+ */
+export type BrowserAiScore = GradeAiScore & {
+  readonly headline: string;
+  /** The signs and the thresholds, when the text was scored. */
+  readonly signsLine: string | undefined;
+  readonly disclaimer: string;
+};
+
+export type BrowserCheck = {
+  readonly language: string;
+  readonly genre: string;
+  readonly findings: readonly BrowserFinding[];
+  readonly aiScore: BrowserAiScore;
+  /** Each rule that did not run, and why: so no finding is never read as "checked and fine". */
+  readonly notRun: readonly NotRunEntry[];
+};
+
+export const DEFAULT_PATH = "document.md";
+
+/** The settings chaff.yaml can hold that name files or code: a browser has neither, so they are reported, not applied. */
+const NEEDS_FILES = ["plugins", "include", "by_path"] as const;
+
+const REASON: Texts<string> = {
+  ja: "ファイルを読む設定で、ブラウザでは使えないため",
+  en: "it reads files, which a browser does not have",
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+/** by_path is dropped: it matches file paths, and a text checked here has none. plugins and include act only on files. */
+const configFrom = (raw: unknown): Config => (raw === undefined ? EMPTY : withStyle({ ...configOf(raw, `/${CONFIG_FILE}`), byPath: [] }, loadStyles()));
+
+const unappliedSettings = (raw: unknown, language: string): NotRunEntry[] =>
+  isRecord(raw) ? NEEDS_FILES.filter((key) => raw[key] !== undefined).map((key) => ({ rule: key, reason: REASON[uiLanguageOf(language)] })) : [];
+
+const browserFindingOf = (finding: Finding, check: SourceCheck): BrowserFinding => {
+  const rule = check.rules.find((entry) => entry.id === finding.rule);
+  const fill = (field: Parameters<typeof filledText>[0] | undefined): string => (field === undefined ? "" : filledText(field, finding, check.language));
+  return { ...findingOf(finding, check), name: fill(rule?.name), why: fill(rule?.why), howToFix: fill(rule?.how_to_fix), quote: finding.quote };
+};
+
+const aiScoreFor = (check: SourceCheck): BrowserAiScore => {
+  const score = aiScoreOfDocument(check.doc, check.rules, check.genre.genre);
+  const view = scoreViewOf(check.language, check.doc.lengthUnit, score.group, check.rules);
+  return {
+    ...gradeAiScoreOf(score),
+    headline: aiScoreHeadline(score, view),
+    signsLine: score.level === undefined ? undefined : view.text.signs(score.signs, score.compared, MEDIUM_SIGNS, HIGH_SIGNS),
+    disclaimer: view.text.disclaimer,
+  };
+};
+
+export const checkText = async (text: string, options: BrowserCheckOptions): Promise<BrowserCheck> => {
+  const choice = { language: options.language, genre: options.genre, experimental: options.experimental ?? false };
+  const check = await checkSource(options.path ?? DEFAULT_PATH, text, configFrom(options.config), choice);
+  return {
+    language: check.language,
+    genre: check.genre.genre,
+    findings: check.applied.kept.map((finding) => browserFindingOf(finding, check)),
+    aiScore: aiScoreFor(check),
+    notRun: [...check.raw.skipped.map((skipped) => ({ rule: skipped.rule, reason: skipped.why })), ...unappliedSettings(options.config, check.language)],
+  };
+};

package/src/browser/detectors.ts

@@ -0,0 +1,40 @@
+import type { CrossDetector, Detector } from "../plugin.ts";
+import { registryEntries } from "../detectors/registry-files.ts";
+
+// detectors/index.ts in a bundle: the registry folders cannot be listed at run time, so the bundler lists them
+// (import.meta.glob) when it builds. The same files, named and checked as registry-load.ts names and checks them.
+
+type Loaded = Readonly<Record<string, unknown>>;
+
+const isDetector = (value: unknown): value is Detector => typeof value === "function";
+
+const isCrossDetector = (value: unknown): value is CrossDetector => typeof value === "function";
+
+const fileName = (path: string): string => path.slice(path.lastIndexOf("/") + 1);
+
+/** From src the files end in .ts, from dist in .js (with .d.ts beside them, which registryEntries leaves out). */
+const registryOf = <T>(loaded: Loaded, isWanted: (value: unknown) => value is T): Readonly<Record<string, T>> => {
+  const byName = new Map(Object.entries(loaded).map(([path, detector]) => [fileName(path), detector]));
+  const names = [...byName.keys()];
+  const extension = names.some((name) => name.endsWith(".js")) ? ".js" : ".ts";
+  return Object.fromEntries(
+    registryEntries(names, extension).map(({ file, howToFind }) => {
+      const detector = byName.get(file);
+      if (!isWanted(detector)) throw new Error(`chaff: ${file} must export a function named detector`);
+      return [howToFind, detector];
+    }),
+  );
+};
+
+export const DETECTORS: Readonly<Record<string, Detector>> = registryOf(
+  import.meta.glob(["../detectors/registry/*.ts", "../detectors/registry/*.js", "!../detectors/registry/*.d.ts"], { eager: true, import: "detector" }),
+  isDetector,
+);
+
+export const CROSS_DETECTORS: Readonly<Record<string, CrossDetector>> = registryOf(
+  import.meta.glob(["../detectors/cross-registry/*.ts", "../detectors/cross-registry/*.js", "!../detectors/cross-registry/*.d.ts"], {
+    eager: true,
+    import: "detector",
+  }),
+  isCrossDetector,
+);

package/src/browser/import-meta-glob.d.ts

@@ -0,0 +1,5 @@
+// The part of a bundler's import.meta.glob (Vite's) that browser/detectors.ts uses: the matching modules' named export,
+// by path, imported when the bundle loads.
+interface ImportMeta {
+  glob(patterns: string | readonly string[], options: { readonly eager: true; readonly import: string }): Readonly<Record<string, unknown>>;
+}

package/src/browser/package-files.ts

@@ -0,0 +1,13 @@
+import { packageFiles } from "chaffjs/browser-files";
+
+// package-files.ts in a build without a file system: chaff's files from memory, rooted at /chaffjs.
+
+const files = packageFiles("chaffjs");
+
+export const PACKAGE_DIR = files.root;
+
+export const readText = (path: string): string => files.readText(path);
+
+export const readDir = (path: string): string[] => files.readDir(path);
+
+export const exists = (path: string): boolean => files.exists(path);

package/src/browser/path.ts

@@ -0,0 +1,73 @@
+// node:path for a build without Node: the POSIX functions chaff imports, over the in-memory files of chaffjs/browser-files.
+// The working folder is "/". test/test_browser_path.ts holds each function to node:path's posix one on generated paths.
+
+export const sep = "/";
+
+const normalizedParts = (parts: readonly string[], absolute: boolean): string[] =>
+  parts.reduce<string[]>((kept, part) => {
+    if (part === "" || part === ".") return kept;
+    if (part !== "..") return [...kept, part];
+    const last = kept.at(-1);
+    if (last !== undefined && last !== "..") return kept.slice(0, -1);
+    return absolute ? kept : [...kept, ".."];
+  }, []);
+
+export const normalize = (path: string): string => {
+  if (path === "") return ".";
+  const absolute = path.startsWith("/");
+  const body = normalizedParts(path.split("/"), absolute).join("/");
+  const trailing = path.endsWith("/") ? "/" : "";
+  if (absolute) return body === "" ? "/" : `/${body}${trailing}`;
+  return `${body === "" ? "." : body}${trailing}`;
+};
+
+export const join = (...parts: readonly string[]): string => {
+  const joined = parts.filter((part) => part !== "").join("/");
+  return joined === "" ? "." : normalize(joined);
+};
+
+export const isAbsolute = (path: string): boolean => path.startsWith("/");
+
+export const resolve = (...parts: readonly string[]): string => {
+  const from = parts.reduceRight((acc, part) => {
+    if (acc.startsWith("/") || part === "") return acc;
+    return acc === "" ? part : `${part}/${acc}`;
+  }, "");
+  const resolved = normalize(from.startsWith("/") ? from : `/${from}`);
+  return resolved.length > 1 && resolved.endsWith("/") ? resolved.slice(0, -1) : resolved;
+};
+
+const segmentsOf = (path: string): string[] =>
+  resolve(path)
+    .split("/")
+    .filter((part) => part !== "");
+
+export const relative = (from: string, to: string): string => {
+  const fromParts = segmentsOf(from);
+  const toParts = segmentsOf(to);
+  const differs = fromParts.findIndex((part, index) => toParts[index] !== part);
+  const shared = differs === -1 ? Math.min(fromParts.length, toParts.length) : differs;
+  return [...fromParts.slice(shared).map(() => ".."), ...toParts.slice(shared)].join("/");
+};
+
+/** The index of the last character that is not a slash, or -1. */
+const lastNonSlash = (path: string): number => {
+  let at = path.length - 1;
+  while (at >= 0 && path[at] === "/") at -= 1;
+  return at;
+};
+
+export const dirname = (path: string): string => {
+  if (path === "") return ".";
+  const last = lastNonSlash(path);
+  const end = last <= 0 ? -1 : path.lastIndexOf("/", last);
+  if (end < 1) return path.startsWith("/") ? "/" : ".";
+  return end === 1 && path.startsWith("/") ? "//" : path.slice(0, end);
+};
+
+export const extname = (path: string): string => {
+  const end = lastNonSlash(path) + 1;
+  const name = path.slice(path.lastIndexOf("/", end - 1) + 1, end);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 || name === ".." ? "" : name.slice(dot);
+};

package/src/browser/working-dir.ts

@@ -0,0 +1,3 @@
+// config/working-dir.ts in a build without a process: the root of the in-memory files.
+
+export const workingDir = (): string => "/";

package/src/browser-files.ts

@@ -0,0 +1,87 @@
+// The files chaff and its language packages ship (rules, genres, lexicons), held in memory for a build without a file
+// system. Every package reads its own through `packageFiles`, with the same paths the file system would give: one store,
+// imported by name (chaffjs/browser-files) so the browser entry and each package's reads meet in the same module.
+
+/** One package's files: path in the package (rules/max-sentence-length.yaml) → text. */
+export type PackageFiles = Readonly<Record<string, string>>;
+
+/** Where the files come from, and where kuromoji's dictionary is served (a URL ending in /). */
+export type BrowserSetup = {
+  readonly files: (packageName: string) => Promise<PackageFiles>;
+  readonly kuromojiDictionaryUrl: string;
+};
+
+type Store = { setup: BrowserSetup | undefined; readonly installed: Map<string, PackageFiles> };
+
+const store: Store = { setup: undefined, installed: new Map() };
+
+/** Each dictionary file is fetched at new URL(file name, kuromojiDictionaryUrl), so that URL must be absolute and end in /. */
+export const setupBrowserFiles = (setup: BrowserSetup): void => {
+  if (!URL.canParse(setup.kuromojiDictionaryUrl) || !setup.kuromojiDictionaryUrl.endsWith("/"))
+    throw new Error(`chaff: kuromojiDictionaryUrl must be an absolute URL ending in /: ${setup.kuromojiDictionaryUrl}`);
+  store.setup = setup;
+};
+
+const setupOf = (): BrowserSetup => {
+  if (store.setup === undefined) throw new Error("chaff: call setupBrowser() before check()");
+  return store.setup;
+};
+
+/** Asks for a package's files the first time they are needed, and keeps them. */
+export const ensurePackageFiles = async (packageName: string): Promise<void> => {
+  if (store.installed.has(packageName)) return;
+  const files = await setupOf().files(packageName);
+  store.installed.set(packageName, files);
+};
+
+export const kuromojiDictionaryUrl = (): string => setupOf().kuromojiDictionaryUrl;
+
+/** A package's files as a read-only file system rooted at /<package name>. */
+export type PackageFileReader = {
+  readonly root: string;
+  readonly readText: (path: string) => string;
+  readonly readDir: (path: string) => string[];
+  readonly exists: (path: string) => boolean;
+};
+
+const filesOf = (packageName: string): PackageFiles => {
+  const files = store.installed.get(packageName);
+  if (files === undefined) throw new Error(`chaff: the files of ${packageName} are not loaded`);
+  return files;
+};
+
+const inPackage = (root: string, path: string): string | undefined => (path.startsWith(`${root}/`) ? path.slice(root.length + 1) : undefined);
+
+const childrenOf = (files: PackageFiles, dir: string): string[] =>
+  Object.keys(files).flatMap((key) => {
+    if (!key.startsWith(`${dir}/`)) return [];
+    const name = key.slice(dir.length + 1);
+    return name.includes("/") ? [] : [name];
+  });
+
+const noSuchFile = (path: string): Error => Object.assign(new Error(`ENOENT: no such file or directory, '${path}'`), { code: "ENOENT" });
+
+export const packageFiles = (packageName: string): PackageFileReader => {
+  const root = `/${packageName}`;
+  return {
+    root,
+    readText: (path) => {
+      const key = inPackage(root, path);
+      const text = key === undefined ? undefined : filesOf(packageName)[key];
+      if (text === undefined) throw noSuchFile(path);
+      return text;
+    },
+    readDir: (path) => {
+      const key = inPackage(root, path);
+      const names = key === undefined ? [] : childrenOf(filesOf(packageName), key);
+      if (names.length === 0) throw noSuchFile(path);
+      return names;
+    },
+    exists: (path) => {
+      const key = inPackage(root, path);
+      if (key === undefined) return false;
+      const files = filesOf(packageName);
+      return Object.hasOwn(files, key) || childrenOf(files, key).length > 0;
+    },
+  };
+};

package/src/browser.ts

@@ -0,0 +1,19 @@
+// `chaffjs/browser`: chaff in a web page, with no file system and no server. Each package's files (rules, lexicons)
+// come from setupBrowser's `files`, asked for only when needed: chaff's own at the first check, a language's at the
+// first text in it. Nothing the page checks is sent anywhere. Built for a bundler that reads package.json's "browser"
+// field and import.meta.glob (Vite).
+import { ensurePackageFiles, setupBrowserFiles, type BrowserSetup } from "chaffjs/browser-files";
+import type { BrowserCheck, BrowserCheckOptions } from "./browser/check-text.ts";
+
+export type { BrowserSetup, PackageFiles } from "chaffjs/browser-files";
+export type { BrowserAiScore, BrowserCheck, BrowserCheckOptions, BrowserFinding } from "./browser/check-text.ts";
+export type { NotRunEntry } from "./grade/result.ts";
+
+export const setupBrowser = (setup: BrowserSetup): void => setupBrowserFiles(setup);
+
+/** Checks one text as `chaff <file>` does, and returns its findings and the rules that did not run, with why. */
+export const check = async (text: string, options: BrowserCheckOptions = {}): Promise<BrowserCheck> => {
+  await ensurePackageFiles("chaffjs");
+  const { checkText } = await import("./browser/check-text.ts");
+  return checkText(text, options);
+};

package/src/cli-text.ts

@@ -42,6 +42,7 @@ const USAGE_JA = `chaff — 文章の読みにくいところを見つけます
   chaff compare <前> <後>                書き換えで事実（数・日付・URL・コード・名前・引用…）が落ちても足されてもいないかを確かめる
   chaff facts <file>                     compare が照合する事実を、書き直す前の控えとして一覧にする
   chaff outline <file> [<後>]            見出しの構成と形（見出しの数・節の平均の長さ・箇条書きの割合・太字）を測る。2 つなら前と後を並べる
+  chaff ai-score <file>... [--format json]  AI らしさの簡易判定（低・中・高）。生成文に多い目印を、同じジャンルの人の文書と比べる（書いたのが AI かは判定しない）
   chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
                                  AI の出力を JSONL でまとめて採点する（指摘の率・事実・引用・合否。何も送らない）
   chaff fix-plan <file> [--json]         指摘をルールごとにまとめ、直す方向と確かめのコマンドを、書き直す人や AI 向けの計画にする（何も送らない）
@@ -88,6 +89,7 @@ const USAGE_EN = `chaff — finds what makes writing hard to read. It never rewr
   chaff compare <before> <after>          check that a rewrite dropped no fact and added none (numbers, dates, URLs, code, names, quotations…)
   chaff facts <file>                      list the facts compare checks, as an inventory to keep before a rewrite
   chaff outline <file> [<after>]          measure the outline and its shape (headings, average section length, text in lists, bold); two files side by side
+  chaff ai-score <file>... [--format json]  quick AI-likeness score (low, medium, high): signs common in generated text against human documents of the genre (not a verdict on who wrote it)
   chaff grade <items.jsonl> [--out <results.jsonl>] [--json]
                                  grade a JSONL file of model outputs (finding rates, facts, quotations, pass or fail; sends nothing)
   chaff fix-plan <file> [--json]          a plan for whoever rewrites the file, a person or an AI: findings by rule, how to rewrite each, the checks to run after (sends nothing)

package/src/cli.ts

@@ -41,6 +41,7 @@ import { settingWarnings } from "./config/warnings.ts";
 import { readConfigIn } from "./config/read.ts";
 import { settingSourcesOf } from "./config/option-problems.ts";
 import { renderSummary, type FileOutcome } from "./render/summary.ts";
+import { aiScoreLineOf } from "./ai-score/lint-line.ts";
 
 import type { Finding, Level, RuleDefinition } from "./plugin.ts";
 import { CLI_TEXT, type CliText, type GenreSource } from "./cli-text.ts";
@@ -110,7 +111,9 @@ const present = (check: SourceCheck, argv: readonly string[]): Inspected => {
   const result = { ...raw, findings: split.fresh };
   const { header, notes } = fileHeader(path, source, language, { genre, from, unread }, { shelved: split.shelved, hushed: applied.suppressed.length });
   const notRun = notRunAmong(applied.named, raw.skipped);
-  const text = argv.includes("--compact") ? renderCompact(header, result, rules, language) : renderFriendly(header, result, rules, language, notes);
+  const text = argv.includes("--compact")
+    ? renderCompact(header, result, rules, language)
+    : [renderFriendly(header, result, rules, language, notes), aiScoreLineOf(check)].join("\n");
   return {
     text,
     rules,

package/src/commands/ai-score.ts

@@ -0,0 +1,77 @@
+import { rulesOf } from "../custom/load.ts";
+import { resolveGenre } from "../resolve-genre.ts";
+import { aiScoreOfDocument, genreGroupOf } from "../ai-score/of-document.ts";
+import { aiScoreJson, renderAiScoreCompact, renderAiScoreFriendly } from "../ai-score/render.ts";
+import type { AiScore } from "../ai-score/score.ts";
+import { AI_SCORE_TEXT } from "../ai-score/text.ts";
+import { scoreViewOf } from "../ai-score/view.ts";
+import type { LengthUnit } from "../plugin.ts";
+import { documentFromSource } from "./read-document.ts";
+import { readSource, treeLanguage, type TreeContext } from "./tree.ts";
+
+/** Options whose value is the next argument. That value is not a file. */
+const VALUED: ReadonlySet<string> = new Set(["--genre", "--format", "--language"]);
+
+const FORMATS: ReadonlySet<string> = new Set(["text", "json"]);
+
+export const aiScoreTargets = (argv: readonly string[]): string[] =>
+  argv.slice(1).filter((arg, index, all) => !arg.startsWith("--") && !VALUED.has(all[index - 1] ?? ""));
+
+type Scored = { readonly path: string; readonly language: string; readonly genre: string; readonly unit: LengthUnit; readonly score: AiScore };
+
+/** One file read as lint reads it (part-of-speech tags on, as the human shares were measured), and scored. */
+const scoreFile = async (path: string, argv: readonly string[], context: TreeContext): Promise<Scored | undefined> => {
+  const source = await readSource(path, context);
+  if (source === undefined) return undefined;
+  const language = treeLanguage(path, source, argv, context);
+  const genre = resolveGenre(path, source, context.config, context.flag(argv, "--genre")).genre;
+  const { doc } = await documentFromSource(path, source, { language, genre }, context.config, true);
+  return { path, language, genre, unit: doc.lengthUnit, score: aiScoreOfDocument(doc, rulesOf(language, context.config), genre) };
+};
+
+const scoreAll = async (paths: readonly string[], argv: readonly string[], context: TreeContext): Promise<Scored[] | undefined> =>
+  paths.reduce<Promise<Scored[] | undefined>>(async (previous, path) => {
+    const earlier = await previous;
+    if (earlier === undefined) return undefined;
+    const next = await scoreFile(path, argv, context);
+    return next === undefined ? undefined : [...earlier, next];
+  }, Promise.resolve([]));
+
+const friendly = (scored: Scored, context: TreeContext): string[] =>
+  renderAiScoreFriendly(
+    scored.path,
+    scored.score,
+    scoreViewOf(scored.language, scored.unit, genreGroupOf(scored.genre), rulesOf(scored.language, context.config)),
+  );
+
+const render = (all: readonly Scored[], format: string, argv: readonly string[], context: TreeContext): string => {
+  if (format === "json")
+    return JSON.stringify(
+      all.map((scored) => ({ path: scored.path, language: scored.language, genre: scored.genre, ...aiScoreJson(scored.score) })),
+      null,
+      2,
+    );
+  if (argv.includes("--compact")) return all.map((scored) => renderAiScoreCompact(scored.path, scored.score)).join("\n");
+  return all.flatMap((scored, index) => [...(index > 0 ? [""] : []), ...friendly(scored, context)]).join("\n");
+};
+
+/**
+ * The AI-likeness quick score of each file: how many signs of generated text it shows that human documents of its genre
+ * rarely do, as low, medium or high. Measures; never judges who wrote it, so it ends with 0 once the files are read.
+ */
+export const runAiScore = async (targets: readonly string[], argv: readonly string[], context: TreeContext): Promise<number> => {
+  const text = AI_SCORE_TEXT[context.ui ?? "ja"];
+  const format = context.flag(argv, "--format") ?? (argv.includes("--json") ? "json" : "text");
+  if (!FORMATS.has(format)) {
+    console.error(text.unknownFormat(format));
+    return 1;
+  }
+  if (targets.length === 0) {
+    console.error(text.usage);
+    return 1;
+  }
+  const all = await scoreAll(targets, argv, context);
+  if (all === undefined) return 1;
+  console.log(render(all, format, argv, context));
+  return 0;
+};

package/src/commands/document-commands.ts

@@ -1,3 +1,4 @@
+import { aiScoreTargets, runAiScore } from "./ai-score.ts";
 import { citeTargets, runCite } from "./cite.ts";
 import { compareTargets, runCompare } from "./compare.ts";
 import { factsTargets, runFacts } from "./facts.ts";
@@ -16,4 +17,5 @@ export const DOCUMENT_COMMANDS: Readonly<Record<string, DocumentCommand>> = {
   compare: (argv, context) => runCompare(compareTargets(argv), argv, context),
   facts: (argv, context) => runFacts(factsTargets(argv), argv, context),
   outline: (argv, context) => runOutline(outlineTargets(argv), argv, context),
+  "ai-score": (argv, context) => runAiScore(aiScoreTargets(argv), argv, context),
 };

package/src/config/by-path-problems.ts

@@ -0,0 +1,17 @@
+import type { Config } from "./load.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+const TEXT: Texts<{ readonly unreadable: (where: string, value: string) => string }> = {
+  ja: {
+    unreadable: (where, value) =>
+      `${where}: by_path の ${value} は読めないので使いません。by_path は files と、genre・language・profile の組を並べます（- files: ["guides/**/*.md"] と genre: docs/manual）`,
+  },
+  en: {
+    unreadable: (where, value) =>
+      `${where}: cannot read ${value} under by_path, so it is not used. by_path is a list of files with genre, language or profile (- files: ["guides/**/*.md"] with genre: docs/manual)`,
+  },
+};
+
+/** chaff.yaml の by_path のうち、読めなかったもの。 */
+export const byPathProblems = (config: Pick<Config, "unreadableByPath" | "path">, ui: UiLanguage = "ja"): string[] =>
+  (config.unreadableByPath ?? []).map((value) => TEXT[ui].unreadable(config.path ?? "chaff.yaml", value));