llm-slop-detector 0.5.0

package/out/mcp.js

@@ -0,0 +1,265 @@
+#!/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 index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const rules_1 = require("./core/rules");
+const scan_1 = require("./core/scan");
+const HELP = `llm-slop-mcp [options]
+
+Stdio MCP server that exposes the LLM Slop Detector as a tool. Intended to be
+spawned by MCP clients (Claude Code, etc), not run interactively.
+
+Options:
+  --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)
+  -h, --help          Show this help
+  -v, --version       Print version
+
+Environment variables (override CLI flags when set):
+  LLM_SLOP_PACKS       Comma-separated list of packs
+  LLM_SLOP_NO_BUILTIN  Set to "1" or "true" to skip built-in rules
+  LLM_SLOP_CONFIG      Path to a .llmsloprc.json file
+
+Tools exposed:
+  scan_text  Input: { text, language?, packs? }  -> Finding[]
+  list_rules Input: { source? }                   -> rule summary
+`;
+function die(msg) {
+    process.stderr.write(`llm-slop-mcp: ${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 parseStartup(argv) {
+    const parsed = (0, util_1.parseArgs)({
+        args: argv,
+        allowPositionals: false,
+        options: {
+            pack: { type: 'string' },
+            'no-builtin': { type: 'boolean', default: false },
+            config: { type: 'string' },
+            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 envPacks = process.env.LLM_SLOP_PACKS;
+    const packsRaw = envPacks ?? 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(', ')}`);
+        }
+    }
+    const envNoBuiltin = process.env.LLM_SLOP_NO_BUILTIN;
+    const envNoBuiltinSet = envNoBuiltin === '1' || envNoBuiltin === 'true';
+    const useBuiltin = !(envNoBuiltinSet || parsed.values['no-builtin']);
+    const envConfig = process.env.LLM_SLOP_CONFIG;
+    const configPath = envConfig ?? parsed.values.config;
+    const localRulePaths = [];
+    if (configPath) {
+        if (!fs.existsSync(configPath))
+            die(`--config not found: ${configPath}`);
+        localRulePaths.push(path.resolve(configPath));
+    }
+    else {
+        const found = (0, rules_1.findLocalRulePathFromCwd)(process.cwd());
+        if (found)
+            localRulePaths.push(found);
+    }
+    return {
+        extensionRoot: path.resolve(__dirname, '..'),
+        useBuiltin,
+        packs,
+        localRulePaths,
+    };
+}
+function buildRules(cfg, packOverride) {
+    return (0, rules_1.loadRules)({
+        extensionRoot: cfg.extensionRoot,
+        useBuiltin: cfg.useBuiltin,
+        enabledPacks: packOverride ?? cfg.packs,
+        localRulePaths: cfg.localRulePaths,
+        userPhrases: [],
+        charReplacements: {},
+        severityOverrides: {},
+    });
+}
+function validatePackList(packs) {
+    if (!Array.isArray(packs)) {
+        throw new Error('packs must be an array of strings');
+    }
+    const out = [];
+    for (const p of packs) {
+        if (typeof p !== 'string')
+            throw new Error('packs must be an array of strings');
+        if (!rules_1.BUILTIN_PACKS.includes(p)) {
+            throw new Error(`unknown pack: ${p}. Known: ${rules_1.BUILTIN_PACKS.join(', ')}`);
+        }
+        out.push(p);
+    }
+    return out;
+}
+function handleScanText(args, cfg, defaultRules) {
+    const text = args.text;
+    if (typeof text !== 'string')
+        throw new Error('text must be a string');
+    const language = typeof args.language === 'string' ? args.language : 'markdown';
+    let rules = defaultRules;
+    if (args.packs !== undefined) {
+        const packs = validatePackList(args.packs);
+        rules = buildRules(cfg, packs);
+    }
+    const findings = (0, scan_1.scanText)(text, rules, language);
+    return findings.map(f => {
+        const start = (0, scan_1.offsetToLineCol)(text, f.offset);
+        const end = (0, scan_1.offsetToLineCol)(text, f.offset + f.length);
+        return {
+            line: start.line,
+            col: start.col,
+            endLine: end.line,
+            endCol: end.col,
+            offset: f.offset,
+            length: f.length,
+            matchText: f.matchText,
+            code: f.code,
+            severity: f.severity,
+            message: f.message,
+            source: f.source,
+            rulePattern: f.rulePattern,
+        };
+    });
+}
+function handleListRules(args, rules) {
+    const sourceFilter = typeof args.source === 'string' ? args.source : undefined;
+    const chars = Array.from(rules.chars.values())
+        .filter(c => sourceFilter === undefined || c.source === sourceFilter)
+        .map(c => ({
+        char: c.char,
+        codepoint: `U+${c.char.codePointAt(0).toString(16).toUpperCase().padStart(4, '0')}`,
+        name: c.name,
+        severity: c.severity,
+        replacement: c.replacement,
+        suggestion: c.suggestion,
+        source: c.source,
+    }));
+    const phrases = rules.phrases
+        .filter(p => sourceFilter === undefined || p.source === sourceFilter)
+        .map(p => ({
+        pattern: p.pattern,
+        reason: p.reason,
+        severity: p.severity,
+        source: p.source,
+    }));
+    return {
+        sources: rules.sources,
+        chars,
+        phrases,
+        overridesApplied: rules.overridesApplied,
+    };
+}
+async function main() {
+    const cfg = parseStartup(process.argv.slice(2));
+    const defaultRules = buildRules(cfg);
+    const server = new index_js_1.Server({ name: 'llm-slop-detector', version: readPackageVersion() }, { capabilities: { tools: {} } });
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'scan_text',
+                description: 'Scan text for LLM-style phrases and invisible Unicode using the LLM Slop Detector ruleset. Returns an array of findings with line/col positions. Use language="markdown" (default) to honour fenced code / frontmatter exclusions, "plaintext" to scan everything, or a source-code language id (typescript, python, etc) to scan only comments and docstrings.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        text: {
+                            type: 'string',
+                            description: 'The text to scan.',
+                        },
+                        language: {
+                            type: 'string',
+                            description: 'Language id. Defaults to "markdown". Use "plaintext", "markdown", "git-commit", or a code language id (typescript, python, rust, go, etc).',
+                        },
+                        packs: {
+                            type: 'array',
+                            items: { type: 'string', enum: [...rules_1.BUILTIN_PACKS] },
+                            description: 'Override the server\'s enabled packs for this call.',
+                        },
+                    },
+                    required: ['text'],
+                },
+            },
+            {
+                name: 'list_rules',
+                description: 'List the rules currently loaded by the server (chars and phrases), optionally filtered by source name.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        source: {
+                            type: 'string',
+                            description: 'Only include rules whose source matches this name (e.g. "built-in", "pack:academic").',
+                        },
+                    },
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const argsObj = (args ?? {});
+        try {
+            if (name === 'scan_text') {
+                const findings = handleScanText(argsObj, cfg, defaultRules);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(findings, null, 2) }],
+                };
+            }
+            if (name === 'list_rules') {
+                const summary = handleListRules(argsObj, defaultRules);
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }],
+                };
+            }
+            return {
+                content: [{ type: 'text', text: `unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            return {
+                content: [{ type: 'text', text: msg }],
+                isError: true,
+            };
+        }
+    });
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(e => {
+    process.stderr.write(`llm-slop-mcp: fatal: ${e instanceof Error ? e.stack ?? e.message : String(e)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=mcp.js.map

package/out/rules.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_PACKS = exports.LOCAL_RULES_FILENAME = void 0;
+exports.severityToVscode = severityToVscode;
+exports.loadRules = loadRules;
+const vscode = require("vscode");
+const fs = require("fs");
+const path = require("path");
+const rules_1 = require("./core/rules");
+Object.defineProperty(exports, "BUILTIN_PACKS", { enumerable: true, get: function () { return rules_1.BUILTIN_PACKS; } });
+Object.defineProperty(exports, "LOCAL_RULES_FILENAME", { enumerable: true, get: function () { return rules_1.LOCAL_RULES_FILENAME; } });
+function severityToVscode(s) {
+    switch (s) {
+        case 'error': return vscode.DiagnosticSeverity.Error;
+        case 'warning': return vscode.DiagnosticSeverity.Warning;
+        case 'information': return vscode.DiagnosticSeverity.Information;
+        case 'hint': return vscode.DiagnosticSeverity.Hint;
+    }
+}
+function getLocalRulePaths() {
+    // Workspace rule files ship arbitrary regex. In an untrusted workspace we
+    // fall back to built-in rules only; a catastrophic-backtracking pattern in
+    // a random repo shouldn't be able to wedge the extension host.
+    if (!vscode.workspace.isTrusted)
+        return [];
+    const paths = [];
+    for (const folder of vscode.workspace.workspaceFolders ?? []) {
+        const p = path.join(folder.uri.fsPath, rules_1.LOCAL_RULES_FILENAME);
+        if (fs.existsSync(p))
+            paths.push(p);
+    }
+    return paths;
+}
+function loadRules(extensionUri) {
+    const cfg = vscode.workspace.getConfiguration('llmSlopDetector');
+    return (0, rules_1.loadRules)({
+        extensionRoot: extensionUri.fsPath,
+        useBuiltin: cfg.get('useBuiltinRules', true),
+        enabledPacks: cfg.get('enabledPacks', []),
+        localRulePaths: getLocalRulePaths(),
+        userPhrases: cfg.get('phrases', []),
+        charReplacements: cfg.get('charReplacements', {}),
+        severityOverrides: (0, rules_1.parseSeverityOverrides)(cfg.get('severityOverrides', {})),
+    });
+}
+//# sourceMappingURL=rules.js.map

package/package.json

@@ -0,0 +1,228 @@
+{
+  "name": "llm-slop-detector",
+  "displayName": "LLM Slop Detector",
+  "description": "Highlights invisible Unicode, AI-style punctuation, and telltale LLM phrases in markdown and plain text.",
+  "version": "0.5.0",
+  "publisher": "thias-se",
+  "engines": {
+    "vscode": "^1.95.0"
+  },
+  "categories": [
+    "Linters",
+    "Other"
+  ],
+  "keywords": [
+    "llm",
+    "ai",
+    "slop",
+    "unicode",
+    "markdown",
+    "plaintext",
+    "linter",
+    "writing",
+    "chatgpt",
+    "claude"
+  ],
+  "icon": "icon.png",
+  "galleryBanner": {
+    "color": "#1e1e1e",
+    "theme": "dark"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mandakan/llm-slop-detector.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mandakan/llm-slop-detector/issues"
+  },
+  "activationEvents": [
+    "onLanguage:markdown",
+    "onLanguage:plaintext",
+    "onLanguage:git-commit",
+    "onLanguage:scminput",
+    "onStartupFinished"
+  ],
+  "main": "./out/extension.js",
+  "bin": {
+    "llm-slop": "./out/cli.js",
+    "llm-slop-mcp": "./out/mcp.js"
+  },
+  "capabilities": {
+    "untrustedWorkspaces": {
+      "supported": "limited",
+      "description": "In an untrusted workspace, local .llmsloprc.json files are skipped to avoid running arbitrary regex patterns from an unknown source. Built-in rules, packs, and user-level settings still apply."
+    }
+  },
+  "contributes": {
+    "configuration": {
+      "title": "LLM Slop Detector",
+      "properties": {
+        "llmSlopDetector.enabled": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable or disable the detector."
+        },
+        "llmSlopDetector.useBuiltinRules": {
+          "type": "boolean",
+          "default": true,
+          "description": "Load the built-in rule list shipped with the extension. Disable this if you want to rely solely on local rule files (.llmsloprc.json) and/or user settings."
+        },
+        "llmSlopDetector.enabledPacks": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "academic",
+              "cliches",
+              "fiction",
+              "claudeisms",
+              "structural",
+              "security"
+            ],
+            "enumDescriptions": [
+              "Words over-represented in LLM-authored academic writing (derived from berenslab/llm-excess-vocab, MIT)",
+              "General LLM cliche adjectives/nouns/verbs (derived from nanxstats/llm-cliches, MIT)",
+              "Fiction and creative-writing LLM tells, including NSFW markers (derived from SicariusSicariiStuff/SLOP_Detector, Apache-2.0)",
+              "Claude-specific mannerisms and sycophantic consent-theater phrasing (derived from SicariusSicariiStuff/SLOP_Detector, Apache-2.0)",
+              "Structural LLM tells: 'not X but Y', sycophantic openers, meta-commentary",
+              "Flags LLM-weaponized invisibles above the BMP: tag chars (ASCII-smuggler prompt injection) and variation selectors (arbitrary-data smuggling). Severity: error."
+            ]
+          },
+          "default": [],
+          "uniqueItems": true,
+          "description": "Optional built-in rule packs to enable on top of the core rule list. See THIRD_PARTY_NOTICES.md for attribution."
+        },
+        "llmSlopDetector.phrases": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "Additional regex patterns to flag as LLM phrases, appended to the built-in list and any local rule files. Case-insensitive. Use \\b for word boundaries. For richer rule metadata (reason, severity) use a .llmsloprc.json file in your workspace root."
+        },
+        "llmSlopDetector.charReplacements": {
+          "type": "object",
+          "default": {},
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Override quick-fix replacements for specific characters. Key: the flagged character (e.g. \"—\" for em dash). Value: the replacement string. User overrides win over built-in and local-file rules."
+        },
+        "llmSlopDetector.severityOverrides": {
+          "type": "object",
+          "default": {},
+          "additionalProperties": {
+            "type": "string",
+            "enum": [
+              "error",
+              "warning",
+              "information",
+              "hint",
+              "off"
+            ]
+          },
+          "description": "Override severity for specific rules, packs, or sources. Selector keys: pack:<name> (e.g. pack:academic), phrase:<exact-pattern>, char:<literal> or char:U+XXXX, source:<name>. Values: error | warning | information | hint | off (off disables the rule entirely). Precedence: phrase/char > pack > source -- most specific wins. Example: {\"pack:academic\": \"hint\", \"phrase:\\\\bdelve(s|d|ing)?\\\\b\": \"off\"}."
+        },
+        "llmSlopDetector.exclude": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [],
+          "description": "File-glob patterns to skip, using .gitignore syntax. Merged with patterns from a .slopignore file at the workspace root. Example: [\"CHANGELOG.md\", \"docs/generated/**\"]. Use !pattern to re-include after a broader ignore."
+        },
+        "llmSlopDetector.debounceMs": {
+          "type": "number",
+          "default": 150,
+          "minimum": 0,
+          "maximum": 2000,
+          "description": "Milliseconds to wait after the last edit before rescanning the document. Collapses rapid keystrokes into a single scan. Set to 0 for instant feedback on small files."
+        },
+        "llmSlopDetector.scanCodeComments": {
+          "type": "boolean",
+          "default": false,
+          "description": "Scan comments and docstrings in source code files for LLM slop. Off by default; enable to widen scanning beyond markdown and plaintext."
+        },
+        "llmSlopDetector.scanCommitMessages": {
+          "type": "boolean",
+          "default": true,
+          "description": "Scan Git commit editor buffers (git-commit) and VS Code's Source Control input box (scminput). On by default -- commit messages are short and findings are actionable. Turn off to silence diagnostics in those buffers."
+        },
+        "llmSlopDetector.codeCommentLanguages": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [
+            "typescript",
+            "javascript",
+            "typescriptreact",
+            "javascriptreact",
+            "python",
+            "rust",
+            "go",
+            "java",
+            "csharp",
+            "cpp",
+            "c",
+            "ruby",
+            "php",
+            "shellscript"
+          ],
+          "uniqueItems": true,
+          "description": "VS Code language IDs whose comments are scanned when scanCodeComments is true. Supported: typescript, javascript, typescriptreact, javascriptreact, python, rust, go, java, csharp, cpp, c, ruby, php, shellscript, swift, kotlin, scala, dart, perl, r, yaml. Unknown language IDs are ignored."
+        }
+      }
+    },
+    "jsonValidation": [
+      {
+        "fileMatch": [
+          ".llmsloprc.json",
+          ".llmsloprc.jsonc"
+        ],
+        "url": "./schemas/llmsloprc.schema.json"
+      }
+    ],
+    "commands": [
+      {
+        "command": "llmSlopDetector.toggle",
+        "title": "LLM Slop Detector: Toggle"
+      },
+      {
+        "command": "llmSlopDetector.openSettings",
+        "title": "LLM Slop Detector: Open settings"
+      },
+      {
+        "command": "llmSlopDetector.showRuleSources",
+        "title": "LLM Slop Detector: Show loaded rule sources"
+      },
+      {
+        "command": "llmSlopDetector.showOnboarding",
+        "title": "LLM Slop Detector: Show onboarding"
+      },
+      {
+        "command": "llmSlopDetector.scanSelection",
+        "title": "LLM Slop Detector: Scan selection"
+      },
+      {
+        "command": "llmSlopDetector.scanWorkspace",
+        "title": "LLM Slop Detector: Scan workspace"
+      }
+    ]
+  },
+  "scripts": {
+    "compile": "tsc -p ./ && chmod +x out/cli.js out/mcp.js",
+    "watch": "tsc -watch -p ./",
+    "package": "npx --yes @vscode/vsce package",
+    "slop": "node ./out/cli.js"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "@types/vscode": "^1.95.0",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  }
+}