humanizer-lint 0.2.3 → 0.2.4

package/SKILL.md

@@ -5,7 +5,7 @@ license: MIT
 compatibility: Node.js >= 18.3.0 (zero external dependencies)
 allowed-tools: Bash(node:*) Read Write
 metadata:
-  version: "0.2.3"
+  version: "0.2.4"
   author: "yanstd888"
   domain: "writing"
 ---

package/package.json

@@ -1,25 +1,26 @@
-{
-  "name": "humanizer-lint",
-  "version": "0.2.3",
-  "description": "Closed-loop stylometric linter and anti-AI-slop diagnostic engine for Indonesian and English prose",
-  "type": "module",
-  "engines": {
-    "node": ">=18.3.0"
-  },
-  "bin": {
-    "humanizer-lint": "./scripts/analyze.mjs",
-    "humanizer-fingerprint": "./scripts/fingerprint.mjs"
-  },
-  "files": [
-    "SKILL.md",
-    "README.md",
-    "LICENSE",
-    "scripts/",
-    "rules/",
-    "profiles/"
-  ],
-  "scripts": {
-    "test": "node --test tests/test-runner.mjs"
-  },
-  "license": "MIT"
-}
+{
+  "name": "humanizer-lint",
+  "version": "0.2.4",
+  "description": "Closed-loop stylometric linter and anti-AI-slop diagnostic engine for Indonesian and English prose",
+  "type": "module",
+  "engines": {
+    "node": ">=18.3.0"
+  },
+  "bin": {
+    "humanizer-lint": "./scripts/analyze.mjs",
+    "humanizer-fingerprint": "./scripts/fingerprint.mjs"
+  },
+  "files": [
+    "SKILL.md",
+    "README.md",
+    "LICENSE",
+    "scripts/",
+    "rules/",
+    "profiles/"
+  ],
+  "scripts": {
+    "test": "node --test tests/test-runner.mjs",
+    "build:demo": "node demo/build.mjs"
+  },
+  "license": "MIT"
+}

package/scripts/analyze.mjs

@@ -1,408 +1,87 @@
-#!/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));
-}
+#!/usr/bin/env node
+import { readFile, readFileSync, realpathSync } from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+
+import { createAnalyzer } from './core/analyzer-core.mjs';
+import { calculateMetrics } from './utils/metrics.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 { analyzeText } = createAnalyzer({ rules: RULES, defaultProfile: DEFAULT_PROFILE, calculateMetrics });
+
+export { analyzeText };
+
+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));
+}