llm-slop-detector 0.5.0

package/out/cli.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const util_1 = require("util");
+const rules_1 = require("./core/rules");
+const types_1 = require("./core/types");
+const scan_1 = require("./core/scan");
+const ignore_1 = require("./core/ignore");
+const PROSE_EXTENSIONS = new Map([
+    ['.md', 'markdown'],
+    ['.markdown', 'markdown'],
+    ['.mdown', 'markdown'],
+    ['.txt', 'plaintext'],
+    ['.text', 'plaintext'],
+]);
+// Files git passes to commit-msg / prepare-commit-msg hooks, recognised by
+// basename so `llm-slop .git/COMMIT_EDITMSG` works without a flag.
+const GIT_MESSAGE_BASENAMES = new Map([
+    ['COMMIT_EDITMSG', 'git-commit'],
+    ['MERGE_MSG', 'git-commit'],
+    ['TAG_EDITMSG', 'git-commit'],
+    ['EDIT_DESCRIPTION', 'git-commit'],
+]);
+const CODE_EXTENSIONS = new Map([
+    ['.ts', 'typescript'], ['.mts', 'typescript'], ['.cts', 'typescript'],
+    ['.tsx', 'typescriptreact'],
+    ['.js', 'javascript'], ['.mjs', 'javascript'], ['.cjs', 'javascript'],
+    ['.jsx', 'javascriptreact'],
+    ['.py', 'python'],
+    ['.rs', 'rust'],
+    ['.go', 'go'],
+    ['.java', 'java'],
+    ['.cs', 'csharp'],
+    ['.cpp', 'cpp'], ['.cxx', 'cpp'], ['.cc', 'cpp'], ['.hpp', 'cpp'], ['.hxx', 'cpp'],
+    ['.c', 'c'], ['.h', 'c'],
+    ['.rb', 'ruby'],
+    ['.php', 'php'],
+    ['.sh', 'shellscript'], ['.bash', 'shellscript'], ['.zsh', 'shellscript'],
+    ['.swift', 'swift'],
+    ['.kt', 'kotlin'], ['.kts', 'kotlin'],
+    ['.scala', 'scala'], ['.sc', 'scala'],
+    ['.dart', 'dart'],
+    ['.pl', 'perl'], ['.pm', 'perl'],
+    ['.r', 'r'],
+    ['.yaml', 'yaml'], ['.yml', 'yaml'],
+]);
+const HELP = `llm-slop-detector [options] <paths...>
+
+Scan markdown and plaintext files for LLM-style phrases and invisible Unicode.
+With --scan-comments, also scan comments and docstrings in source code.
+
+Options:
+  -f, --format <pretty|json|sarif>  Output format (default: pretty)
+      --pack <name,...>             Enable built-in rule packs
+                                    (${rules_1.BUILTIN_PACKS.join(', ')})
+      --no-builtin                  Skip the built-in core rule list
+      --config <path>               Path to a .llmsloprc.json file
+                                    (default: nearest ancestor of cwd)
+  -s, --severity <level>            Fail threshold: error | warning |
+                                    information | hint (default: information)
+      --scan-comments               Scan comments/docstrings in source code
+                                    files (.ts, .py, .rs, .go, etc)
+      --exclude <pattern>            .gitignore-style pattern to skip. Repeat
+                                    for multiple. Merged with .slopignore.
+      --no-slopignore               Ignore the .slopignore file at cwd
+      --severity-override <k=v>     Override severity for a selector. Repeat
+                                    for multiple. Value: error | warning |
+                                    information | hint | off.
+                                    Selectors: pack:<name>,
+                                    phrase:<pattern>, char:<literal|U+XXXX>,
+                                    source:<name>.
+  -q, --quiet                       Suppress the summary line
+  -h, --help                        Show this help
+  -v, --version                     Print version
+
+Exit code: 0 if no findings at or above the severity threshold, 1 otherwise.
+
+Examples:
+  llm-slop-detector README.md
+  llm-slop-detector --pack academic,cliches docs/
+  llm-slop-detector --format=json . > slop.json
+  llm-slop-detector --scan-comments src/
+`;
+function parseCli(argv) {
+    const parsed = (0, util_1.parseArgs)({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            format: { type: 'string', short: 'f', default: 'pretty' },
+            pack: { type: 'string' },
+            'no-builtin': { type: 'boolean', default: false },
+            config: { type: 'string' },
+            severity: { type: 'string', short: 's', default: 'information' },
+            'scan-comments': { type: 'boolean', default: false },
+            exclude: { type: 'string', multiple: true, default: [] },
+            'no-slopignore': { type: 'boolean', default: false },
+            'severity-override': { type: 'string', multiple: true, default: [] },
+            quiet: { type: 'boolean', short: 'q', default: false },
+            help: { type: 'boolean', short: 'h', default: false },
+            version: { type: 'boolean', short: 'v', default: false },
+        },
+        strict: true,
+    });
+    if (parsed.values.help) {
+        process.stdout.write(HELP);
+        process.exit(0);
+    }
+    if (parsed.values.version) {
+        process.stdout.write(readPackageVersion() + '\n');
+        process.exit(0);
+    }
+    const format = parsed.values.format;
+    if (format !== 'pretty' && format !== 'json' && format !== 'sarif') {
+        die(`unknown --format: ${format}`);
+    }
+    const severityRaw = parsed.values.severity;
+    if (!(severityRaw in types_1.SEVERITY_RANK)) {
+        die(`unknown --severity: ${severityRaw}`);
+    }
+    const packsRaw = parsed.values.pack;
+    const packs = packsRaw ? packsRaw.split(',').map(s => s.trim()).filter(Boolean) : [];
+    for (const p of packs) {
+        if (!rules_1.BUILTIN_PACKS.includes(p)) {
+            die(`unknown pack: ${p}. Known: ${rules_1.BUILTIN_PACKS.join(', ')}`);
+        }
+    }
+    if (parsed.positionals.length === 0) {
+        die('no paths given. Try --help.');
+    }
+    const excludeRaw = parsed.values.exclude;
+    const exclude = Array.isArray(excludeRaw)
+        ? excludeRaw.filter((v) => typeof v === 'string')
+        : typeof excludeRaw === 'string' ? [excludeRaw] : [];
+    const overrideRaw = parsed.values['severity-override'];
+    const overrideSpecs = Array.isArray(overrideRaw)
+        ? overrideRaw.filter((v) => typeof v === 'string')
+        : typeof overrideRaw === 'string' ? [overrideRaw] : [];
+    const rawOverrides = {};
+    const validValues = new Set(['error', 'warning', 'information', 'info', 'hint', 'off']);
+    for (const spec of overrideSpecs) {
+        const eq = spec.indexOf('=');
+        if (eq === -1)
+            die(`invalid --severity-override: ${spec} (expected key=value)`);
+        const key = spec.slice(0, eq).trim();
+        const value = spec.slice(eq + 1).trim();
+        if (key.length === 0)
+            die(`invalid --severity-override: ${spec} (empty selector)`);
+        if (!validValues.has(value)) {
+            die(`invalid --severity-override value: ${spec} (expected error|warning|information|hint|off)`);
+        }
+        rawOverrides[key] = value;
+    }
+    const severityOverrides = (0, rules_1.parseSeverityOverrides)(rawOverrides);
+    return {
+        paths: parsed.positionals,
+        format: format,
+        packs,
+        useBuiltin: !parsed.values['no-builtin'],
+        configPath: parsed.values.config,
+        severity: severityRaw,
+        quiet: parsed.values.quiet,
+        scanComments: parsed.values['scan-comments'],
+        exclude,
+        noIgnoreFile: parsed.values['no-slopignore'],
+        severityOverrides,
+    };
+}
+function die(msg) {
+    process.stderr.write(`llm-slop: ${msg}\n`);
+    process.exit(2);
+}
+function readPackageVersion() {
+    try {
+        const pkgPath = path.resolve(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function extensionRoot() {
+    // Compiled CLI lives at out/cli.js; the extension root is its parent.
+    return path.resolve(__dirname, '..');
+}
+function collectFiles(paths, extensions, ignore, ignoreRoot) {
+    const result = [];
+    for (const p of paths) {
+        const abs = path.resolve(p);
+        let stat;
+        try {
+            stat = fs.statSync(abs);
+        }
+        catch {
+            process.stderr.write(`llm-slop: path not found: ${p}\n`);
+            continue;
+        }
+        if (stat.isFile()) {
+            const ext = path.extname(abs).toLowerCase();
+            const base = path.basename(abs);
+            if (extensions.has(ext) || GIT_MESSAGE_BASENAMES.has(base)) {
+                if (isIgnored(abs, ignoreRoot, ignore, false))
+                    continue;
+                result.push(abs);
+            }
+            else {
+                process.stderr.write(`llm-slop: skipping ${p} (unrecognized extension; add --scan-comments for source code)\n`);
+            }
+        }
+        else if (stat.isDirectory()) {
+            walkDir(abs, extensions, result, ignore, ignoreRoot);
+        }
+    }
+    return result;
+}
+function isIgnored(absPath, ignoreRoot, ignore, isDirectory) {
+    if (ignore.patterns.length === 0)
+        return false;
+    const rel = path.relative(ignoreRoot, absPath);
+    if (rel.length === 0 || rel.startsWith('..'))
+        return false;
+    return ignore.ignores(rel, isDirectory);
+}
+function walkDir(dir, extensions, out, ignore, ignoreRoot) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'out')
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            if (isIgnored(full, ignoreRoot, ignore, true))
+                continue;
+            walkDir(full, extensions, out, ignore, ignoreRoot);
+        }
+        else if (e.isFile() && extensions.has(path.extname(e.name).toLowerCase())) {
+            if (isIgnored(full, ignoreRoot, ignore, false))
+                continue;
+            out.push(full);
+        }
+    }
+}
+function languageFor(file, extensions) {
+    const byBasename = GIT_MESSAGE_BASENAMES.get(path.basename(file));
+    if (byBasename !== undefined)
+        return byBasename;
+    return extensions.get(path.extname(file).toLowerCase()) ?? 'plaintext';
+}
+function scanFile(file, rules, extensions) {
+    const text = fs.readFileSync(file, 'utf8');
+    return (0, scan_1.scanText)(text, rules, languageFor(file, extensions));
+}
+function shouldFail(reports, threshold) {
+    const thresholdRank = types_1.SEVERITY_RANK[threshold];
+    for (const r of reports) {
+        for (const f of r.findings) {
+            if (types_1.SEVERITY_RANK[f.severity] <= thresholdRank)
+                return true;
+        }
+    }
+    return false;
+}
+function formatPretty(reports, quiet) {
+    const lines = [];
+    let total = 0;
+    const counts = { error: 0, warning: 0, information: 0, hint: 0 };
+    const sevTag = { error: 'error', warning: 'warn', information: 'info', hint: 'hint' };
+    for (const r of reports) {
+        if (r.findings.length === 0)
+            continue;
+        const text = fs.readFileSync(r.path, 'utf8');
+        const rel = path.relative(process.cwd(), r.path) || r.path;
+        for (const f of r.findings) {
+            const { line, col } = (0, scan_1.offsetToLineCol)(text, f.offset);
+            lines.push(`${rel}:${line}:${col}  ${sevTag[f.severity].padEnd(5)}  ${f.message}`);
+            counts[f.severity]++;
+            total++;
+        }
+    }
+    if (!quiet) {
+        if (total === 0) {
+            lines.push('No slop found.');
+        }
+        else {
+            const parts = [];
+            for (const s of ['error', 'warning', 'information', 'hint']) {
+                if (counts[s] > 0)
+                    parts.push(`${counts[s]} ${s}`);
+            }
+            lines.push('');
+            lines.push(`${total} finding${total === 1 ? '' : 's'} (${parts.join(', ')})`);
+        }
+    }
+    return lines.join('\n') + (lines.length > 0 ? '\n' : '');
+}
+function formatJson(reports) {
+    const out = [];
+    for (const r of reports) {
+        if (r.findings.length === 0)
+            continue;
+        const text = fs.readFileSync(r.path, 'utf8');
+        const rel = path.relative(process.cwd(), r.path) || r.path;
+        for (const f of r.findings) {
+            const start = (0, scan_1.offsetToLineCol)(text, f.offset);
+            const end = (0, scan_1.offsetToLineCol)(text, f.offset + f.length);
+            out.push({
+                path: rel,
+                line: start.line,
+                col: start.col,
+                endLine: end.line,
+                endCol: end.col,
+                code: f.code,
+                severity: f.severity,
+                message: f.message,
+                source: f.source,
+                rulePattern: f.rulePattern,
+            });
+        }
+    }
+    return JSON.stringify(out, null, 2) + '\n';
+}
+function formatSarif(reports, version) {
+    const sarifLevel = {
+        error: 'error',
+        warning: 'warning',
+        information: 'note',
+        hint: 'note',
+    };
+    const results = [];
+    for (const r of reports) {
+        if (r.findings.length === 0)
+            continue;
+        const text = fs.readFileSync(r.path, 'utf8');
+        const rel = path.relative(process.cwd(), r.path) || r.path;
+        for (const f of r.findings) {
+            const start = (0, scan_1.offsetToLineCol)(text, f.offset);
+            const end = (0, scan_1.offsetToLineCol)(text, f.offset + f.length);
+            results.push({
+                ruleId: f.code === 'char' ? `char:${f.matchText}` : `phrase:${f.rulePattern ?? f.matchText}`,
+                level: sarifLevel[f.severity],
+                message: { text: f.message },
+                locations: [{
+                        physicalLocation: {
+                            artifactLocation: { uri: rel },
+                            region: {
+                                startLine: start.line,
+                                startColumn: start.col,
+                                endLine: end.line,
+                                endColumn: end.col,
+                            },
+                        },
+                    }],
+            });
+        }
+    }
+    const sarif = {
+        $schema: 'https://json.schemastore.org/sarif-2.1.0.json',
+        version: '2.1.0',
+        runs: [{
+                tool: {
+                    driver: {
+                        name: 'llm-slop-detector',
+                        version,
+                        informationUri: 'https://github.com/mandakan/llm-slop-detector',
+                    },
+                },
+                results,
+            }],
+    };
+    return JSON.stringify(sarif, null, 2) + '\n';
+}
+function main() {
+    const opts = parseCli(process.argv.slice(2));
+    const localRulePaths = [];
+    if (opts.configPath) {
+        if (!fs.existsSync(opts.configPath))
+            die(`--config not found: ${opts.configPath}`);
+        localRulePaths.push(path.resolve(opts.configPath));
+    }
+    else {
+        const found = (0, rules_1.findLocalRulePathFromCwd)(process.cwd());
+        if (found)
+            localRulePaths.push(found);
+    }
+    const rules = (0, rules_1.loadRules)({
+        extensionRoot: extensionRoot(),
+        useBuiltin: opts.useBuiltin,
+        enabledPacks: opts.packs,
+        localRulePaths,
+        userPhrases: [],
+        charReplacements: {},
+        severityOverrides: opts.severityOverrides,
+    });
+    const extensions = new Map(PROSE_EXTENSIONS);
+    if (opts.scanComments) {
+        for (const [k, v] of CODE_EXTENSIONS)
+            extensions.set(k, v);
+    }
+    const ignoreRoot = process.cwd();
+    const ignore = (0, ignore_1.loadIgnoreMatcher)(opts.noIgnoreFile ? null : ignoreRoot, opts.exclude);
+    const files = collectFiles(opts.paths, extensions, ignore, ignoreRoot);
+    const reports = files.map(f => ({ path: f, findings: scanFile(f, rules, extensions) }));
+    let output;
+    if (opts.format === 'json')
+        output = formatJson(reports);
+    else if (opts.format === 'sarif')
+        output = formatSarif(reports, readPackageVersion());
+    else
+        output = formatPretty(reports, opts.quiet);
+    process.stdout.write(output);
+    process.exit(shouldFail(reports, opts.severity) ? 1 : 0);
+}
+main();
+//# sourceMappingURL=cli.js.map

package/out/core/comments.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_CODE_LANGUAGES = void 0;
+exports.getCommentScanner = getCommentScanner;
+const C_STYLE_LANGS = new Set([
+    'typescript',
+    'javascript',
+    'typescriptreact',
+    'javascriptreact',
+    'rust',
+    'go',
+    'java',
+    'csharp',
+    'cpp',
+    'c',
+    'php',
+    'swift',
+    'kotlin',
+    'scala',
+    'dart',
+]);
+const PYTHON_LANGS = new Set(['python']);
+const HASH_LANGS = new Set(['ruby', 'shellscript', 'perl', 'r', 'yaml']);
+exports.SUPPORTED_CODE_LANGUAGES = [
+    ...C_STYLE_LANGS,
+    ...PYTHON_LANGS,
+    ...HASH_LANGS,
+].sort();
+function getCommentScanner(language) {
+    if (C_STYLE_LANGS.has(language))
+        return scanCStyleComments;
+    if (PYTHON_LANGS.has(language))
+        return scanPythonComments;
+    if (HASH_LANGS.has(language))
+        return scanHashComments;
+    return null;
+}
+// Extract // line comments and /* */ block comments, skipping contents of
+// string literals (", ', `). Regex literals, division operators, and exotic
+// lexical edge cases are not disambiguated -- acceptable given findings are
+// Information severity and false positives are suppressible inline.
+function scanCStyleComments(text) {
+    const ranges = [];
+    const n = text.length;
+    let i = 0;
+    let inString = null;
+    while (i < n) {
+        const c = text.charCodeAt(i);
+        if (inString !== null) {
+            if (c === 92 /* \ */ && i + 1 < n) {
+                i += 2;
+                continue;
+            }
+            if (text[i] === inString)
+                inString = null;
+            i++;
+            continue;
+        }
+        if (c === 47 /* / */ && i + 1 < n) {
+            const next = text.charCodeAt(i + 1);
+            if (next === 47 /* / */) {
+                const start = i;
+                const nl = text.indexOf('\n', i + 2);
+                const end = nl === -1 ? n : nl;
+                ranges.push([start, end]);
+                i = end;
+                continue;
+            }
+            if (next === 42 /* * */) {
+                const start = i;
+                const close = text.indexOf('*/', i + 2);
+                const end = close === -1 ? n : close + 2;
+                ranges.push([start, end]);
+                i = end;
+                continue;
+            }
+        }
+        if (c === 34 /* " */ || c === 39 /* ' */ || c === 96 /* ` */) {
+            inString = text[i];
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return ranges;
+}
+// Extract # line comments and triple-quoted strings. Triple-quoted strings
+// are scanned whether they're docstrings or raw data -- Option A can't
+// distinguish without a parser, and the issue accepts this tradeoff.
+function scanPythonComments(text) {
+    const ranges = [];
+    const n = text.length;
+    let i = 0;
+    let inString = null;
+    while (i < n) {
+        if (inString !== null) {
+            if (inString.triple) {
+                if (text.startsWith(inString.quote.repeat(3), i)) {
+                    i += 3;
+                    inString = null;
+                    continue;
+                }
+            }
+            else {
+                if (text[i] === '\\' && i + 1 < n) {
+                    i += 2;
+                    continue;
+                }
+                if (text[i] === inString.quote || text[i] === '\n') {
+                    inString = null;
+                }
+            }
+            i++;
+            continue;
+        }
+        if (text.startsWith('"""', i) || text.startsWith("'''", i)) {
+            const quote = text[i];
+            const start = i;
+            i += 3;
+            const closerIdx = text.indexOf(quote.repeat(3), i);
+            const end = closerIdx === -1 ? n : closerIdx + 3;
+            ranges.push([start, end]);
+            i = end;
+            continue;
+        }
+        if (text[i] === '#') {
+            const start = i;
+            const nl = text.indexOf('\n', i + 1);
+            const end = nl === -1 ? n : nl;
+            ranges.push([start, end]);
+            i = end;
+            continue;
+        }
+        if (text[i] === '"' || text[i] === "'") {
+            inString = { quote: text[i], triple: false };
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return ranges;
+}
+// Extract # line comments, skipping contents of string literals.
+// Works for Ruby, shell, Perl, R, YAML, etc. Heredocs and `$# ` parameter
+// expansion are not specially handled.
+function scanHashComments(text) {
+    const ranges = [];
+    const n = text.length;
+    let i = 0;
+    let inString = null;
+    while (i < n) {
+        if (inString !== null) {
+            if (text[i] === '\\' && i + 1 < n) {
+                i += 2;
+                continue;
+            }
+            if (text[i] === inString || text[i] === '\n')
+                inString = null;
+            i++;
+            continue;
+        }
+        if (text[i] === '#') {
+            const start = i;
+            const nl = text.indexOf('\n', i + 1);
+            const end = nl === -1 ? n : nl;
+            ranges.push([start, end]);
+            i = end;
+            continue;
+        }
+        if (text[i] === '"' || text[i] === "'") {
+            inString = text[i];
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return ranges;
+}
+//# sourceMappingURL=comments.js.map