slopfix 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zwarmex
+
+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.fr.md

@@ -0,0 +1,56 @@
+<div align="center">
+
+# slopfix
+
+**Votre texte sonne comme du ChatGPT. slopfix trouve pourquoi, et le corrige.**
+
+Un linter sans dépendance pour les tics d'écriture IA : tirets cadratins, `ce n'est pas X, c'est Y`, `plongeons dans`, `j'espère que cela vous aide !`, emojis en guise de puces et plus de 200 autres. Français et anglais. CLI, librairie, GitHub Action, skill pour agents IA et [playground dans le navigateur](https://zwarmex.github.io/slopfix/).
+
+[Essayer dans le navigateur](https://zwarmex.github.io/slopfix/) · [English](README.md)
+
+</div>
+
+```bash
+npx slopfix article.md
+```
+
+## Pourquoi
+
+Tout le monde repère un texte généré en deux secondes, et arrête de lire. Les recruteurs zappent la lettre de motivation, les lecteurs quittent l'article, les mainteneurs ferment la pull request. Les tics sont toujours les mêmes, et la plupart sont mécaniques :
+
+<!-- slopfix-disable -->
+
+| Tic | Exemple | slopfix |
+| --- | --- | --- |
+| Tirets cadratins partout | `rapide (tiret) et simple (tiret) par nature` | signale, remplace par `, ` |
+| Parallélisme négatif | « Ce n'est pas un outil, c'est une révolution. » | signale |
+| Formules de remplissage | « Il est important de noter que... » | supprime, remet la majuscule |
+| Mots surutilisés | incontournable, pierre angulaire, s'avère être | signale, remplace les cas sûrs |
+| Restes de chatbot | « Bien sûr ! », « J'espère que cela vous aide ! » | supprime ou signale |
+| Grandiloquence | « change la donne », « joue un rôle crucial », « plongeons dans » | signale |
+| Mise en forme de chatbot | emojis en puces, listes de **Libellé gras :** | supprime les emojis, signale les listes |
+
+<!-- slopfix-enable -->
+
+slopfix est déterministe. Il n'appelle aucun LLM, ne devine pas qui a écrit le texte et n'envoie rien nulle part. Il montre les tics, donne à chaque fichier un **score de slop** de 0 (propre) à 100 (pur slop), et corrige ce qui peut l'être sans risque.
+
+## Utilisation
+
+```bash
+npx slopfix docs/                  # analyser un dossier
+npx slopfix article.md --fix       # corriger le fichier
+npx slopfix . --max-score 20       # échouer seulement au-dessus de 20
+npx slopfix . --lang fr            # forcer le français
+```
+
+La langue est détectée automatiquement pour chaque fichier. Les blocs de code, le code inline, les URLs, le HTML et le front matter sont ignorés.
+
+Configuration, GitHub Action, pre-commit et API : tout est dans le [README anglais](README.md).
+
+## Contribuer
+
+Ajouter une expression française, c'est une ligne dans [`src/rules/fr.js`](src/rules/fr.js). Vous voyez passer un tic IA tous les jours sur LinkedIn ? Ouvrez une pull request. Voir [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Licence
+
+MIT

package/README.md

@@ -1,3 +1,223 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# slopfix
+
+**Your text reads like ChatGPT wrote it. slopfix finds why, and fixes it.**
+
+A zero dependency linter for AI writing tells: em dashes, `it's not X, it's Y`, `delve`, `I hope this helps!`, emoji bullets and 200+ more. English and French. CLI, library, GitHub Action, agent skill and a [browser playground](https://zwarmex.github.io/slopfix/).
+
+[![CI](https://github.com/Zwarmex/slopfix/actions/workflows/ci.yml/badge.svg)](https://github.com/Zwarmex/slopfix/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/slopfix.svg)](https://www.npmjs.com/package/slopfix)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Dependencies: 0](https://img.shields.io/badge/dependencies-0-brightgreen.svg)
+
+[Try it in your browser](https://zwarmex.github.io/slopfix/) · [Français](README.fr.md)
+
+</div>
+
+```bash
+npx slopfix README.md
+```
+
+```
+README.md  en · 130 words · slop score 94/100 (pure slop)
+  3:1    error    Certainly! → (remove)                        Sycophantic chatbot opener.
+  5:1    warning  In today's fast-paced world, → (remove)      Filler phrase. Delete it and say the thing.
+  5:91   warning  FlowSync is not just another app, it's       "It's not X, it's Y" construction.
+  7:45   warning  (em dash) → ","                              Em dash. The most recognizable AI writing tell.
+  7:117  warning  delve into → "dig into"                      Word that is heavily overused by language models.
+  15:78  error    I hope this helps! → (remove)                Chatbot sign-off.
+
+✖ 24 tells (4 errors, 16 warnings, 4 info) · 13 fixable with --fix
+```
+
+## Why
+
+People now spot generated text in two seconds, and they stop reading. Recruiters skip the cover letter, readers skip the blog post, maintainers close the pull request. The tells are always the same, and most of them are mechanical:
+
+<!-- slopfix-disable -->
+
+| Tell | Example | slopfix |
+| --- | --- | --- |
+| Em dashes everywhere | `fast (em dash) and simple (em dash) by design` | flags, fixes to `, ` |
+| Negative parallelism | "It's not a tool, it's a revolution." | flags |
+| Filler openers | "It's important to note that..." | removes, re-capitalizes |
+| Overused words | delve, utilize, tapestry, a myriad of | flags, replaces the safe ones |
+| Chatbot leftovers | "Certainly!", "I hope this helps!", "As an AI language model" | removes or flags |
+| Hype | "game-changer", "unlock the full potential", "stands as a testament" | flags |
+| Chatbot formatting | emoji bullets, lists of **Bold label:** items | removes emojis, flags lists |
+
+<!-- slopfix-enable -->
+
+slopfix is deterministic. It does not call an LLM, it does not guess who wrote the text and it does not send anything anywhere. It shows the tells, gives each file a **slop score** from 0 (clean) to 100 (pure slop), and fixes what is safe to fix.
+
+## Install
+
+```bash
+# run once
+npx slopfix docs/
+
+# or install
+npm install --save-dev slopfix
+```
+
+Node 18 or newer. No dependencies.
+
+## CLI
+
+```bash
+slopfix README.md                 # lint a file
+slopfix docs blog                 # lint folders (md, mdx, markdown, txt)
+slopfix docs --fix                # fix every safe tell in place
+slopfix . --max-score 20          # only fail when a file scores above 20
+slopfix . --format github         # annotations for GitHub Actions
+pbpaste | slopfix --fix | pbcopy  # clean your clipboard (macOS)
+```
+
+| Option | Description |
+| --- | --- |
+| `--fix` | Rewrite files with every safe fix. With stdin, print the fixed text. |
+| `--lang <code>` | `en`, `fr`, `auto` (default, per file) or `all` |
+| `--format <name>` | `pretty` (default), `compact`, `json`, `github` |
+| `--max-score <n>` | Fail only when a file's score is above `n` |
+| `--quiet` | Hide info level tells |
+| `--dash <text>` | What replaces an em dash with `--fix` (default `", "`) |
+| `--ext <list>` | Extensions to scan in folders |
+| `--plain` | Treat input as plain text instead of Markdown |
+| `--list-rules` | Print every rule |
+
+Exit code is `0` when clean, `1` when tells are found, `2` on usage errors.
+
+Code blocks, inline code, URLs, HTML tags and front matter are skipped, so your docs can talk about `delve` without being flagged.
+
+## Configuration
+
+Create `.slopfixrc.json` (or a `slopfix` key in `package.json`):
+
+```json
+{
+  "lang": "auto",
+  "dashReplacement": " - ",
+  "maxScore": 25,
+  "rules": {
+    "en/weasel-vocabulary": "off",
+    "em-dash": "error"
+  },
+  "ban": [
+    "synergy",
+    { "phrase": "blazingly fast", "replacement": "fast" }
+  ],
+  "ignore": ["CHANGELOG.md", "docs/legacy/**"]
+}
+```
+
+Silence a passage inside a Markdown file:
+
+```md
+<!-- slopfix-disable -->
+This paragraph can delve as much as it wants.
+<!-- slopfix-enable -->
+
+<!-- slopfix-disable-next-line -->
+So can this line.
+```
+
+## GitHub Action
+
+Annotates the tells right on the pull request diff.
+
+```yaml
+# .github/workflows/slopfix.yml
+name: slopfix
+on: pull_request
+jobs:
+  slopfix:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+      - uses: Zwarmex/slopfix@v0
+        with:
+          paths: docs README.md
+          max-score: 25
+```
+
+## pre-commit
+
+```yaml
+repos:
+  - repo: https://github.com/Zwarmex/slopfix
+    rev: v0.1.0
+    hooks:
+      - id: slopfix
+```
+
+## Library
+
+```js
+import { lint, fix } from 'slopfix';
+
+const result = lint('Certainly! We delve into the data.');
+result.score;   // 0 to 100
+result.issues;  // [{ ruleId, severity, message, line, column, quote, fix }, ...]
+
+fix('Certainly! We delve into the data.').output;
+// "We dig into the data."
+```
+
+Types are included. It runs in Node and in the browser (the playground uses the same code).
+
+## Make your AI agent check itself
+
+Copy [`skill/SKILL.md`](skill/SKILL.md) into your agent's skills folder (for example `.claude/skills/slopfix/SKILL.md`). Agents that support skills (Claude Code, Codex, Cursor and others) will run slopfix on the prose they write before handing it to you. You can also add one line to your `AGENTS.md`:
+
+```md
+Before you finish, run `npx slopfix --quiet` on every Markdown file you changed and fix what it reports.
+```
+
+## Rules
+
+Run `slopfix --list-rules` for the full list.
+
+| Rule | Lang | Default | Autofix |
+| --- | --- | --- | --- |
+| `em-dash` | all | warning | yes |
+| `spaced-en-dash` | all | warning | yes |
+| `emoji-bullet` | all | warning | yes |
+| `bold-label-list` | all | info | no |
+| `en/chatbot-artifact`, `fr/chatbot-artifact` | en, fr | error | no |
+| `en/sycophantic-opener`, `fr/sycophantic-opener` | en, fr | error | yes |
+| `en/chatbot-sign-off`, `fr/chatbot-sign-off` | en, fr | error | yes |
+| `en/filler-opener`, `fr/filler-opener` | en, fr | warning | yes |
+| `en/hype-intro`, `fr/hype-intro` | en, fr | warning | no |
+| `en/ai-vocabulary`, `fr/ai-vocabulary` | en, fr | warning | partly |
+| `en/weasel-vocabulary`, `fr/weasel-vocabulary` | en, fr | info | no |
+| `en/not-x-but-y`, `fr/not-x-but-y` | en, fr | warning | no |
+| `en/whether-youre`, `fr/que-vous-soyez` | en, fr | info | no |
+
+Rewrites that need judgment (negative parallelism, hype) are reported but never rewritten for you. A linter that silently rewrites your argument is worse than slop.
+
+## The slop score
+
+Each tell has a weight (error 5, warning 2, info 1). The score takes the weighted density per 100 words and maps it onto a 0 to 100 curve. Rough guide:
+
+| Score | Label |
+| --- | --- |
+| 0 to 9 | clean |
+| 10 to 29 | a few tells |
+| 30 to 59 | sloppy |
+| 60 to 100 | pure slop |
+
+It is a writing quality signal, not an AI detector. Humans write `crucial` too. A high score means readers will *think* a model wrote it, which is the problem you want to fix.
+
+## Contributing
+
+The best contributions are new phrases and new languages. Adding a phrase is one line in [`src/rules/en.js`](src/rules/en.js) or [`src/rules/fr.js`](src/rules/fr.js), adding a language is one new file. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+Wanted: Spanish, German, Portuguese, Italian, Dutch. Open a pull request with the tells you see every day in your language.
+
+## License
+
+MIT

package/bin/slopfix.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from 'node:fs';
+import { join, relative, extname, resolve } from 'node:path';
+import { lint, fix, rules } from '../src/index.js';
+import { formatters, c } from '../src/format.js';
+
+const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+
+const HELP = `
+${c.bold('slopfix')} ${pkg.version}  Find and fix AI writing tells in your docs, posts and READMEs.
+
+${c.bold('Usage')}
+  slopfix [files or folders...] [options]
+  cat post.md | slopfix [options]
+
+${c.bold('Options')}
+  --fix                  Rewrite files with every safe fix (stdin: print the fixed text)
+  --lang <code>          en, fr, auto (default) or all
+  --format <name>        pretty (default), compact, json, github
+  --max-score <n>        Only fail when a file's slop score is above n (0 to 100)
+  --quiet                Hide info level tells
+  --dash <text>          What replaces an em dash with --fix (default ", ")
+  --ext <list>           Extensions to scan in folders (default md,mdx,markdown,txt)
+  --plain                Treat input as plain text, not Markdown
+  --config <path>        Config file (default .slopfixrc.json if present)
+  --list-rules           Print every rule and exit
+  -v, --version          Print the version
+  -h, --help             Print this help
+
+${c.bold('Examples')}
+  npx slopfix README.md
+  npx slopfix docs --fix
+  npx slopfix . --max-score 20 --format github
+  pbpaste | npx slopfix --fix | pbcopy
+
+${c.bold('Exit codes')}
+  0 no errors or warnings (or every file under --max-score), 1 tells found, 2 usage error
+`;
+
+const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', 'vendor', 'coverage', '.next', '.nuxt', '.cache', '.venv', 'venv']);
+
+function parseArgs(argv) {
+  const args = { files: [], fix: false, format: 'pretty', quiet: false, listRules: false, plain: false };
+  const takesValue = new Set(['--lang', '--format', '--max-score', '--dash', '--ext', '--config']);
+  for (let i = 0; i < argv.length; i++) {
+    let a = argv[i];
+    let value;
+    if (a.startsWith('--') && a.includes('=')) [a, value] = [a.slice(0, a.indexOf('=')), a.slice(a.indexOf('=') + 1)];
+    if (takesValue.has(a) && value === undefined) {
+      value = argv[++i];
+      if (value === undefined) throw new Error(`${a} needs a value`);
+    }
+    switch (a) {
+      case '-h':
+      case '--help':
+        args.help = true;
+        break;
+      case '-v':
+      case '--version':
+        args.version = true;
+        break;
+      case '--fix':
+        args.fix = true;
+        break;
+      case '--quiet':
+        args.quiet = true;
+        break;
+      case '--plain':
+        args.plain = true;
+        break;
+      case '--list-rules':
+        args.listRules = true;
+        break;
+      case '--lang':
+        args.lang = value;
+        break;
+      case '--format':
+        if (!formatters[value]) throw new Error(`Unknown format "${value}". Use ${Object.keys(formatters).join(', ')}.`);
+        args.format = value;
+        break;
+      case '--max-score':
+        args.maxScore = Number(value);
+        if (!Number.isFinite(args.maxScore)) throw new Error('--max-score needs a number');
+        break;
+      case '--dash':
+        args.dash = value;
+        break;
+      case '--ext':
+        args.ext = value.split(',').map((e) => e.trim().replace(/^\./, ''));
+        break;
+      case '--config':
+        args.config = value;
+        break;
+      default:
+        if (a.startsWith('-') && a !== '-') throw new Error(`Unknown option ${a}`);
+        args.files.push(a);
+    }
+  }
+  return args;
+}
+
+function loadConfig(path) {
+  const file = path || ['.slopfixrc.json', '.slopfixrc'].find((f) => existsSync(f));
+  if (file) {
+    try {
+      return JSON.parse(readFileSync(file, 'utf8'));
+    } catch (e) {
+      throw new Error(`Could not read config ${file}: ${e.message}`);
+    }
+  }
+  if (existsSync('package.json')) {
+    try {
+      return JSON.parse(readFileSync('package.json', 'utf8')).slopfix || {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function globToRegex(glob) {
+  const re = glob
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*\/?/g, '\u0000')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]')
+    .replace(/\u0000/g, '.*');
+  return new RegExp(`(^|/)${re}($|/)`);
+}
+
+function collect(paths, extensions, ignore) {
+  const files = [];
+  const isIgnored = (p) => ignore.some((re) => re.test(p.split('\\').join('/')));
+  const walk = (dir) => {
+    for (const name of readdirSync(dir).sort()) {
+      if (IGNORED_DIRS.has(name)) continue;
+      const full = join(dir, name);
+      const rel = relative(process.cwd(), full);
+      if (isIgnored(rel)) continue;
+      const st = statSync(full);
+      if (st.isDirectory()) walk(full);
+      else if (extensions.includes(extname(name).slice(1).toLowerCase())) files.push(full);
+    }
+  };
+  for (const p of paths) {
+    if (!existsSync(p)) throw new Error(`No such file or folder: ${p}`);
+    if (statSync(p).isDirectory()) walk(p);
+    else files.push(p);
+  }
+  return files;
+}
+
+function readStdin() {
+  return readFileSync(0, 'utf8');
+}
+
+function listRules() {
+  const rows = rules.map((r) => `${r.id.padEnd(26)} ${r.lang.padEnd(3)} ${r.severity.padEnd(8)} ${r.message}`);
+  return [`${'RULE'.padEnd(26)} ${'LANG'.padEnd(3)} SEVERITY ${'DESCRIPTION'}`, ...rows].join('\n');
+}
+
+function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (e) {
+    console.error(c.red(`slopfix: ${e.message}`));
+    return 2;
+  }
+  if (args.help) return console.log(HELP), 0;
+  if (args.version) return console.log(pkg.version), 0;
+  if (args.listRules) return console.log(listRules()), 0;
+
+  const config = loadConfig(args.config);
+  const options = {
+    lang: args.lang || config.lang || 'auto',
+    rules: config.rules || {},
+    ban: config.ban || [],
+    dashReplacement: args.dash ?? config.dashReplacement ?? ', ',
+    markdown: !args.plain && config.markdown !== false,
+  };
+  const maxScore = args.maxScore ?? config.maxScore;
+  const extensions = args.ext || config.extensions || ['md', 'mdx', 'markdown', 'txt'];
+  const ignore = (config.ignore || []).map(globToRegex);
+
+  const fromStdin = args.files.length === 0 || (args.files.length === 1 && args.files[0] === '-');
+  if (fromStdin && process.stdin.isTTY) {
+    console.log(HELP);
+    return 2;
+  }
+
+  const results = [];
+  try {
+    if (fromStdin) {
+      const text = readStdin();
+      if (args.fix) {
+        process.stdout.write(fix(text, options).output);
+        return 0;
+      }
+      results.push({ file: '<stdin>', ...lint(text, options) });
+    } else {
+      for (const file of collect(args.files, extensions, ignore)) {
+        const text = readFileSync(file, 'utf8');
+        const name = relative(process.cwd(), resolve(file)).split('\\').join('/');
+        if (args.fix) {
+          const { output, fixed, result } = fix(text, options);
+          if (fixed > 0 && output !== text) writeFileSync(file, output);
+          results.push({ file: name, fixed, ...result });
+        } else {
+          results.push({ file: name, ...lint(text, options) });
+        }
+      }
+    }
+  } catch (e) {
+    console.error(c.red(`slopfix: ${e.message}`));
+    return 2;
+  }
+
+  const shown = args.quiet ? results.map((r) => ({ ...r, issues: r.issues.filter((i) => i.severity !== 'info') })) : results;
+  const output = formatters[args.format](shown);
+  if (output) console.log(output);
+  if (args.fix && args.format === 'pretty') {
+    const total = results.reduce((n, r) => n + (r.fixed || 0), 0);
+    console.log(c.green(`\u2714 Fixed ${total} tells in ${results.filter((r) => r.fixed).length} files.`));
+  }
+
+  const failed = results.some((r) =>
+    maxScore !== undefined ? r.score > maxScore : r.issues.some((i) => i.severity === 'error' || i.severity === 'warning'),
+  );
+  return failed ? 1 : 0;
+}
+
+process.exitCode = main();

package/index.d.ts

@@ -0,0 +1,93 @@
+export type Severity = 'error' | 'warning' | 'info';
+export type Language = 'en' | 'fr';
+
+export interface Options {
+  /** 'auto' (default) detects the language, 'all' runs every language's rules. */
+  lang?: Language | 'auto' | 'all';
+  /** Turn a rule off or change its severity, e.g. { 'em-dash': 'off', 'en/weasel-vocabulary': 'warning' }. */
+  rules?: Record<string, Severity | 'off' | false>;
+  /** Extra phrases to flag. A replacement makes them fixable. */
+  ban?: Array<string | { phrase: string; replacement?: string }>;
+  /** What replaces an em dash when fixing. Default ', '. */
+  dashReplacement?: string;
+  /** Skip code, URLs, HTML and front matter. Default true. */
+  markdown?: boolean;
+}
+
+export interface Fix {
+  range: [number, number];
+  text: string;
+  label?: string;
+}
+
+export interface Issue {
+  ruleId: string;
+  category: string;
+  severity: Severity;
+  message: string;
+  quote: string;
+  index: number;
+  length: number;
+  line: number;
+  column: number;
+  endLine: number;
+  endColumn: number;
+  fix?: Fix;
+}
+
+export interface LintResult {
+  language: Language;
+  words: number;
+  /** 0 is clean, 100 is pure slop. */
+  score: number;
+  label: 'clean' | 'a few tells' | 'sloppy' | 'pure slop';
+  issues: Issue[];
+}
+
+export interface FixResult {
+  output: string;
+  fixed: number;
+  result: LintResult;
+}
+
+export interface Hit {
+  index: number;
+  length: number;
+  fix?: string | null;
+  fixLabel?: string;
+  message?: string;
+  quote?: string;
+}
+
+export interface Rule {
+  id: string;
+  lang: Language | '*';
+  category: string;
+  severity: Severity;
+  message: string;
+  find(text: string, ctx: { options: Required<Options>; language: Language }): Iterable<Hit>;
+}
+
+export function lint(text: string, options?: Options): LintResult;
+export function fix(text: string, options?: Options): FixResult;
+export function detectLanguage(text: string): Language;
+export function computeScore(issues: Issue[], words: number): number;
+export function scoreLabel(score: number): LintResult['label'];
+export function mask(text: string, options?: { markdown?: boolean }): string;
+export const rules: Rule[];
+export const languages: Language[];
+export const weights: Record<Severity, number>;
+export const defaults: Required<Options>;
+
+declare const slopfix: {
+  lint: typeof lint;
+  fix: typeof fix;
+  rules: typeof rules;
+  detectLanguage: typeof detectLanguage;
+  computeScore: typeof computeScore;
+  scoreLabel: typeof scoreLabel;
+  mask: typeof mask;
+  languages: typeof languages;
+  defaults: typeof defaults;
+};
+export default slopfix;

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "slopfix",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Find and fix AI writing tells (em dashes, \"it's not X, it's Y\", delve, chatbot leftovers) in English and French. Zero dependencies. CLI, library, GitHub Action.",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "slopfix": "bin/slopfix.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "lint:docs": "node bin/slopfix.js README.md README.fr.md CONTRIBUTING.md CHANGELOG.md skill/SKILL.md",
+    "demo": "node examples/make-examples.js && node bin/slopfix.js examples"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "chatgpt",
+    "claude",
+    "slop",
+    "ai-slop",
+    "ai-writing",
+    "humanizer",
+    "linter",
+    "prose",
+    "writing",
+    "markdown",
+    "em-dash",
+    "cli",
+    "github-action"
+  ],
+  "author": "Zwarmex",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Zwarmex/slopfix.git"
+  },
+  "homepage": "https://zwarmex.github.io/slopfix/",
+  "bugs": {
+    "url": "https://github.com/Zwarmex/slopfix/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}