buvard 0.1.1 → 0.1.2

package/AGENTS.md

@@ -11,8 +11,10 @@ repo `git.nech.pl/pln/buvard` (visibility toggle is the owner's call).
   structure -8, servile/meta -10; punctuation budgets (1 tiret cadratin/500w,
   1 !/1000w). **Voice rule: hits are review candidates, never verdicts — the
   author's voice always wins.** buvard is a style linter, never an AI detector.
-- **`bin/buvard.js`** — CLI (`check`, `--json`), frontmatter stripped. Tests:
-  `npm test` (node:test, 6/6 passing).
+- **`bin/buvard.js`** — CLI (`check`, `score`, `--json`, `--hidden`, `--help`,
+  `--version`), frontmatter stripped. Walks skip dot-directories and never
+  follow directory symlinks; unreadable dirs warn, never crash. Tests:
+  `npm test` (node:test, 24 passing).
 - **`docs/research.md`** — the clustering study. **`docs/research-litreview.md`**
   — literature review (2026-11-07): detection literature unreliable on short/
   paraphrased text; 61.22% FP rate of commercial detectors on non-native essays

package/bin/buvard.js

@@ -2,14 +2,18 @@
 /**
  * buvard — l'anti-slop qui tache. Blotting paper for AI-flavored prose.
  *
- * buvard check <files|dirs> [--json]   run the catalog over markdown/text
- * buvard score <file>                  single-file score, machine-readable
+ * buvard check [files|dirs] [--json] [--hidden]   run the catalog over markdown/text
+ * buvard score <file> [--json]                    single-file score, machine-readable
+ * buvard --help | --version
  *
  * Scoring starts at 100; each hit costs its weight (lexique 5, structure 8,
  * servile 10; punctuation charges per occurrence past the budget: one tiret
  * cadratin per 500 words, one exclamation per 1000). Every hit is a review
  * candidate, not a verdict — the author's voice always wins.
  *
+ * Walks skip dot-directories (--hidden to include) and never follow directory
+ * symlinks; unreadable directories are warned about, not fatal.
+ *
  * Known gaps, deliberately manual: règle de trois, synonyme acrobatique and
  * sentence-length variance need document-level analysis that regex fakes
  * badly. Read the text too.
@@ -20,26 +24,123 @@ import path from 'path';
 import { CATALOG_VERSION, lint, bodyOf } from '../lib/index.mjs';
 
 const TEXT_EXT = /\.(md|txt|mdx)$/i;
+const PKG_VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 
-function collect(target, files) {
-  if (TEXT_EXT.test(target) && fs.existsSync(target)) return files.push(path.resolve(target));
-  if (fs.existsSync(target) && fs.statSync(target).isDirectory()) {
-    for (const f of fs.readdirSync(target)) {
-      const p = path.join(target, f);
-      if (fs.statSync(p).isDirectory()) collect(p, files);
-      else if (TEXT_EXT.test(f)) files.push(path.resolve(p));
-    }
+const USAGE = `buvard — l'anti-slop qui tache. Blotting paper for AI-flavored prose.
+
+Usage:
+  buvard check [files|dirs...] [--json] [--hidden]   lint markdown/text files
+  buvard score <file> [--json]                       single-file score
+  buvard --help                                      this help
+  buvard --version                                   package version
+
+Options:
+  --json      machine-readable output
+  --hidden    include dot-directories when walking (skipped by default)
+
+Scoring: 100 base; each hit costs its weight (lexique -5, structure -8,
+servile -10; punctuation past budget charges per occurrence: one tiret
+cadratin per 500 words, one exclamation per 1000). Hits are review
+candidates, never verdicts — the author's voice always wins.`;
+
+/**
+ * Collect lintable files from a target path. Text files go straight in;
+ * directories are walked (skipping dot-entries unless `hidden`, and never
+ * following directory symlinks — readdir Dirents mark them as symlinks, not
+ * directories). Unresolvable targets and unreadable directories land in
+ * `errors` as warnings; they never throw.
+ */
+function collect(target, files, opts, errors) {
+  let st;
+  try {
+    st = fs.statSync(target);
+  } catch {
+    errors.push(`buvard: no file or directory for "${target}"`);
+    return;
+  }
+  if (st.isFile()) {
+    if (TEXT_EXT.test(target)) files.push(path.resolve(target));
+    else errors.push(`buvard: "${target}" is not .md, .txt or .mdx — skipped`);
+    return;
+  }
+  if (!st.isDirectory()) {
+    errors.push(`buvard: "${target}" is neither file nor directory — skipped`);
+    return;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(target, { withFileTypes: true });
+  } catch (e) {
+    errors.push(`buvard: cannot read "${target}" (${e.code}) — skipped`);
+    return;
+  }
+  for (const ent of entries) {
+    if (!opts.hidden && ent.name.startsWith('.')) continue;
+    const p = path.join(target, ent.name);
+    if (ent.isDirectory()) collect(p, files, opts, errors);
+    else if (ent.isFile() && TEXT_EXT.test(ent.name)) files.push(path.resolve(p));
+  }
+}
+
+function scoreReport(file, json) {
+  const r = { file, ...lint(bodyOf(fs.readFileSync(file, 'utf8'))) };
+  if (json) {
+    console.log(JSON.stringify({ buvard: CATALOG_VERSION, ...r }, null, 1));
     return;
   }
-  console.error(`buvard: no file or directory for "${target}"`);
+  console.log(`${r.score}/100  ${path.relative(process.cwd(), r.file)} (${r.words} mots, ${r.hits.length} candidat${r.hits.length === 1 ? '' : 's'})`);
 }
 
 function main(argv) {
-  const json = argv.includes('--json');
-  const targets = argv.filter((a) => !a.startsWith('--'));
+  const flags = new Set();
+  const positional = [];
+  for (const a of argv) {
+    if (!a.startsWith('-')) {
+      positional.push(a);
+      continue;
+    }
+    if (a === '--json' || a === '--hidden') {
+      flags.add(a);
+    } else if (a === '-h' || a === '--help') {
+      console.log(USAGE);
+      return 0;
+    } else if (a === '--version') {
+      console.log(`buvard v${PKG_VERSION} (catalog v${CATALOG_VERSION})`);
+      return 0;
+    } else {
+      console.error(`buvard: unknown option "${a}"\n\n${USAGE}`);
+      return 2;
+    }
+  }
+
+  let cmd = 'check';
+  if (positional[0] === 'check' || positional[0] === 'score') cmd = positional.shift();
+
+  const json = flags.has('--json');
+  const opts = { hidden: flags.has('--hidden') };
+  const errors = [];
+
+  if (cmd === 'score') {
+    if (positional.length !== 1) {
+      console.error(`buvard score takes exactly one file\n\n${USAGE}`);
+      return 2;
+    }
+    const files = [];
+    collect(positional[0], files, opts, errors);
+    if (errors.length > 0 || files.length === 0) {
+      errors.forEach((e) => console.error(e));
+      return 2;
+    }
+    scoreReport(files[0], json);
+    return 0;
+  }
+
   const files = [];
-  if (targets.length > 0) targets.forEach((t) => collect(t, files));
-  else collect('.', files);
+  if (positional.length > 0) positional.forEach((t) => collect(t, files, opts, errors));
+  else collect('.', files, opts, errors);
+
+  errors.forEach((e) => console.error(e));
+  if (files.length === 0 && positional.length > 0) return 2;
 
   const results = files.map((file) => ({ file, ...lint(bodyOf(fs.readFileSync(file, 'utf8'))) }));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buvard",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "buvard — l'anti-slop qui tache. Blotting paper for AI-flavored prose: a weighted multi-score linter for French and English slop patterns.",
   "type": "module",
   "bin": {