humanizer-lint 0.0.0-stage → 0.2.3

package/rules/en-slop.json

@@ -0,0 +1,49 @@
+{
+  "language": "en",
+  "patterns": [
+    {"id":"EN001","type":"SLOP_PHRASE","pattern":"\\bdelve\\b","fixInstruction":"Name the exact action or subject instead."},
+    {"id":"EN002","type":"SLOP_PHRASE","pattern":"\\btapestry\\b","fixInstruction":"Replace the metaphor with a concrete description."},
+    {"id":"EN003","type":"SLOP_PHRASE","pattern":"\\btestament\\b","fixInstruction":"State the evidence directly."},
+    {"id":"EN004","type":"SLOP_PHRASE","pattern":"\\bunderscore(?:s|d|ing)?\\b","fixInstruction":"State what the evidence shows."},
+    {"id":"EN005","type":"SLOP_PHRASE","pattern":"\\bpivotal\\b","fixInstruction":"Describe the actual consequence without inflated significance."},
+    {"id":"EN006","type":"SLOP_PHRASE","pattern":"\\bcrucial\\b","fixInstruction":"Explain why the item matters in this context."},
+    {"id":"EN007","type":"SLOP_PHRASE","pattern":"\\bfoster(?:s|ed|ing)?\\b","fixInstruction":"Name the concrete behavior or outcome."},
+    {"id":"EN008","type":"SLOP_PHRASE","pattern":"\\blandscape\\b","fixInstruction":"Name the field or conditions directly."},
+    {"id":"EN009","type":"SLOP_PHRASE","pattern":"\\brealm\\b","fixInstruction":"Name the actual domain."},
+    {"id":"EN010","type":"SLOP_PHRASE","pattern":"\\bbeacon\\b","fixInstruction":"Replace the metaphor with a supported fact."},
+    {"id":"EN011","type":"SLOP_PHRASE","pattern":"\\bsymphony\\b","fixInstruction":"Describe the relationship without a decorative metaphor."},
+    {"id":"EN012","type":"SLOP_PHRASE","pattern":"\\bunlock(?:s|ed|ing)?\\b","fixInstruction":"Name what becomes possible and how."},
+    {"id":"EN013","type":"SLOP_PHRASE","pattern":"\\belevate(?:s|d|ing)?\\b","fixInstruction":"State the measurable improvement."},
+    {"id":"EN014","type":"SLOP_PHRASE","pattern":"\\bunleash(?:es|ed|ing)?\\b","fixInstruction":"Describe the actual capability or result."},
+    {"id":"EN015","type":"SLOP_PHRASE","pattern":"\\bgame[- ]changer\\b","fixInstruction":"State the specific change and its effect."},
+    {"id":"EN016","type":"SLOP_PHRASE","pattern":"\\bparadigm shift\\b","fixInstruction":"Describe what changed in concrete terms."},
+    {"id":"EN017","type":"SLOP_PHRASE","pattern":"\\bmoreover\\b","fixInstruction":"Connect the sentences by their actual relationship."},
+    {"id":"EN018","type":"SLOP_PHRASE","pattern":"\\bfurthermore\\b","fixInstruction":"Connect the sentences by their actual relationship."},
+    {"id":"EN019","type":"SLOP_PHRASE","pattern":"\\bin conclusion\\b","fixInstruction":"End on the final concrete point."},
+    {"id":"EN020","type":"SLOP_PHRASE","pattern":"\\bit is important to note\\b","fixInstruction":"Remove the announcement and state the fact."},
+    {"id":"EN021","type":"SLOP_PHRASE","pattern":"\\bit is worth noting\\b","fixInstruction":"Remove the announcement and state the fact."},
+    {"id":"EN022","type":"SLOP_PHRASE","pattern":"\\bin today['’]s fast-paced\\b","fixInstruction":"Name the current condition precisely."},
+    {"id":"EN023","type":"SLOP_PHRASE","pattern":"\\bever-evolving\\b","fixInstruction":"Name the change and its time frame."},
+    {"id":"EN024","type":"SLOP_PHRASE","pattern":"\\bseamless(?:ly)?\\b","fixInstruction":"Describe the missing step, delay, or transition precisely."},
+    {"id":"EN025","type":"SLOP_PHRASE","pattern":"\\brobust\\b","fixInstruction":"Name the failure mode or capacity the system handles."},
+    {"id":"EN026","type":"SLOP_PHRASE","pattern":"\\bcutting[- ]edge\\b","fixInstruction":"Name the specific technical capability."},
+    {"id":"EN027","type":"SLOP_PHRASE","pattern":"\\brevolutionary\\b","fixInstruction":"Describe the concrete difference without promotional language."},
+    {"id":"EN028","type":"SLOP_PHRASE","pattern":"\\bnext[- ]generation\\b","fixInstruction":"Name the new behavior or version."},
+    {"id":"EN029","type":"SLOP_PHRASE","pattern":"\\btransformative\\b","fixInstruction":"State what changed and for whom."},
+    {"id":"EN030","type":"SLOP_PHRASE","pattern":"\\bjourney\\b","fixInstruction":"Name the process or sequence directly."},
+    {"id":"EN031","type":"SLOP_PHRASE","pattern":"\\bempower(?:s|ed|ing)?\\b","fixInstruction":"Name the action users can now take."},
+    {"id":"EN032","type":"SLOP_PHRASE","pattern":"\\bharness(?:es|ed|ing)?\\b","fixInstruction":"State how the resource is used."},
+    {"id":"EN033","type":"SLOP_PHRASE","pattern":"\\bnavigate(?:s|d|ing)? the complexities\\b","fixInstruction":"Name the specific difficulty and response."},
+    {"id":"EN034","type":"SLOP_PHRASE","pattern":"\\bholistic approach\\b","fixInstruction":"List the parts included in the approach."},
+    {"id":"EN035","type":"SLOP_PHRASE","pattern":"\\bvaluable insights\\b","fixInstruction":"State the finding itself."},
+    {"id":"EN036","type":"SLOP_PHRASE","pattern":"\\bplays? a (?:key|vital|crucial) role\\b","fixInstruction":"Describe the action or consequence directly."},
+    {"id":"EN037","type":"SLOP_PHRASE","pattern":"\\bthe future looks bright\\b","fixInstruction":"End on a supported plan or concrete fact."},
+    {"id":"EN038","type":"SLOP_PHRASE","pattern":"\\bexciting times (?:lie|are) ahead\\b","fixInstruction":"Replace optimism with a supported next step."},
+    {"id":"EN039","type":"SLOP_PHRASE","pattern":"\\bstands as a testament\\b","fixInstruction":"State the evidence directly."},
+    {"id":"EN040","type":"SLOP_PHRASE","pattern":"\\bmarking a (?:pivotal|significant) moment\\b","fixInstruction":"State what happened and its direct effect."},
+    {"id":"EN041","type":"STRUCTURAL_CLICHE","pattern":",\\s+[a-z]+ing\\s+(?:a|the|its|their|this|that)\\s+[a-z]+","fixInstruction":"Split or rewrite the participial tail as a supported clause."},
+    {"id":"EN042","type":"STRUCTURAL_CLICHE","pattern":"\\bnot only[\\s\\S]{0,100}?but also\\b","fixInstruction":"State both claims directly without the binary formula."},
+    {"id":"EN043","type":"STRUCTURAL_CLICHE","pattern":"\\bit['’]s not just about[\\s\\S]{0,100}?it['’]s about\\b","fixInstruction":"State the positive claim directly."},
+    {"id":"EN044","type":"STRUCTURAL_CLICHE","pattern":"(?:—|--)","maxOccurrences":1,"perWords":250,"fixInstruction":"Replace repeated dashes with the punctuation that matches the relationship."}
+  ]
+}

package/rules/id-slop.json

@@ -0,0 +1,57 @@
+{
+  "language": "id",
+  "patterns": [
+    {"id":"ID001","type":"SLOP_PHRASE","pattern":"\\bdi era digital\\b","fixInstruction":"Mulai langsung dari subjek atau fakta konkret."},
+    {"id":"ID002","type":"SLOP_PHRASE","pattern":"\\bdi tengah pesatnya\\b","fixInstruction":"Hapus pembuka umum dan sebutkan perubahan yang dimaksud."},
+    {"id":"ID003","type":"SLOP_PHRASE","pattern":"\\btidak dapat dipungkiri\\b","fixInstruction":"Nyatakan klaim secara langsung tanpa pembuka klise."},
+    {"id":"ID004","type":"SLOP_PHRASE","pattern":"\\btak dapat dipungkiri\\b","fixInstruction":"Nyatakan klaim secara langsung tanpa pembuka klise."},
+    {"id":"ID005","type":"SLOP_PHRASE","pattern":"\\bpenting untuk diingat\\b","fixInstruction":"Hapus penanda kepentingan dan tulis fakta yang perlu diingat."},
+    {"id":"ID006","type":"SLOP_PHRASE","pattern":"\\bperlu dicatat bahwa\\b","fixInstruction":"Hapus pengantar dan mulai dari informasi intinya."},
+    {"id":"ID007","type":"SLOP_PHRASE","pattern":"\\bsebagai kesimpulan\\b","fixInstruction":"Hapus kesimpulan generik atau tutup dengan fakta terakhir."},
+    {"id":"ID008","type":"SLOP_PHRASE","pattern":"\\bsecara keseluruhan\\b","fixInstruction":"Ganti rangkuman umum dengan kesimpulan yang spesifik."},
+    {"id":"ID009","type":"SLOP_PHRASE","pattern":"\\blebih lanjut\\s*,","fixInstruction":"Hubungkan kalimat berdasarkan maknanya, bukan transisi otomatis."},
+    {"id":"ID010","type":"SLOP_PHRASE","pattern":"\\bnamun demikian\\s*,","fixInstruction":"Gunakan kontras langsung jika memang ada pertentangan."},
+    {"id":"ID011","type":"SLOP_PHRASE","pattern":"\\bselain itu\\s*,","maxOccurrences":1,"perWords":300,"fixInstruction":"Pertahankan paling banyak satu kali atau gunakan hubungan yang lebih spesifik."},
+    {"id":"ID012","type":"SLOP_PHRASE","pattern":"\\bmari kita bahas\\b","fixInstruction":"Mulai pembahasan tanpa mengumumkannya."},
+    {"id":"ID013","type":"SLOP_PHRASE","pattern":"\\bmenyelami lebih dalam\\b","fixInstruction":"Sebutkan aspek yang dianalisis secara langsung."},
+    {"id":"ID014","type":"SLOP_PHRASE","pattern":"\\bbukan sekadar\\b","fixInstruction":"Nyatakan fungsi atau manfaat utama secara langsung."},
+    {"id":"ID015","type":"SLOP_PHRASE","pattern":"\\btidak hanya[\\s\\S]{0,80}?tetapi juga\\b","maxOccurrences":1,"perWords":300,"fixInstruction":"Pisahkan kedua klaim atau nyatakan hubungan tanpa formula biner."},
+    {"id":"ID016","type":"SLOP_PHRASE","pattern":"\\bhal ini menunjukkan bahwa\\b","fixInstruction":"Sebutkan bukti dan kesimpulannya secara langsung."},
+    {"id":"ID017","type":"SLOP_PHRASE","pattern":"\\bdapat disimpulkan bahwa\\b","fixInstruction":"Tulis kesimpulan tanpa frasa pengantar."},
+    {"id":"ID018","type":"SLOP_PHRASE","pattern":"\\bseiring dengan perkembangan zaman\\b","fixInstruction":"Sebutkan periode atau perubahan yang konkret."},
+    {"id":"ID019","type":"SLOP_PHRASE","pattern":"\\bdi zaman yang serba\\b","fixInstruction":"Ganti generalisasi dengan konteks yang nyata."},
+    {"id":"ID020","type":"SLOP_PHRASE","pattern":"\\bdi dunia yang semakin\\b","fixInstruction":"Sebutkan kondisi yang benar-benar berubah."},
+    {"id":"ID021","type":"SLOP_PHRASE","pattern":"\\bdalam lanskap yang\\b","fixInstruction":"Sebutkan bidang atau keadaan secara langsung."},
+    {"id":"ID022","type":"SLOP_PHRASE","pattern":"\\bmemainkan peran penting\\b","fixInstruction":"Jelaskan tindakan atau dampak konkretnya."},
+    {"id":"ID023","type":"SLOP_PHRASE","pattern":"\\bmenjadi kunci utama\\b","fixInstruction":"Jelaskan syarat atau mekanisme yang sebenarnya."},
+    {"id":"ID024","type":"SLOP_PHRASE","pattern":"\\blangkah yang tepat\\b","fixInstruction":"Sebutkan langkah yang dimaksud."},
+    {"id":"ID025","type":"SLOP_PHRASE","pattern":"\\blangkah strategis\\b","fixInstruction":"Sebutkan tindakan dan hasil yang dituju."},
+    {"id":"ID026","type":"SLOP_PHRASE","pattern":"\\bsolusi inovatif\\b","fixInstruction":"Jelaskan cara kerja solusi tanpa label promosi."},
+    {"id":"ID027","type":"SLOP_PHRASE","pattern":"\\bpendekatan holistik\\b","fixInstruction":"Sebutkan bagian yang digabungkan oleh pendekatan tersebut."},
+    {"id":"ID028","type":"SLOP_PHRASE","pattern":"\\bberbagai aspek\\b","fixInstruction":"Sebutkan aspek yang relevan."},
+    {"id":"ID029","type":"SLOP_PHRASE","pattern":"\\bdampak yang signifikan\\b","fixInstruction":"Jelaskan dampak dan ukurannya jika tersedia."},
+    {"id":"ID030","type":"SLOP_PHRASE","pattern":"\\bhasil yang optimal\\b","fixInstruction":"Nyatakan hasil yang dapat diamati atau diukur."},
+    {"id":"ID031","type":"SLOP_PHRASE","pattern":"\\bsecara efektif dan efisien\\b","fixInstruction":"Jelaskan perbaikan waktu, biaya, atau mutu secara spesifik."},
+    {"id":"ID032","type":"SLOP_PHRASE","pattern":"\\bpada akhirnya\\s*,","fixInstruction":"Tutup langsung dengan akibat atau keputusan akhir."},
+    {"id":"ID033","type":"SLOP_PHRASE","pattern":"\\bdengan demikian\\s*,","fixInstruction":"Nyatakan akibatnya tanpa transisi otomatis."},
+    {"id":"ID034","type":"SLOP_PHRASE","pattern":"\\boleh karena itu\\s*,","fixInstruction":"Hubungkan sebab dan akibat secara langsung."},
+    {"id":"ID035","type":"SLOP_PHRASE","pattern":"\\bpada dasarnya\\s*,","fixInstruction":"Hapus pengantar dan nyatakan pokoknya."},
+    {"id":"ID036","type":"SLOP_PHRASE","pattern":"\\bperlu dipahami bahwa\\b","fixInstruction":"Mulai dari informasi yang perlu dipahami."},
+    {"id":"ID037","type":"SLOP_PHRASE","pattern":"\\btentu saja\\s*,","fixInstruction":"Hapus penegasan otomatis jika tidak menambah makna."},
+    {"id":"ID038","type":"SLOP_PHRASE","pattern":"\\btanpa diragukan lagi\\b","fixInstruction":"Ganti kepastian retoris dengan bukti atau klaim langsung."},
+    {"id":"ID039","type":"SLOP_PHRASE","pattern":"\\bmembuka peluang baru\\b","fixInstruction":"Sebutkan peluang yang benar-benar tersedia."},
+    {"id":"ID040","type":"SLOP_PHRASE","pattern":"\\bmendorong pertumbuhan berkelanjutan\\b","fixInstruction":"Sebutkan mekanisme dan indikator pertumbuhannya."},
+    {"id":"ID041","type":"DEFINITIONAL_OPENING","scope":"paragraph-start","pattern":"^[A-ZÀ-ÖØ-Þ][\\p{L}\\p{N}_\\s'\"-]{2,80}\\s+adalah\\s+(?:sebuah|suatu|proses|metode|sistem|cara|langkah|pendekatan)\\b","fixInstruction":"Ganti definisi kaku dengan fungsi, contoh, atau fakta konkret."},
+    {"id":"ID042","type":"DEFINITIONAL_OPENING","scope":"paragraph-start","pattern":"^Dalam (?:konteks|dunia|ranah) [\\p{L}\\p{N}\\s-]+,","fixInstruction":"Mulai langsung dari subjek yang dibahas."}
+  ],
+  "morphology": {
+    "nominalizationPattern": "^(?:peng|pen|pem|peny|pe|ke)[a-z]{5,}an$",
+    "nominalizationWhitelist": ["perusahaan","pekerjaan","pertanyaan","pernyataan","perjalanan","permainan","peralatan","peraturan","perubahan","perbedaan","persamaan","pertemuan","pernikahan","pendidikan","pemerintahan","pembangunan","pengalaman","pengetahuan","pendapatan","pengeluaran","kegiatan","kesehatan","kebutuhan","keputusan","keamanan","kecepatan","kekuatan","kesempatan","kesalahan","ketentuan","keuangan","kebijakan","kehidupan","kemampuan","kenyataan","kepercayaan","keterangan","kewajiban","kerusakan","keuntungan","kerugian","kemajuan","kehadiran","kebiasaan"],
+    "nominalizationMaxRatio": 0.045,
+    "passivePattern": "^di[a-z]{4,}(?:kan|i)$",
+    "loanwordExclusionPattern": "^(?:diskusi|dinamika|dimensi|direktori|distribusi|divisi|disiplin|digital|diagnosa|diagram|dialek|dialog|diameter|dilema|dinamis|diplomasi|direktur|disertasi|diskon|divergensi|diversifikasi|dedikasi|definisi|delegasi|demokrasi|depresi|deskripsi|destinasi|deteksi|deviasi|dominasi|donasi|durasi)$",
+    "loanwordSuffixExclusionPattern": "(?:asi|isi|ensi|uksi|logi|nomi|grafi|metri|krasi|fobi|pati|terapi|stasi|nasti)$",
+    "passiveMaxRatio": 0.035,
+    "subordinateOpeningPattern": "^(?:Dengan menggunakan|Untuk mencapai|Dalam rangka|Melalui pendekatan|Guna memastikan|Dengan memanfaatkan)\\b"
+  }
+}

package/scripts/analyze.mjs

@@ -0,0 +1,408 @@
+#!/usr/bin/env node
+import { readFile, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { sanitizeMarkdown } from './utils/sanitizer.mjs';
+import { calculateMetrics, mean, punctuationRates } from './utils/metrics.mjs';
+import { tokenizeText } from './utils/tokenizer.mjs';
+
+const RULES = {
+  id: JSON.parse(readFileSync(new URL('../rules/id-slop.json', import.meta.url), 'utf8')),
+  en: JSON.parse(readFileSync(new URL('../rules/en-slop.json', import.meta.url), 'utf8')),
+};
+const DEFAULT_PROFILE = JSON.parse(readFileSync(new URL('../profiles/default-human.json', import.meta.url), 'utf8'));
+const ID_WORDS = new Set(['yang', 'dan', 'di', 'ini', 'untuk', 'dengan', 'dari', 'pada', 'dalam', 'tidak', 'akan', 'atau', 'juga', 'oleh', 'adalah', 'sebagai', 'bahwa', 'dapat', 'karena', 'tersebut']);
+const EN_WORDS = new Set(['the', 'and', 'of', 'to', 'in', 'is', 'that', 'for', 'it', 'with', 'as', 'on', 'are', 'this', 'by', 'be', 'at', 'or', 'from', 'an']);
+
+function round(value, places = 4) {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+
+function detectLanguage(words) {
+  let id = 0;
+  let en = 0;
+  for (const word of words) {
+    if (ID_WORDS.has(word)) id += 1;
+    if (EN_WORDS.has(word)) en += 1;
+  }
+  return en > id ? 'en' : 'id';
+}
+
+function locationFor(sentence) {
+  return `Paragraph ${sentence.paragraphIndex}, Sentence ${sentence.sentenceIndex}`;
+}
+
+function regexFor(pattern) {
+  return new RegExp(pattern, 'giu');
+}
+
+function patternViolations(tokenized, rules, wordCount) {
+  const violations = [];
+  for (const rule of rules.patterns) {
+    const candidates = [];
+    const sentences = rule.scope === 'paragraph-start'
+      ? tokenized.paragraphs.map((paragraph) => paragraph.sentences[0]).filter(Boolean)
+      : tokenized.sentences;
+
+    for (const sentence of sentences) {
+      const regex = regexFor(rule.pattern);
+      for (const match of sentence.text.matchAll(regex)) candidates.push({ sentence, match: match[0] });
+    }
+
+    const allowed = rule.maxOccurrences == null
+      ? 0
+      : rule.maxOccurrences * Math.max(1, Math.ceil(wordCount / (rule.perWords || wordCount || 1)));
+    for (const candidate of candidates.slice(allowed)) {
+      violations.push({
+        type: rule.type,
+        ruleId: rule.id,
+        location: locationFor(candidate.sentence),
+        match: candidate.match,
+        fixInstruction: rule.fixInstruction,
+      });
+    }
+  }
+  return violations;
+}
+
+function monotonyViolations(tokenized) {
+  const violations = [];
+  for (const paragraph of tokenized.paragraphs) {
+    for (let index = 0; index <= paragraph.sentences.length - 3; index += 1) {
+      const window = paragraph.sentences.slice(index, index + 3);
+      const lengths = window.map((sentence) => sentence.wordCount);
+      if (Math.abs(lengths[1] - lengths[0]) <= 3 && Math.abs(lengths[2] - lengths[1]) <= 3) {
+        violations.push({
+          type: 'MONOTONOUS_RHYTHM',
+          location: `Paragraph ${paragraph.paragraphIndex}, Sentences ${window[0].sentenceIndex}-${window[2].sentenceIndex}`,
+          lengths,
+          fixInstruction: `Sentence lengths are uniform (${lengths.join(', ')} words). Split one sentence into a short statement or merge two into a longer clause.`,
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+function structuralViolations(tokenized, metrics) {
+  const violations = [];
+  if (metrics.wordCount >= 150 && metrics.compressionRatio < 0.42) {
+    violations.push({
+      type: 'LOW_ENTROPY_REPETITION',
+      location: 'Whole text',
+      fixInstruction: 'Remove repeated templates and vary concrete sentence structures.',
+    });
+  }
+
+  for (let index = 0; index <= tokenized.paragraphs.length - 3; index += 1) {
+    const window = tokenized.paragraphs.slice(index, index + 3);
+    const counts = window.map((paragraph) => paragraph.sentences.length);
+    if (counts[0] > 0 && counts.every((count) => count === counts[0])) {
+      violations.push({
+        type: 'SYMMETRIC_PARAGRAPHS',
+        location: `Paragraphs ${window[0].paragraphIndex}-${window[2].paragraphIndex}`,
+        counts,
+        fixInstruction: 'Merge or split a paragraph where the content supports a different rhythm.',
+      });
+    }
+  }
+
+  for (const paragraph of tokenized.paragraphs) {
+    const starters = new Map();
+    for (const sentence of paragraph.sentences) {
+      const starter = sentence.words[0];
+      if (!starter) continue;
+      const group = starters.get(starter) ?? [];
+      group.push(sentence.sentenceIndex);
+      starters.set(starter, group);
+    }
+    for (const [starter, indexes] of starters) {
+      if (indexes.length >= 3) {
+        violations.push({
+          type: 'REPETITIVE_STARTERS',
+          location: `Paragraph ${paragraph.paragraphIndex}, Sentences ${indexes.join(', ')}`,
+          match: starter,
+          fixInstruction: 'Change one sentence opening or combine sentences where the subject repeats.',
+        });
+      }
+    }
+  }
+  return violations;
+}
+
+function statisticalViolations(metrics, thresholds, language) {
+  const violations = [];
+  const cvTarget = metrics.sentenceCount >= 8 ? thresholds.burstinessCVLong : thresholds.burstinessCVShort;
+  if (metrics.burstinessCV < cvTarget) {
+    violations.push({
+      type: 'LOW_BURSTINESS',
+      location: 'Whole text',
+      actual: round(metrics.burstinessCV),
+      target: cvTarget,
+      fixInstruction: 'Vary sentence lengths by splitting one uniform sentence and merging another where the meaning supports it.',
+    });
+  }
+  if (metrics.sentenceCount >= 8 && (metrics.shortSentenceRatio < thresholds.shortSentenceRatio || metrics.longSentenceRatio < thresholds.longSentenceRatio)) {
+    violations.push({
+      type: 'MISSING_SENTENCE_RANGE',
+      location: 'Whole text',
+      shortSentenceRatio: round(metrics.shortSentenceRatio),
+      longSentenceRatio: round(metrics.longSentenceRatio),
+      fixInstruction: 'Add a supported sentence of 6 words or fewer and a supported sentence of 26 words or more until both distribution thresholds pass.',
+    });
+  }
+  if (metrics.adjacentDelta < thresholds.adjacentDelta) {
+    violations.push({
+      type: 'LOW_ADJACENT_DELTA',
+      location: 'Whole text',
+      actual: round(metrics.adjacentDelta),
+      target: thresholds.adjacentDelta,
+      fixInstruction: 'Change neighboring sentence lengths by splitting or merging only where the content allows it.',
+    });
+  }
+  if (metrics.mattr < thresholds.mattr[language]) {
+    violations.push({
+      type: 'LOW_LEXICAL_DIVERSITY',
+      location: 'Whole text',
+      actual: round(metrics.mattr),
+      target: thresholds.mattr[language],
+      fixInstruction: 'Replace repeated generic wording with precise terms already supported by the source.',
+    });
+  }
+  return violations;
+}
+
+function morphologyViolations(tokenized, morphology) {
+  if (!morphology) return { violations: [], nominalizationRatio: 0, passiveRatio: 0 };
+  const words = tokenized.words;
+  const nominalizationPattern = new RegExp(morphology.nominalizationPattern, 'iu');
+  const nominalizationWhitelist = new Set(morphology.nominalizationWhitelist);
+  const nominalizations = words.filter((word) => nominalizationPattern.test(word) && !nominalizationWhitelist.has(word));
+  const passivePattern = new RegExp(morphology.passivePattern, 'iu');
+  const loanwordExclusion = new RegExp(morphology.loanwordExclusionPattern, 'iu');
+  const loanwordSuffixExclusion = new RegExp(morphology.loanwordSuffixExclusionPattern ?? '$^', 'iu');
+  const passives = words.filter((word) => passivePattern.test(word) && !loanwordExclusion.test(word) && !loanwordSuffixExclusion.test(word));
+  const nominalizationRatio = words.length ? nominalizations.length / words.length : 0;
+  const passiveRatio = words.length ? passives.length / words.length : 0;
+  const violations = [];
+
+  if (nominalizationRatio > morphology.nominalizationMaxRatio) {
+    violations.push({
+      type: 'EXCESSIVE_NOMINALIZATION',
+      location: 'Whole text',
+      ratio: round(nominalizationRatio),
+      matches: [...new Set(nominalizations)],
+      fixInstruction: 'Replace abstract nominalizations with concrete actors and verbs.',
+    });
+  }
+  if (passiveRatio > morphology.passiveMaxRatio) {
+    violations.push({
+      type: 'PASSIVE_BLOATING',
+      location: 'Whole text',
+      ratio: round(passiveRatio),
+      matches: [...new Set(passives)],
+      fixInstruction: 'Name the actor and use an active verb where the actor is known.',
+    });
+  }
+
+  const openingPattern = new RegExp(morphology.subordinateOpeningPattern, 'iu');
+  let foundConsecutiveOpening = false;
+  for (const paragraph of tokenized.paragraphs) {
+    for (let index = 1; index < paragraph.sentences.length; index += 1) {
+      const previous = paragraph.sentences[index - 1];
+      const current = paragraph.sentences[index];
+      if (!openingPattern.test(previous.text) || !openingPattern.test(current.text)) continue;
+      violations.push({
+        type: 'PASSIVE_BLOATING',
+        location: `Paragraph ${paragraph.paragraphIndex}, Sentences ${previous.sentenceIndex}-${current.sentenceIndex}`,
+        match: 'Two or more consecutive sentences start with translationese subordinate clauses',
+        fixInstruction: 'Rewrite to start directly with the active subject (Subjek + Predikat).',
+      });
+      foundConsecutiveOpening = true;
+      break;
+    }
+    if (foundConsecutiveOpening) break;
+  }
+  return { violations, nominalizationRatio, passiveRatio };
+}
+
+function voiceDeviation(metrics, tokenized, text, profile) {
+  const targets = profile?.targets ?? profile?.metrics;
+  if (!targets) return 0;
+  const actual = {
+    meanSentenceLength: metrics.meanSentenceLength,
+    burstinessCV: metrics.burstinessCV,
+    adjacentDelta: metrics.adjacentDelta,
+    mattr: metrics.mattr,
+    averageParagraphSentenceCount: mean(tokenized.paragraphs.map((paragraph) => paragraph.sentences.length)),
+  };
+  const deviations = [];
+  for (const key of Object.keys(actual)) {
+    if (typeof targets[key] !== 'number') continue;
+    deviations.push(Math.min(3, Math.abs(actual[key] - targets[key]) / Math.max(Math.abs(targets[key]), 0.01)));
+  }
+  const targetPunctuation = targets.punctuationRates;
+  if (targetPunctuation) {
+    const actualPunctuation = punctuationRates(text, metrics.wordCount);
+    for (const key of Object.keys(targetPunctuation)) {
+      deviations.push(Math.min(3, Math.abs(actualPunctuation[key] - targetPunctuation[key]) / Math.max(Math.abs(targetPunctuation[key]), 0.01)));
+    }
+  }
+  const result = deviations.length ? mean(deviations) : 0;
+  return result < 0.0005 ? 0 : result;
+}
+
+function scoreResult(metrics, violations, language, thresholds) {
+  const cvTarget = metrics.sentenceCount >= 8 ? thresholds.burstinessCVLong : thresholds.burstinessCVShort;
+  let burstinessPenalty = metrics.burstinessCV < cvTarget ? Math.min(25, Math.round((cvTarget - metrics.burstinessCV) * 100)) : 0;
+  if (metrics.sentenceCount >= 8 && (metrics.shortSentenceRatio < thresholds.shortSentenceRatio || metrics.longSentenceRatio < thresholds.longSentenceRatio)) {
+    burstinessPenalty = Math.min(25, burstinessPenalty + 8);
+  }
+  const rhythmPenalty = Math.min(20, violations.filter((violation) => violation.type === 'MONOTONOUS_RHYTHM').length * 6);
+  const lexicalPenalty = Math.min(30, violations.reduce((total, violation) => {
+    if (violation.type === 'SLOP_PHRASE' || violation.type === 'DEFINITIONAL_OPENING') return total + 5;
+    if (violation.type === 'STRUCTURAL_CLICHE') return total + 4;
+    return total;
+  }, 0));
+  const morphologyPenalty = Math.min(15,
+    (violations.some((violation) => violation.type === 'EXCESSIVE_NOMINALIZATION') ? 7.5 : 0)
+    + Math.min(15, violations.filter((violation) => violation.type === 'PASSIVE_BLOATING').length * 7.5));
+  const vocabularyPenalty = metrics.mattr < thresholds.mattr[language] ? 5 : 0;
+  const entropyPenalty = violations.some((violation) => ['LOW_ENTROPY_REPETITION', 'SYMMETRIC_PARAGRAPHS', 'REPETITIVE_STARTERS'].includes(violation.type)) ? 5 : 0;
+  const profilePenalty = violations.some((violation) => violation.type === 'VOICE_PROFILE_DEVIATION') ? 5 : 0;
+  const vocabularyAndProfilePenalty = Math.min(10, vocabularyPenalty + entropyPenalty + profilePenalty);
+  return Math.max(0, Math.round(100 - burstinessPenalty - rhythmPenalty - lexicalPenalty - morphologyPenalty - vocabularyAndProfilePenalty));
+}
+
+export function analyzeText(input, options = {}) {
+  const sanitized = sanitizeMarkdown(input);
+  const initial = tokenizeText(sanitized, options.language ?? 'auto');
+  const language = options.language && options.language !== 'auto' ? options.language : detectLanguage(initial.words);
+  if (!RULES[language]) throw new Error(`Unsupported language: ${language}`);
+  const tokenized = language === (options.language ?? 'auto') ? initial : tokenizeText(sanitized, language);
+  const profile = options.profile ?? DEFAULT_PROFILE;
+  const thresholds = { ...DEFAULT_PROFILE.thresholds, ...(profile.thresholds ?? {}) };
+  const metrics = calculateMetrics(tokenized, sanitized);
+  const patternMatches = patternViolations(tokenized, RULES[language], metrics.wordCount);
+
+  if (metrics.wordCount < thresholds.minimumWords || metrics.sentenceCount < thresholds.minimumSentences) {
+    const violations = patternMatches.filter((violation) => violation.type === 'SLOP_PHRASE');
+    return {
+      status: 'SKIP',
+      score: 100,
+      language,
+      warning: 'Text too short for statistical stylometry (< 3 sentences)',
+      metrics: Object.fromEntries(Object.entries({ ...metrics, nominalizationRatio: 0, passiveRatio: 0, voiceProfileDeviation: 0 }).map(([key, value]) => [key, typeof value === 'number' ? round(value) : value])),
+      violations,
+    };
+  }
+
+  const morphology = morphologyViolations(tokenized, RULES[language].morphology);
+  metrics.nominalizationRatio = morphology.nominalizationRatio;
+  metrics.passiveRatio = morphology.passiveRatio;
+  metrics.voiceProfileDeviation = voiceDeviation(metrics, tokenized, sanitized, profile);
+  const profileTargets = profile.targets ?? profile.metrics ?? {};
+  const targetMean = Number(profileTargets.meanSentenceLength);
+  const meanDeviation = targetMean > 0 ? Math.abs(metrics.meanSentenceLength - targetMean) / targetMean : 0;
+  const profileViolations = options.profile != null && meanDeviation > 0.3 ? [{
+    type: 'VOICE_PROFILE_DEVIATION',
+    location: 'Global Document',
+    match: 'Mean sentence length deviates >30% from target voice profile',
+    fixInstruction: 'Adjust overall sentence complexity so mean sentence length approaches the target profile.',
+  }] : [];
+  const violations = [
+    ...patternMatches,
+    ...monotonyViolations(tokenized),
+    ...structuralViolations(tokenized, metrics),
+    ...morphology.violations,
+    ...profileViolations,
+    ...statisticalViolations(metrics, thresholds, language),
+  ];
+  const score = scoreResult(metrics, violations, language, thresholds);
+  const cvTarget = metrics.sentenceCount >= 8 ? thresholds.burstinessCVLong : thresholds.burstinessCVShort;
+  const forbidden = violations.some((violation) => violation.type === 'SLOP_PHRASE' || violation.type === 'DEFINITIONAL_OPENING');
+  const rhythmPass = metrics.adjacentDelta >= thresholds.adjacentDelta;
+  const distributionPass = metrics.sentenceCount < 8 || (metrics.shortSentenceRatio >= thresholds.shortSentenceRatio && metrics.longSentenceRatio >= thresholds.longSentenceRatio);
+  const status = score >= thresholds.passScore && !forbidden && metrics.burstinessCV >= cvTarget && rhythmPass && distributionPass ? 'PASS' : 'FAIL';
+
+  return {
+    status,
+    score,
+    language,
+    metrics: Object.fromEntries(Object.entries(metrics).map(([key, value]) => [key, typeof value === 'number' ? round(value) : value])),
+    violations,
+  };
+}
+
+function formatHuman(result) {
+  const lines = [`Status: ${result.status}`, `Score: ${result.score}`, `Language: ${result.language}`];
+  if (result.warning) lines.push(`Warning: ${result.warning}`);
+  lines.push('', 'Metrics:');
+  for (const [name, value] of Object.entries(result.metrics)) lines.push(`  ${name}: ${value}`);
+  if (result.violations.length) lines.push('', 'Violations:');
+  for (const violation of result.violations) lines.push(`  ${violation.type} | ${violation.location} | ${violation.fixInstruction}`);
+  return `${lines.join('\n')}\n`;
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks.map((chunk) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))).toString('utf8');
+}
+
+export async function runAnalyzeCli(argv, io = {}) {
+  const stdout = io.stdout ?? ((value) => process.stdout.write(value));
+  const stderr = io.stderr ?? ((value) => process.stderr.write(value));
+  const stdin = io.stdin ?? readStdin;
+  try {
+    const { values } = parseArgs({
+      args: argv,
+      options: {
+        file: { type: 'string' },
+        stdin: { type: 'boolean' },
+        lang: { type: 'string', default: 'auto' },
+        profile: { type: 'string' },
+        json: { type: 'boolean' },
+        help: { type: 'boolean' },
+      },
+      strict: true,
+      allowPositionals: false,
+    });
+    if (values.help) {
+      stdout('Usage: humanizer-lint (--file <path> | --stdin) [--lang id|en|auto] [--profile <path>] [--json]\n');
+      return 0;
+    }
+    if (Boolean(values.file) === Boolean(values.stdin)) throw new Error('Choose exactly one input: --file or --stdin');
+    if (!['id', 'en', 'auto'].includes(values.lang)) throw new Error('--lang must be id, en, or auto');
+    if (values.stdin && io.stdin == null && process.stdin.isTTY) throw new Error('--stdin requires piped input');
+    const text = values.file ? await new Promise((resolve, reject) => readFile(values.file, 'utf8', (error, data) => error ? reject(error) : resolve(data))) : await stdin();
+    const profile = values.profile ? JSON.parse(await new Promise((resolve, reject) => readFile(values.profile, 'utf8', (error, data) => error ? reject(error) : resolve(data)))) : undefined;
+    const result = analyzeText(text, { language: values.lang, profile });
+    stdout(values.json ? `${JSON.stringify(result, null, 2)}\n` : formatHuman(result));
+    return result.status === 'FAIL' ? 1 : 0;
+  } catch (error) {
+    stderr(`ERROR: ${error.message}\n`);
+    return 2;
+  }
+}
+
+function currentModulePath() {
+  let value = decodeURIComponent(new URL(import.meta.url).pathname);
+  if (/^\/[A-Za-z]:/.test(value)) value = value.slice(1);
+  return path.resolve(value);
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(currentModulePath());
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  process.exitCode = await runAnalyzeCli(process.argv.slice(2));
+}

package/scripts/fingerprint.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { promises as fs, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { sanitizeMarkdown } from './utils/sanitizer.mjs';
+import { calculateMetrics, mean, punctuationRates } from './utils/metrics.mjs';
+import { tokenizeText } from './utils/tokenizer.mjs';
+
+const { mkdir, readFile, readdir, rename, stat, writeFile } = fs;
+
+function round(value, places = 4) {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+}
+
+function averageObjects(objects) {
+  const keys = [...new Set(objects.flatMap((object) => Object.keys(object)))];
+  return Object.fromEntries(keys.map((key) => [key, round(mean(objects.map((object) => object[key] ?? 0)))]));
+}
+
+export async function fingerprintSamples(files, options = {}) {
+  if (!Array.isArray(files) || files.length < 1 || files.length > 5) throw new Error('Fingerprint requires 1 to 5 sample files');
+  const samples = [];
+  for (const file of files) {
+    const raw = await readFile(file, 'utf8');
+    const sanitized = sanitizeMarkdown(raw);
+    const tokenized = tokenizeText(sanitized, 'auto');
+    const metrics = calculateMetrics(tokenized, sanitized);
+    if (metrics.wordCount < 20 || metrics.sentenceCount < 3) throw new Error(`Sample is too short: ${file}`);
+    samples.push({
+      ...metrics,
+      averageParagraphSentenceCount: mean(tokenized.paragraphs.map((paragraph) => paragraph.sentences.length)),
+      punctuationRates: punctuationRates(sanitized, metrics.wordCount),
+    });
+  }
+
+  const punctuation = averageObjects(samples.map((sample) => sample.punctuationRates));
+  const profile = {
+    name: options.name ?? 'custom-voice',
+    version: 1,
+    sampleCount: samples.length,
+    language: options.language ?? 'auto',
+    metrics: {
+      meanSentenceLength: round(mean(samples.map((sample) => sample.meanSentenceLength))),
+      stdDev: round(mean(samples.map((sample) => sample.stdDev))),
+      burstinessCV: round(mean(samples.map((sample) => sample.burstinessCV))),
+      adjacentDelta: round(mean(samples.map((sample) => sample.adjacentDelta))),
+      mattr: round(mean(samples.map((sample) => sample.mattr))),
+      averageParagraphSentenceCount: round(mean(samples.map((sample) => sample.averageParagraphSentenceCount))),
+      punctuationRates: punctuation,
+    },
+  };
+
+  if (options.output) {
+    const output = path.resolve(options.output);
+    await mkdir(path.dirname(output), { recursive: true });
+    const temporary = `${output}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(profile, null, 2)}\n`, 'utf8');
+    await rename(temporary, output);
+  }
+  return profile;
+}
+
+async function collectInput(input) {
+  const info = await stat(input);
+  if (info.isFile()) return [path.resolve(input)];
+  if (!info.isDirectory()) throw new Error('--input must be a file or directory');
+  const entries = await readdir(input, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isFile() && /\.(?:md|txt)$/i.test(entry.name))
+    .map((entry) => path.resolve(input, entry.name))
+    .sort()
+    .slice(0, 5);
+}
+
+export async function runFingerprintCli(argv, io = {}) {
+  const stdout = io.stdout ?? ((value) => process.stdout.write(value));
+  const stderr = io.stderr ?? ((value) => process.stderr.write(value));
+  try {
+    const { values } = parseArgs({
+      args: argv,
+      options: {
+        input: { type: 'string' },
+        output: { type: 'string' },
+        name: { type: 'string' },
+        lang: { type: 'string', default: 'auto' },
+        help: { type: 'boolean' },
+      },
+      strict: true,
+      allowPositionals: false,
+    });
+    if (values.help) {
+      stdout('Usage: humanizer-fingerprint --input <file-or-dir> --output <profile.json> [--name <name>] [--lang id|en|auto]\n');
+      return 0;
+    }
+    if (!values.input || !values.output) throw new Error('--input and --output are required');
+    if (!['id', 'en', 'auto'].includes(values.lang)) throw new Error('--lang must be id, en, or auto');
+    const files = await collectInput(values.input);
+    if (!files.length) throw new Error('No .txt or .md samples found');
+    const profile = await fingerprintSamples(files, { output: values.output, name: values.name, language: values.lang });
+    stdout(`${JSON.stringify(profile, null, 2)}\n`);
+    return 0;
+  } catch (error) {
+    stderr(`ERROR: ${error.message}\n`);
+    return 2;
+  }
+}
+
+function currentModulePath() {
+  let value = decodeURIComponent(new URL(import.meta.url).pathname);
+  if (/^\/[A-Za-z]:/.test(value)) value = value.slice(1);
+  return path.resolve(value);
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(process.argv[1]) === realpathSync(currentModulePath());
+  } catch {
+    return false;
+  }
+}
+
+if (isMainModule()) {
+  process.exitCode = await runFingerprintCli(process.argv.slice(2));
+}