llm-slop-detector 0.5.0

package/out/core/ignore.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLOPIGNORE_FILENAME = void 0;
+exports.parseIgnorePatterns = parseIgnorePatterns;
+exports.buildIgnoreMatcher = buildIgnoreMatcher;
+exports.loadIgnoreMatcher = loadIgnoreMatcher;
+const fs = require("fs");
+const path = require("path");
+exports.SLOPIGNORE_FILENAME = '.slopignore';
+// Parse .gitignore-style pattern lines into matchers. Blank lines and lines
+// starting with `#` are skipped. `!foo` negates; trailing `/` means
+// directory-only; a leading `/` or an internal `/` anchors to the root; a bare
+// name matches at any depth.
+function parseIgnorePatterns(lines) {
+    const out = [];
+    for (const rawLine of lines) {
+        let line = rawLine.replace(/\r$/, '');
+        // Strip unescaped trailing whitespace. `\ ` preserves a trailing space.
+        line = line.replace(/(?:^|[^\\])\s+$/, m => {
+            const first = m[0];
+            return first === ' ' || first === '\t' ? '' : first;
+        });
+        if (line.length === 0)
+            continue;
+        if (line.startsWith('#'))
+            continue;
+        if (line.startsWith('\\#'))
+            line = line.slice(1);
+        let negate = false;
+        if (line.startsWith('!')) {
+            negate = true;
+            line = line.slice(1);
+        }
+        let dirOnly = false;
+        if (line.endsWith('/')) {
+            dirOnly = true;
+            line = line.slice(0, -1);
+        }
+        if (line.length === 0)
+            continue;
+        let rooted;
+        if (line.startsWith('/')) {
+            rooted = true;
+            line = line.slice(1);
+        }
+        else {
+            rooted = line.includes('/');
+        }
+        const regex = globToRegex(line, rooted);
+        out.push({ raw: rawLine, negate, dirOnly, regex });
+    }
+    return out;
+}
+function escapeRegexChar(c) {
+    return /[.+^${}()|[\]\\/]/.test(c) ? '\\' + c : c;
+}
+function globToRegex(pattern, rooted) {
+    let re = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                if (pattern[i + 2] === '/') {
+                    re += '(?:.*/)?';
+                    i += 3;
+                    continue;
+                }
+                re += '.*';
+                i += 2;
+                continue;
+            }
+            re += '[^/]*';
+            i++;
+            continue;
+        }
+        if (c === '?') {
+            re += '[^/]';
+            i++;
+            continue;
+        }
+        if (c === '[') {
+            const j = pattern.indexOf(']', i + 1);
+            if (j !== -1) {
+                re += pattern.slice(i, j + 1);
+                i = j + 1;
+                continue;
+            }
+            re += '\\[';
+            i++;
+            continue;
+        }
+        if (c === '\\' && i + 1 < pattern.length) {
+            re += escapeRegexChar(pattern[i + 1]);
+            i += 2;
+            continue;
+        }
+        re += escapeRegexChar(c);
+        i++;
+    }
+    const prefix = rooted ? '^' : '^(?:.*/)?';
+    // Trailing "(?:/.*)?$" lets a directory pattern ("docs" or "docs/") match
+    // every descendant without a second pass.
+    const suffix = '(?:/.*)?$';
+    return new RegExp(prefix + re + suffix);
+}
+function toPosix(p) {
+    return p.replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\//, '');
+}
+function buildIgnoreMatcher(patterns) {
+    return {
+        patterns,
+        ignores(relPath, isDirectory) {
+            const normalized = toPosix(relPath);
+            if (normalized.length === 0)
+                return false;
+            let ignored = false;
+            for (const p of patterns) {
+                if (p.dirOnly && isDirectory === false)
+                    continue;
+                if (p.regex.test(normalized)) {
+                    ignored = !p.negate;
+                }
+            }
+            return ignored;
+        },
+    };
+}
+function loadIgnoreMatcher(rootDir, extraPatterns = []) {
+    const lines = [];
+    if (rootDir !== null) {
+        const file = path.join(rootDir, exports.SLOPIGNORE_FILENAME);
+        try {
+            const text = fs.readFileSync(file, 'utf8');
+            lines.push(...text.split(/\r?\n/));
+        }
+        catch {
+            // No .slopignore present -- fall through to just the extra patterns.
+        }
+    }
+    for (const p of extraPatterns) {
+        if (typeof p === 'string')
+            lines.push(p);
+    }
+    return buildIgnoreMatcher(parseIgnorePatterns(lines));
+}
+//# sourceMappingURL=ignore.js.map

package/out/core/rules.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_PACKS = exports.LOCAL_RULES_FILENAME = void 0;
+exports.parseSeverityOverrides = parseSeverityOverrides;
+exports.loadRules = loadRules;
+exports.findLocalRulePathFromCwd = findLocalRulePathFromCwd;
+const fs = require("fs");
+const path = require("path");
+exports.LOCAL_RULES_FILENAME = '.llmsloprc.json';
+exports.BUILTIN_PACKS = ['academic', 'cliches', 'fiction', 'claudeisms', 'structural', 'security'];
+function parseSeverity(s, fallback) {
+    switch (s) {
+        case 'error': return 'error';
+        case 'warning': return 'warning';
+        case 'information':
+        case 'info': return 'information';
+        case 'hint': return 'hint';
+        default: return fallback;
+    }
+}
+// Chars in the invisible/zero-width ranges are dangerous (hide in text,
+// break diffs, enable Trojan Source attacks); visible punctuation is merely suspicious.
+function defaultCharSeverity(char) {
+    const code = char.codePointAt(0);
+    const invisible = code === 0x00AD ||
+        code === 0x00A0 ||
+        code === 0x1160 ||
+        code === 0x180E ||
+        (code >= 0x200B && code <= 0x200F) ||
+        (code >= 0x202A && code <= 0x202E) ||
+        code === 0x202F ||
+        code === 0x2028 || code === 0x2029 ||
+        code === 0x2060 ||
+        (code >= 0x2066 && code <= 0x2069) ||
+        code === 0x3164 ||
+        code === 0xFEFF;
+    return invisible ? 'warning' : 'information';
+}
+function ingestList(raw, origin, target) {
+    const name = typeof raw.name === 'string' ? raw.name : origin;
+    let charCount = 0;
+    let phraseCount = 0;
+    if (Array.isArray(raw.chars)) {
+        for (const c of raw.chars) {
+            if (typeof c.char !== 'string' || c.char.length === 0)
+                continue;
+            const charStr = c.char;
+            target.chars.set(charStr, {
+                char: charStr,
+                name: typeof c.name === 'string'
+                    ? c.name
+                    : `Unknown char (U+${charStr.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')})`,
+                severity: parseSeverity(c.severity, defaultCharSeverity(charStr)),
+                replacement: typeof c.replacement === 'string' ? c.replacement : undefined,
+                suggestion: typeof c.suggestion === 'string' ? c.suggestion : undefined,
+                source: name,
+            });
+            charCount++;
+        }
+    }
+    if (Array.isArray(raw.phrases)) {
+        for (const p of raw.phrases) {
+            if (typeof p.pattern !== 'string' || p.pattern.length === 0)
+                continue;
+            let regex;
+            try {
+                regex = new RegExp(p.pattern, 'gi');
+            }
+            catch (e) {
+                console.warn(`[LLM Slop] Invalid regex in ${origin}: ${p.pattern}`, e);
+                continue;
+            }
+            target.phrases.push({
+                pattern: p.pattern,
+                regex,
+                reason: typeof p.reason === 'string' ? p.reason : undefined,
+                severity: parseSeverity(p.severity, 'information'),
+                source: name,
+            });
+            phraseCount++;
+        }
+    }
+    target.sources.push({
+        name,
+        version: typeof raw.version === 'string' ? raw.version : undefined,
+        description: typeof raw.description === 'string' ? raw.description : undefined,
+        origin,
+        charCount,
+        phraseCount,
+    });
+}
+function readJsonFile(p) {
+    try {
+        const text = fs.readFileSync(p, 'utf8');
+        const parsed = JSON.parse(text);
+        if (typeof parsed === 'object' && parsed !== null)
+            return parsed;
+        console.warn(`[LLM Slop] ${p} is not a JSON object`);
+        return null;
+    }
+    catch (e) {
+        console.warn(`[LLM Slop] Failed to read ${p}:`, e);
+        return null;
+    }
+}
+function buildCharRegex(chars) {
+    if (chars.size === 0)
+        return /(?!)/g;
+    const body = Array.from(chars.keys())
+        .map(c => '\\u{' + c.codePointAt(0).toString(16) + '}')
+        .join('');
+    return new RegExp('[' + body + ']', 'gu');
+}
+function charCodepointSelector(char) {
+    return `char:U+${char.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')}`;
+}
+// Normalize `char:u+2014` / `char:U+2014` / `char:U+02014` to a single canonical
+// key so lookups don't depend on user casing or zero-padding. Literal char keys
+// (`char:—`) and non-char selectors pass through unchanged.
+function normalizeOverrideKey(key) {
+    if (!key.startsWith('char:'))
+        return key;
+    const rest = key.slice(5);
+    const m = /^[uU]\+([0-9a-fA-F]+)$/.exec(rest);
+    if (!m)
+        return key;
+    const cp = parseInt(m[1], 16);
+    if (Number.isNaN(cp))
+        return key;
+    return `char:U+${cp.toString(16).toUpperCase().padStart(4, '0')}`;
+}
+function parseSeverityOverrideValue(v) {
+    if (v === 'off')
+        return 'off';
+    if (v === 'error' || v === 'warning' || v === 'hint')
+        return v;
+    if (v === 'information' || v === 'info')
+        return 'information';
+    return null;
+}
+// Canonicalize user-provided override map: normalize char selector keys and
+// validate/coerce values. Invalid values are dropped with a console warning.
+function parseSeverityOverrides(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const parsed = parseSeverityOverrideValue(value);
+        if (parsed === null) {
+            console.warn(`[LLM Slop] invalid severity in severityOverrides for "${key}": ${String(value)}`);
+            continue;
+        }
+        out[normalizeOverrideKey(key)] = parsed;
+    }
+    return out;
+}
+function resolveCharOverride(rule, overrides) {
+    // Most specific: rule-level. Literal first so `char:—: hint` beats
+    // `char:U+2014: off` when both are present.
+    const literal = `char:${rule.char}`;
+    if (literal in overrides)
+        return overrides[literal];
+    const cp = charCodepointSelector(rule.char);
+    if (cp in overrides)
+        return overrides[cp];
+    // Pack-level (source is `pack:<name>` for built-in packs).
+    if (rule.source.startsWith('pack:') && rule.source in overrides)
+        return overrides[rule.source];
+    // Source-level.
+    const src = `source:${rule.source}`;
+    if (src in overrides)
+        return overrides[src];
+    return undefined;
+}
+function resolvePhraseOverride(rule, overrides) {
+    const phraseKey = `phrase:${rule.pattern}`;
+    if (phraseKey in overrides)
+        return overrides[phraseKey];
+    if (rule.source.startsWith('pack:') && rule.source in overrides)
+        return overrides[rule.source];
+    const src = `source:${rule.source}`;
+    if (src in overrides)
+        return overrides[src];
+    return undefined;
+}
+function applySeverityOverrides(rules, overrides) {
+    if (Object.keys(overrides).length === 0)
+        return;
+    let applied = 0;
+    const charsToDelete = [];
+    for (const [char, rule] of rules.chars) {
+        const ov = resolveCharOverride(rule, overrides);
+        if (ov === undefined)
+            continue;
+        applied++;
+        if (ov === 'off')
+            charsToDelete.push(char);
+        else
+            rules.chars.set(char, { ...rule, severity: ov });
+    }
+    for (const c of charsToDelete)
+        rules.chars.delete(c);
+    const remainingPhrases = [];
+    for (const phrase of rules.phrases) {
+        const ov = resolvePhraseOverride(phrase, overrides);
+        if (ov === undefined) {
+            remainingPhrases.push(phrase);
+            continue;
+        }
+        applied++;
+        if (ov === 'off')
+            continue;
+        remainingPhrases.push({ ...phrase, severity: ov });
+    }
+    rules.phrases = remainingPhrases;
+    // Recompute per-source counts so the rule-sources quick pick reflects
+    // effective rule counts rather than raw ingest counts.
+    const countBySource = new Map();
+    const bump = (name, kind) => {
+        const entry = countBySource.get(name) ?? { chars: 0, phrases: 0 };
+        entry[kind]++;
+        countBySource.set(name, entry);
+    };
+    for (const r of rules.chars.values())
+        bump(r.source, 'chars');
+    for (const r of rules.phrases)
+        bump(r.source, 'phrases');
+    for (const src of rules.sources) {
+        const c = countBySource.get(src.name);
+        src.charCount = c?.chars ?? 0;
+        src.phraseCount = c?.phrases ?? 0;
+    }
+    rules.overridesApplied = applied;
+}
+function loadRules(opts) {
+    const rules = {
+        chars: new Map(),
+        phrases: [],
+        sources: [],
+        charRegex: /(?!)/g,
+        overridesApplied: 0,
+    };
+    if (opts.useBuiltin) {
+        const builtinPath = path.join(opts.extensionRoot, 'builtin-rules.json');
+        const raw = readJsonFile(builtinPath);
+        if (raw)
+            ingestList(raw, 'built-in', rules);
+    }
+    const allowed = new Set(exports.BUILTIN_PACKS);
+    for (const pack of opts.enabledPacks) {
+        if (!allowed.has(pack))
+            continue;
+        const packPath = path.join(opts.extensionRoot, 'builtin-packs', `${pack}.json`);
+        const raw = readJsonFile(packPath);
+        if (raw)
+            ingestList(raw, `pack:${pack}`, rules);
+    }
+    for (const p of opts.localRulePaths) {
+        const raw = readJsonFile(p);
+        if (raw)
+            ingestList(raw, p, rules);
+    }
+    if (opts.userPhrases.length > 0) {
+        ingestList({ name: 'user settings', phrases: opts.userPhrases.map(pattern => ({ pattern })) }, 'settings.json', rules);
+    }
+    for (const [char, replacement] of Object.entries(opts.charReplacements)) {
+        const existing = rules.chars.get(char);
+        if (existing) {
+            rules.chars.set(char, {
+                ...existing,
+                replacement,
+                source: `${existing.source} + settings`,
+            });
+        }
+        else {
+            rules.chars.set(char, {
+                char,
+                name: `User-defined (U+${char.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')})`,
+                severity: defaultCharSeverity(char),
+                replacement,
+                source: 'settings.json',
+            });
+        }
+    }
+    applySeverityOverrides(rules, opts.severityOverrides);
+    rules.charRegex = buildCharRegex(rules.chars);
+    return rules;
+}
+function findLocalRulePathFromCwd(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        const candidate = path.join(dir, exports.LOCAL_RULES_FILENAME);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+//# sourceMappingURL=rules.js.map