llm-slop-detector 0.6.2 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.7.0](https://github.com/mandakan/llm-slop-detector/compare/llm-slop-detector-v0.6.2...llm-slop-detector-v0.7.0) (2026-04-24)
+
+
+### Features
+
+* mark files with slop in the explorer ([#62](https://github.com/mandakan/llm-slop-detector/issues/62)) ([ff4e240](https://github.com/mandakan/llm-slop-detector/commit/ff4e2402a1aee52032061b922214756586cd0b01))
+* publish releases to Open VSX Registry ([#60](https://github.com/mandakan/llm-slop-detector/issues/60)) ([b572f87](https://github.com/mandakan/llm-slop-detector/commit/b572f8770139f773e19f9038ef377016cd64a4a4))
+
 ## [0.6.2](https://github.com/mandakan/llm-slop-detector/compare/llm-slop-detector-v0.6.1...llm-slop-detector-v0.6.2) (2026-04-24)
 
 

package/out/extension.js

@@ -84,6 +84,112 @@ function isIgnoredDocument(doc) {
 // Findings keyed by document URI, stashed during scan so the hover provider
 // can recover rule metadata (pattern, matched char) without rescanning.
 const FINDINGS_BY_URI = new Map();
+// Explorer decoration provider. Marks files known to contain slop so users
+// can see where work is pending without having to open each file. Populated
+// lazily from two sources: documents scanned while open, and results from
+// the workspace-scan command. Folders get the color via `propagate: true`;
+// VS Code only re-queries ancestors when we fire events for them, so the
+// provider walks up to the workspace root on every state change.
+class SlopDecorationProvider {
+    emitter = new vscode.EventEmitter();
+    onDidChangeFileDecorations = this.emitter.event;
+    slopyPaths = new Set();
+    setFileState(uri, hasSlop) {
+        if (uri.scheme !== 'file')
+            return;
+        const p = uri.fsPath;
+        const had = this.slopyPaths.has(p);
+        if (had === hasSlop)
+            return;
+        if (hasSlop)
+            this.slopyPaths.add(p);
+        else
+            this.slopyPaths.delete(p);
+        this.emitter.fire(this.urisForPathAndAncestors(p));
+    }
+    applyScanResults(slopyPaths, scannedPaths) {
+        const next = new Set(slopyPaths);
+        const changed = [];
+        for (const p of scannedPaths) {
+            const shouldMark = next.has(p);
+            const isMarked = this.slopyPaths.has(p);
+            if (shouldMark === isMarked)
+                continue;
+            if (shouldMark)
+                this.slopyPaths.add(p);
+            else
+                this.slopyPaths.delete(p);
+            for (const u of this.urisForPathAndAncestors(p))
+                changed.push(u);
+        }
+        if (changed.length > 0)
+            this.emitter.fire(changed);
+    }
+    forgetPath(fsPath) {
+        if (!this.slopyPaths.delete(fsPath))
+            return;
+        this.emitter.fire(this.urisForPathAndAncestors(fsPath));
+    }
+    clearAll() {
+        if (this.slopyPaths.size === 0)
+            return;
+        this.slopyPaths.clear();
+        this.emitter.fire(undefined);
+    }
+    provideFileDecoration(uri) {
+        if (uri.scheme !== 'file')
+            return;
+        if (this.slopyPaths.has(uri.fsPath)) {
+            return {
+                badge: 'S',
+                tooltip: 'Contains LLM slop',
+                color: new vscode.ThemeColor('list.warningForeground'),
+                propagate: true,
+            };
+        }
+        // Folders: return decoration if any tracked file lives under this path.
+        // The tree rarely has more than a handful of slopy files, so an O(n)
+        // scan per folder query is fine and avoids maintaining a separate index.
+        const folderPrefix = uri.fsPath + path.sep;
+        for (const p of this.slopyPaths) {
+            if (p.startsWith(folderPrefix)) {
+                return {
+                    tooltip: 'Contains LLM slop',
+                    color: new vscode.ThemeColor('list.warningForeground'),
+                    propagate: true,
+                };
+            }
+        }
+        return undefined;
+    }
+    urisForPathAndAncestors(fsPath) {
+        const uris = [vscode.Uri.file(fsPath)];
+        const folder = vscode.workspace.workspaceFolders?.find(f => fsPath === f.uri.fsPath || fsPath.startsWith(f.uri.fsPath + path.sep));
+        if (!folder)
+            return uris;
+        let cur = path.dirname(fsPath);
+        const root = folder.uri.fsPath;
+        while (cur.length >= root.length && cur.startsWith(root)) {
+            uris.push(vscode.Uri.file(cur));
+            if (cur === root)
+                break;
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                break;
+            cur = parent;
+        }
+        return uris;
+    }
+}
+let DECORATION_PROVIDER;
+function updateDecorationForDocument(doc, findings) {
+    if (!DECORATION_PROVIDER || doc.uri.scheme !== 'file')
+        return;
+    const cfg = vscode.workspace.getConfiguration('llmSlopDetector');
+    if (!cfg.get('decorateExplorer', true))
+        return;
+    DECORATION_PROVIDER.setFileState(doc.uri, findings.length > 0);
+}
 const PENDING_REFRESH = new Map();
 function cancelPendingRefresh(uriKey) {
     const p = PENDING_REFRESH.get(uriKey);
@@ -217,9 +323,12 @@ function activate(context) {
         if (!enabled || !SUPPORTED_LANGS.has(doc.languageId) || isIgnoredDocument(doc)) {
             collection.delete(doc.uri);
             FINDINGS_BY_URI.delete(doc.uri.toString());
+            updateDecorationForDocument(doc, []);
             return;
         }
-        collection.set(doc.uri, scanDocument(doc));
+        const diags = scanDocument(doc);
+        collection.set(doc.uri, diags);
+        updateDecorationForDocument(doc, diags);
     };
     // Leading+trailing debounce: first change after idle triggers an immediate
     // scan so feedback stays snappy; subsequent changes within the window
@@ -297,9 +406,16 @@ function activate(context) {
         RULES = (0, rules_1.loadRules)(context.extensionUri);
         reloadIgnore();
         rebuildSupportedLangs();
+        const cfg = vscode.workspace.getConfiguration('llmSlopDetector');
+        const decorate = cfg.get('decorateExplorer', true);
+        const enabled = cfg.get('enabled', true);
+        if (!decorate || !enabled)
+            DECORATION_PROVIDER?.clearAll();
         vscode.workspace.textDocuments.forEach(refresh);
         updateStatus();
     };
+    DECORATION_PROVIDER = new SlopDecorationProvider();
+    context.subscriptions.push(vscode.window.registerFileDecorationProvider(DECORATION_PROVIDER));
     reloadRules();
     // Live-reload when a local .llmsloprc.json is created/changed/deleted
     // anywhere in the workspace. The loader itself only reads the files at
@@ -313,7 +429,13 @@ function activate(context) {
         collection.delete(doc.uri);
         FINDINGS_BY_URI.delete(key);
         updateStatus();
-    }), vscode.workspace.onDidChangeWorkspaceFolders(reloadRules), vscode.workspace.onDidGrantWorkspaceTrust(reloadRules), vscode.window.onDidChangeActiveTextEditor(() => updateStatus()), vscode.languages.onDidChangeDiagnostics(() => updateStatus()), vscode.workspace.onDidChangeConfiguration(e => {
+    }), vscode.workspace.onDidChangeWorkspaceFolders(reloadRules), vscode.workspace.onDidDeleteFiles(e => {
+        for (const uri of e.files)
+            DECORATION_PROVIDER?.forgetPath(uri.fsPath);
+    }), vscode.workspace.onDidRenameFiles(e => {
+        for (const { oldUri } of e.files)
+            DECORATION_PROVIDER?.forgetPath(oldUri.fsPath);
+    }), vscode.workspace.onDidGrantWorkspaceTrust(reloadRules), vscode.window.onDidChangeActiveTextEditor(() => updateStatus()), vscode.languages.onDidChangeDiagnostics(() => updateStatus()), vscode.workspace.onDidChangeConfiguration(e => {
         if (e.affectsConfiguration('llmSlopDetector'))
             reloadRules();
     }), vscode.languages.registerCodeActionsProvider(CODE_ACTION_SELECTORS, new SlopCodeActionProvider(), { providedCodeActionKinds: SlopCodeActionProvider.providedCodeActionKinds }), vscode.languages.registerHoverProvider(CODE_ACTION_SELECTORS, new SlopHoverProvider()), vscode.commands.registerCommand('llmSlopDetector.toggle', async () => {
@@ -450,7 +572,7 @@ async function scanWorkspace() {
         return;
     }
     const extensions = buildScanExtensionMap();
-    const hits = await vscode.window.withProgress({
+    const result = await vscode.window.withProgress({
         location: vscode.ProgressLocation.Notification,
         title: 'LLM Slop Detector: scanning workspace',
         cancellable: true,
@@ -471,8 +593,9 @@ async function scanWorkspace() {
         }
         if (token.isCancellationRequested)
             return undefined;
+        const scannedPaths = new Set(targets.map(t => t.absPath));
         if (targets.length === 0)
-            return [];
+            return { hits: [], scannedPaths };
         // Use the in-memory text of any open document so unsaved changes are
         // reflected in the scan, falling back to the on-disk version otherwise.
         const openText = new Map();
@@ -518,10 +641,17 @@ async function scanWorkspace() {
         }));
         if (token.isCancellationRequested)
             return undefined;
-        return out;
+        return { hits: out, scannedPaths };
     });
-    if (hits === undefined)
+    if (result === undefined)
         return;
+    const { hits, scannedPaths } = result;
+    if (cfg.get('decorateExplorer', true) && DECORATION_PROVIDER) {
+        const slopyAbsPaths = new Set();
+        for (const h of hits)
+            slopyAbsPaths.add(h.uri.fsPath);
+        DECORATION_PROVIDER.applyScanResults(slopyAbsPaths, scannedPaths);
+    }
     if (hits.length === 0) {
         vscode.window.showInformationMessage('LLM Slop Detector: no findings in the workspace.');
         return;

package/package.json

@@ -2,7 +2,7 @@
   "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.6.2",
+  "version": "0.7.0",
   "publisher": "thias-se",
   "engines": {
     "vscode": "^1.95.0"
@@ -132,6 +132,11 @@
           "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.decorateExplorer": {
+          "type": "boolean",
+          "default": true,
+          "description": "Mark files in the explorer that are known to contain LLM slop. Updates as you open scanned files; run 'Scan workspace' to populate marks for files you haven't opened."
+        },
         "llmSlopDetector.debounceMs": {
           "type": "number",
           "default": 150,