prooflint 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Higashiyama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# prooflint
+
+Declarative text linter for Japanese/Markdown. Define custom rules in YAML — no JavaScript required.
+
+## textlint との棲み分け
+
+[textlint](https://textlint.github.io/) は汎用的な日本語ルール（ですます混在検出、二重否定、助詞の重複など）を提供する。prooflint はそれを置き換えるものではなく、**プロジェクト固有のルールを YAML で宣言的に定義する**ことに特化している。
+
+| | textlint | prooflint |
+|---|---|---|
+| 汎用日本語ルール | ✅ | — |
+| カスタムルール定義 | JS プラグイン必要 | **YAML のみ** |
+| 用語集管理 | 別途プラグイン | **組み込み** |
+| プロジェクト固有設定 | `.textlintrc` | `.prooflint.yml` |
+
+推奨: 汎用ルールは textlint、プロジェクト固有ルールは prooflint で併用する。
+
+## Install
+
+```bash
+npm install --save-dev prooflint
+# または
+npm install -g prooflint
+```
+
+## Quick Start
+
+```bash
+# 設定ファイルを生成
+prooflint init
+
+# Markdown ファイルを lint
+prooflint check "docs/**/*.md"
+
+# JSON 出力 (CI 用)
+prooflint check --format json "docs/**/*.md"
+```
+
+## Configuration
+
+`.prooflint.yml` に 3 種類のルールを定義できる。
+
+### pattern — 正規表現マッチング
+
+```yaml
+rules:
+  - id: no-desu-masu-mix
+    type: pattern
+    description: "である調とですます調の混在を検出"
+    severity: error
+    patterns:
+      - regex: "です。"
+        message: "である調で統一してください"
+      - regex: "ます。"
+        message: "である調で統一してください"
+```
+
+### dictionary — 用語の表記ゆれ統一
+
+```yaml
+rules:
+  - id: term-consistency
+    type: dictionary
+    description: "用語の表記ゆれを統一"
+    severity: warning
+    terms:
+      - prefer: "サーバー"
+        avoid: ["サーバ"]
+      - prefer: "インターフェース"
+        avoid: ["インタフェース", "インターフェイス"]
+```
+
+### structure — 文構造のチェック
+
+```yaml
+rules:
+  # 一文の長さを制限
+  - id: sentence-length
+    type: structure
+    severity: warning
+    target: sentence
+    max_chars: 120
+
+  # 見出しのレベルと末尾ピリオドを制限
+  - id: heading-style
+    type: structure
+    severity: error
+    target: heading
+    max_level: 3
+    no_period: true
+```
+
+## Severity
+
+| 値 | 意味 | 終了コード |
+|---|---|---|
+| `error` | 重大な問題。CI で失敗させる | 1 |
+| `warning` | 推奨事項の違反 | 0 |
+| `info` | 情報提供のみ | 0 |
+
+## Output
+
+```
+docs/guide.md
+     3:15  error  である調で統一してください  no-desu-masu-mix
+     7:1   warn   「サーバ」→「サーバー」に統一してください  term-consistency
+    12:5   error  見出しレベル4は上限（H3）を超えています  heading-style
+
+3 problems (2 errors, 1 warning)
+```
+
+## CLI Options
+
+```
+prooflint check [patterns...] [options]
+
+Options:
+  -c, --config <path>    設定ファイルのパス (デフォルト: .prooflint.yml)
+  -f, --format <format>  出力形式: console または json (デフォルト: console)
+
+prooflint init [options]
+
+Options:
+  --force    既存の設定ファイルを上書き
+```
+
+## Node.js API
+
+```typescript
+import { lintText, loadConfig } from 'prooflint'
+
+const config = loadConfig('./.prooflint.yml')
+const result = lintText(markdownContent, 'path/to/file.md', config)
+
+console.log(result.errorCount, result.warningCount)
+result.messages.forEach((msg) => {
+  console.log(`${msg.line}:${msg.column} [${msg.severity}] ${msg.message}`)
+})
+```
+
+## Requirements
+
+- Node.js >= 18
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,534 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync3, writeFileSync, existsSync } from "fs";
+import { resolve as resolve2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+import { glob } from "fs/promises";
+
+// src/config/loader.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import yaml from "js-yaml";
+
+// src/rules/types.ts
+import { z } from "zod";
+var SeveritySchema = z.enum(["error", "warning", "info"]);
+var PatternRuleSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("pattern"),
+  description: z.string().optional(),
+  severity: SeveritySchema.default("warning"),
+  patterns: z.array(
+    z.object({
+      regex: z.string().min(1),
+      message: z.string().min(1),
+      flags: z.string().optional()
+    })
+  ).min(1)
+});
+var DictionaryRuleSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("dictionary"),
+  description: z.string().optional(),
+  severity: SeveritySchema.default("warning"),
+  terms: z.array(
+    z.object({
+      prefer: z.string().min(1),
+      avoid: z.array(z.string().min(1)).min(1)
+    })
+  ).min(1)
+});
+var StructureRuleSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("structure"),
+  description: z.string().optional(),
+  severity: SeveritySchema.default("warning"),
+  target: z.enum(["sentence", "heading"]).default("sentence"),
+  max_chars: z.number().int().positive().optional(),
+  max_level: z.number().int().min(1).max(6).optional(),
+  no_period: z.boolean().optional()
+});
+var RuleSchema = z.discriminatedUnion("type", [
+  PatternRuleSchema,
+  DictionaryRuleSchema,
+  StructureRuleSchema
+]);
+var ContextSchema = z.object({
+  glossary: z.string().optional(),
+  style_guide: z.string().optional()
+}).optional();
+var ConfigSchema = z.object({
+  rules: z.array(RuleSchema).default([]),
+  context: ContextSchema
+});
+
+// src/config/loader.ts
+var CONFIG_FILE_NAMES = [".prooflint.yml", ".prooflint.yaml", "prooflint.config.yml"];
+function findConfigFile(cwd = process.cwd()) {
+  for (const name of CONFIG_FILE_NAMES) {
+    const candidate = resolve(cwd, name);
+    try {
+      readFileSync(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function loadConfig(configPath) {
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = yaml.load(raw);
+  const result = ConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+    throw new Error(`Invalid config at ${configPath}:
+${issues}`);
+  }
+  return result.data;
+}
+
+// src/rules/engine.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/parser/markdown.ts
+import { remark } from "remark";
+function parseMarkdown(content) {
+  const processor = remark();
+  const tree = processor.parse(content);
+  const textNodes = [];
+  const headings = [];
+  function visit(node) {
+    if (node.type === "heading") {
+      const text = extractText(node);
+      const position = node.position;
+      const textNode = {
+        text,
+        line: position?.start.line ?? 1,
+        column: position?.start.column ?? 1,
+        nodeType: "heading",
+        headingDepth: node.depth
+      };
+      headings.push(textNode);
+      textNodes.push(textNode);
+    } else if (node.type === "paragraph") {
+      const text = extractText(node);
+      const position = node.position;
+      textNodes.push({
+        text,
+        line: position?.start.line ?? 1,
+        column: position?.start.column ?? 1,
+        nodeType: "paragraph"
+      });
+    } else if (node.type === "listItem" || node.type === "blockquote") {
+      if ("children" in node) {
+        for (const child of node.children) {
+          visit(child);
+        }
+        return;
+      }
+    }
+    if ("children" in node && node.type !== "heading" && node.type !== "paragraph") {
+      for (const child of node.children) {
+        visit(child);
+      }
+    }
+  }
+  for (const child of tree.children) {
+    visit(child);
+  }
+  return { textNodes, headings, raw: content };
+}
+function extractText(node) {
+  if ("value" in node && typeof node.value === "string") {
+    return node.value;
+  }
+  if ("children" in node) {
+    return node.children.map(extractText).join("");
+  }
+  return "";
+}
+
+// src/rules/pattern.ts
+function applyPatternRule(rule, nodes) {
+  const messages = [];
+  for (const node of nodes) {
+    for (const pattern of rule.patterns) {
+      const flags = pattern.flags ?? "g";
+      let regex;
+      try {
+        regex = new RegExp(pattern.regex, flags.includes("g") ? flags : flags + "g");
+      } catch {
+        throw new Error(`Rule "${rule.id}": invalid regex "${pattern.regex}"`);
+      }
+      let match;
+      while ((match = regex.exec(node.text)) !== null) {
+        const beforeMatch = node.text.slice(0, match.index);
+        const newlines = (beforeMatch.match(/\n/g) ?? []).length;
+        const lastNewline = beforeMatch.lastIndexOf("\n");
+        const col = lastNewline === -1 ? node.column + match.index : match.index - lastNewline;
+        messages.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          message: pattern.message,
+          line: node.line + newlines,
+          column: col,
+          source: match[0]
+        });
+      }
+    }
+  }
+  return messages;
+}
+
+// src/rules/dictionary.ts
+function isWordBoundary(text, start, end) {
+  const charBefore = start > 0 ? text[start - 1] : null;
+  const charAfter = end < text.length ? text[end] : null;
+  if (charAfter === "\u30FC" || charAfter === "\u301C") return false;
+  return true;
+}
+function applyDictionaryRule(rule, nodes) {
+  const messages = [];
+  for (const node of nodes) {
+    for (const term of rule.terms) {
+      for (const avoidWord of term.avoid) {
+        const preferStartsWithAvoid = term.prefer.startsWith(avoidWord);
+        const escaped = avoidWord.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const regex = new RegExp(escaped, "g");
+        let match;
+        while ((match = regex.exec(node.text)) !== null) {
+          const matchStart = match.index;
+          const matchEnd = matchStart + avoidWord.length;
+          if (preferStartsWithAvoid && !isWordBoundary(node.text, matchStart, matchEnd)) {
+            continue;
+          }
+          const beforeMatch = node.text.slice(0, matchStart);
+          const newlines = (beforeMatch.match(/\n/g) ?? []).length;
+          const lastNewline = beforeMatch.lastIndexOf("\n");
+          const col = lastNewline === -1 ? node.column + matchStart : matchStart - lastNewline;
+          messages.push({
+            ruleId: rule.id,
+            severity: rule.severity,
+            message: `\u300C${avoidWord}\u300D\u2192\u300C${term.prefer}\u300D\u306B\u7D71\u4E00\u3057\u3066\u304F\u3060\u3055\u3044`,
+            line: node.line + newlines,
+            column: col,
+            source: match[0]
+          });
+        }
+      }
+    }
+  }
+  return messages;
+}
+
+// src/parser/sentence.ts
+function splitSentences(text, startLine, startColumn) {
+  const sentences = [];
+  const lines = text.split("\n");
+  let currentLine = startLine;
+  let currentCol = startColumn;
+  let buffer = "";
+  let bufferLine = currentLine;
+  let bufferCol = currentCol;
+  for (let li = 0; li < lines.length; li++) {
+    const line = lines[li] ?? "";
+    let charPos = li === 0 ? startColumn - 1 : 0;
+    for (let ci = 0; ci < line.length; ci++) {
+      const ch = line[ci] ?? "";
+      buffer += ch;
+      charPos++;
+      if (isSentenceEnd(ch, line, ci)) {
+        const trimmed2 = buffer.trim();
+        if (trimmed2.length > 0) {
+          sentences.push({ text: trimmed2, line: bufferLine, column: bufferCol });
+        }
+        buffer = "";
+        bufferLine = currentLine;
+        bufferCol = charPos + 1;
+      }
+    }
+    if (li < lines.length - 1) {
+      buffer += "\n";
+      currentLine++;
+      currentCol = 1;
+      if (buffer.trim() === "") {
+        bufferLine = currentLine;
+        bufferCol = 1;
+        buffer = "";
+      }
+    }
+  }
+  const trimmed = buffer.trim();
+  if (trimmed.length > 0) {
+    sentences.push({ text: trimmed, line: bufferLine, column: bufferCol });
+  }
+  return sentences;
+}
+function isSentenceEnd(ch, line, index) {
+  if ("\u3002\uFF01\uFF1F".includes(ch)) return true;
+  if (ch === "." || ch === "!" || ch === "?") {
+    const next = line[index + 1];
+    if (next === void 0 || next === " " || next === "	") return true;
+  }
+  return false;
+}
+
+// src/rules/structure.ts
+function applyStructureRule(rule, nodes) {
+  const messages = [];
+  const target = rule.target ?? "sentence";
+  if (target === "heading") {
+    return applyHeadingRules(rule, nodes);
+  }
+  for (const node of nodes) {
+    if (node.nodeType === "heading") continue;
+    if (rule.max_chars !== void 0) {
+      const sentences = splitSentences(node.text, node.line, node.column);
+      for (const sentence of sentences) {
+        if (sentence.text.length > rule.max_chars) {
+          messages.push({
+            ruleId: rule.id,
+            severity: rule.severity,
+            message: `\u4E00\u6587\u304C${sentence.text.length}\u6587\u5B57\u3067\u3059\uFF08\u4E0A\u9650: ${rule.max_chars}\u6587\u5B57\uFF09`,
+            line: sentence.line,
+            column: sentence.column,
+            source: sentence.text.slice(0, 40) + (sentence.text.length > 40 ? "..." : "")
+          });
+        }
+      }
+    }
+  }
+  return messages;
+}
+function applyHeadingRules(rule, nodes) {
+  const messages = [];
+  for (const node of nodes) {
+    if (node.nodeType !== "heading") continue;
+    if (rule.max_level !== void 0 && node.headingDepth !== void 0) {
+      if (node.headingDepth > rule.max_level) {
+        messages.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          message: `\u898B\u51FA\u3057\u30EC\u30D9\u30EB${node.headingDepth}\u306F\u4E0A\u9650\uFF08H${rule.max_level}\uFF09\u3092\u8D85\u3048\u3066\u3044\u307E\u3059`,
+          line: node.line,
+          column: node.column,
+          source: node.text
+        });
+      }
+    }
+    if (rule.no_period === true) {
+      if (/[。．.]$/.test(node.text.trim())) {
+        messages.push({
+          ruleId: rule.id,
+          severity: rule.severity,
+          message: "\u898B\u51FA\u3057\u306E\u672B\u5C3E\u306B\u53E5\u70B9\u3092\u4F7F\u308F\u306A\u3044\u3067\u304F\u3060\u3055\u3044",
+          line: node.line,
+          column: node.column,
+          source: node.text
+        });
+      }
+    }
+  }
+  return messages;
+}
+
+// src/rules/engine.ts
+function lintText(content, filePath, config) {
+  const doc = parseMarkdown(content);
+  const messages = [];
+  for (const rule of config.rules) {
+    switch (rule.type) {
+      case "pattern":
+        messages.push(...applyPatternRule(rule, doc.textNodes));
+        break;
+      case "dictionary":
+        messages.push(...applyDictionaryRule(rule, doc.textNodes));
+        break;
+      case "structure":
+        messages.push(...applyStructureRule(rule, doc.textNodes));
+        break;
+    }
+  }
+  messages.sort((a, b) => a.line !== b.line ? a.line - b.line : a.column - b.column);
+  return {
+    filePath,
+    messages,
+    errorCount: messages.filter((m) => m.severity === "error").length,
+    warningCount: messages.filter((m) => m.severity === "warning").length,
+    infoCount: messages.filter((m) => m.severity === "info").length
+  };
+}
+function lintFile(filePath, config) {
+  const content = readFileSync2(filePath, "utf-8");
+  return lintText(content, filePath, config);
+}
+
+// src/reporter/console.ts
+import chalk from "chalk";
+function severityLabel(severity) {
+  switch (severity) {
+    case "error":
+      return chalk.red("error");
+    case "warning":
+      return chalk.yellow("warn ");
+    case "info":
+      return chalk.blue("info ");
+  }
+}
+function formatMessage(msg) {
+  const location = chalk.dim(`${String(msg.line).padStart(4)}:${String(msg.column).padEnd(4)}`);
+  const sev = severityLabel(msg.severity);
+  const text = msg.message;
+  const rule = chalk.dim(msg.ruleId);
+  return `  ${location}  ${sev}  ${text}  ${rule}`;
+}
+function formatConsole(results) {
+  const lines = [];
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalInfos = 0;
+  for (const result of results) {
+    if (result.messages.length === 0) continue;
+    lines.push("");
+    lines.push(chalk.underline(result.filePath));
+    for (const msg of result.messages) {
+      lines.push(formatMessage(msg));
+    }
+    totalErrors += result.errorCount;
+    totalWarnings += result.warningCount;
+    totalInfos += result.infoCount;
+  }
+  const total = totalErrors + totalWarnings + totalInfos;
+  if (total === 0) {
+    lines.push(chalk.green("\n0 problems"));
+    return lines.join("\n");
+  }
+  const parts = [];
+  if (totalErrors > 0) parts.push(chalk.red(`${totalErrors} error${totalErrors > 1 ? "s" : ""}`));
+  if (totalWarnings > 0) parts.push(chalk.yellow(`${totalWarnings} warning${totalWarnings > 1 ? "s" : ""}`));
+  if (totalInfos > 0) parts.push(chalk.blue(`${totalInfos} info`));
+  lines.push("");
+  lines.push(`${total} problem${total > 1 ? "s" : ""} (${parts.join(", ")})`);
+  return lines.join("\n");
+}
+function hasErrors(results) {
+  return results.some((r) => r.errorCount > 0);
+}
+
+// src/reporter/json.ts
+function formatJson(results) {
+  const output = {
+    results,
+    summary: {
+      totalFiles: results.length,
+      filesWithProblems: results.filter((r) => r.messages.length > 0).length,
+      totalErrors: results.reduce((s, r) => s + r.errorCount, 0),
+      totalWarnings: results.reduce((s, r) => s + r.warningCount, 0),
+      totalInfos: results.reduce((s, r) => s + r.infoCount, 0)
+    }
+  };
+  return JSON.stringify(output, null, 2);
+}
+
+// src/cli.ts
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var pkgPath = resolve2(__dirname, "../package.json");
+var pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+var INIT_TEMPLATE = `rules:
+  # \u7528\u8A9E\u306E\u8868\u8A18\u3086\u308C\u3092\u7D71\u4E00
+  - id: term-consistency
+    type: dictionary
+    description: "\u7528\u8A9E\u306E\u8868\u8A18\u3086\u308C\u3092\u7D71\u4E00"
+    severity: warning
+    terms:
+      - prefer: "\u30B5\u30FC\u30D0\u30FC"
+        avoid: ["\u30B5\u30FC\u30D0"]
+      - prefer: "\u30E6\u30FC\u30B6\u30FC"
+        avoid: ["\u30E6\u30FC\u30B6"]
+
+  # \u4E00\u6587\u306E\u9577\u3055\u3092\u5236\u9650
+  - id: sentence-length
+    type: structure
+    description: "\u4E00\u6587\u306E\u9577\u3055\u3092\u5236\u9650"
+    severity: warning
+    target: sentence
+    max_chars: 120
+
+  # \u898B\u51FA\u3057\u306E\u30B9\u30BF\u30A4\u30EB\u3092\u7D71\u4E00
+  - id: heading-style
+    type: structure
+    description: "\u898B\u51FA\u3057\u306E\u30EC\u30D9\u30EB\u3068\u672B\u5C3E\u30D4\u30EA\u30AA\u30C9\u3092\u5236\u9650"
+    severity: error
+    target: heading
+    max_level: 4
+    no_period: true
+`;
+var program = new Command();
+program.name("prooflint").description("Declarative text linter for Markdown \u2014 define rules in YAML").version(pkg.version);
+program.command("init").description("Create a .prooflint.yml config file in the current directory").option("--force", "Overwrite existing config file").action((options) => {
+  const target = resolve2(process.cwd(), ".prooflint.yml");
+  if (existsSync(target) && !options.force) {
+    console.error(".prooflint.yml already exists. Use --force to overwrite.");
+    process.exit(1);
+  }
+  writeFileSync(target, INIT_TEMPLATE, "utf-8");
+  console.log(`Created ${target}`);
+});
+program.command("check [patterns...]").description("Lint Markdown files matching the given glob patterns").option("-c, --config <path>", "Path to config file").option("-f, --format <format>", "Output format: console or json", "console").action(async (patterns, options) => {
+  const cwd = process.cwd();
+  let config;
+  try {
+    if (options.config) {
+      config = loadConfig(resolve2(cwd, options.config));
+    } else {
+      const configPath = findConfigFile(cwd);
+      if (!configPath) {
+        console.error("No .prooflint.yml found. Run `prooflint init` to create one.");
+        process.exit(1);
+      }
+      config = loadConfig(configPath);
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const targetPatterns = patterns.length > 0 ? patterns : ["**/*.md"];
+  const filePaths = [];
+  for (const pattern of targetPatterns) {
+    try {
+      for await (const entry of glob(pattern, { cwd })) {
+        const abs = resolve2(cwd, entry);
+        if (!filePaths.includes(abs)) filePaths.push(abs);
+      }
+    } catch {
+      const abs = resolve2(cwd, pattern);
+      if (existsSync(abs) && !filePaths.includes(abs)) filePaths.push(abs);
+    }
+  }
+  if (filePaths.length === 0) {
+    console.log("No files found.");
+    process.exit(0);
+  }
+  const results = filePaths.map((fp) => {
+    try {
+      return lintFile(fp, config);
+    } catch (err) {
+      console.error(`Error processing ${fp}: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  });
+  const format = options.format ?? "console";
+  if (format === "json") {
+    console.log(formatJson(results));
+  } else {
+    const output = formatConsole(results);
+    console.log(output);
+  }
+  if (hasErrors(results)) {
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.js.map