fix: branch coverage parsing, UI consistency, and sidebar accuracy

package.json

@@ -2,13 +2,13 @@
   "name": "coverage-visualizer",
   "displayName": "Python Coverage Visualizer",
   "description": "Visualize Python test coverage inline in VS Code — highlights, CodeLens, dashboard, and sidebar tree view",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "publisher": "kool7",
   "engines": {
     "vscode": "^1.90.0"
   },
   "license": "MIT",
-  "icon": "assets/icon-128.png",
+  "icon": "assets/icon-256.png",
   "categories": [
     "Testing",
     "Visualization",
@@ -104,6 +104,11 @@
           "type": "string",
           "default": "coverage.json",
           "description": "Path to coverage.json relative to workspace root. Generate with: pytest --cov=. --cov-report=json"
+        },
+        "coverageVisualizer.excludeTestFiles": {
+          "type": "boolean",
+          "default": true,
+          "description": "Skip decorations and CodeLens on test files (test_*.py, *_test.py, files inside tests/ directories)."
         }
       }
     }

src/config.ts

@@ -8,6 +8,7 @@ export interface Config {
   enableCodeLens: boolean;
   enableHoverMessages: boolean;
   autoReloadOnChange: boolean;
+  excludeTestFiles: boolean;
 }
 
 export function getConfig(): Config {
@@ -20,5 +21,6 @@ export function getConfig(): Config {
     enableCodeLens: cfg.get<boolean>('enableCodeLens', true),
     enableHoverMessages: cfg.get<boolean>('enableHoverMessages', true),
     autoReloadOnChange: cfg.get<boolean>('autoReloadOnChange', true),
+    excludeTestFiles: cfg.get<boolean>('excludeTestFiles', true),
   };
 }

src/extension.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import * as fs from 'fs';
+import { exec, spawn } from 'child_process';
 import {
   parseCoverageJson,
   parseCoverageXml,
@@ -20,6 +21,10 @@ import { CoverageTreeProvider } from './providers/treeProvider.js';
 let coveredDecoration: vscode.TextEditorDecorationType;
 let uncoveredDecoration: vscode.TextEditorDecorationType;
 let currentReport: CoverageReport | undefined;
+let coverageRunInProgress = false;
+let noCoveragePromptActive = false;
+let reloadTimer: ReturnType<typeof setTimeout> | undefined;
+let coverageOutputChannel: vscode.OutputChannel | undefined;
 
 const codeLensProvider = new CoverageCodeLensProvider();
 const hoverProvider = new CoverageHoverProvider();
@@ -85,14 +90,19 @@ function setupWatchers(context: vscode.ExtensionContext) {
   const root = vscode.workspace.workspaceFolders?.[0];
   if (!root) return;
 
+  const debouncedReload = () => {
+    if (!getConfig().autoReloadOnChange) return;
+    clearTimeout(reloadTimer);
+    reloadTimer = setTimeout(() => loadAndApply(), 500);
+  };
+
   const patterns = ['coverage.json', 'coverage.xml', '.coverage'];
   patterns.forEach(pattern => {
     const w = vscode.workspace.createFileSystemWatcher(
       new vscode.RelativePattern(root, pattern)
     );
-    const reload = () => { if (getConfig().autoReloadOnChange) loadAndApply(); };
-    w.onDidCreate(reload);
-    w.onDidChange(reload);
+    w.onDidCreate(debouncedReload);
+    w.onDidChange(debouncedReload);
     w.onDidDelete(() => {
       if (!findAnyCoverageFile(root.uri.fsPath)) clearCoverage();
     });
@@ -106,11 +116,12 @@ async function loadAndApply() {
 
   const result = await detectAndParse(workspaceFolder);
   if (!result) {
-    vscode.window.showWarningMessage(
-      'Coverage Visualizer: No coverage file found. Run: pytest --cov=. --cov-report=json'
-    );
+    if (!coverageRunInProgress && !findAnyCoverageFile(workspaceFolder)) {
+      await handleNoCoverage(workspaceFolder);
+    }
     return;
   }
+  coverageRunInProgress = false;
 
   const { report, formatUsed } = result;
   currentReport = report;
@@ -120,13 +131,87 @@ async function loadAndApply() {
   treeProvider.setReport(report);
 
   vscode.window.visibleTextEditors.forEach(editor => applyToEditor(editor, currentReport!));
-  updateStatusBar(report);
+
+  // Compute stats from the same filtered file set the dashboard shows,
+  // so the status bar number stays consistent with what's on screen.
+  const { excludeTestFiles } = getConfig();
+  const filteredFiles = Object.entries(report.files)
+    .filter(([p]) => !excludeTestFiles || !isTestFile(p))
+    .map(([, d]) => d);
+  const filteredCovered = filteredFiles.reduce((n, f) => n + f.executedLines.length, 0);
+  const filteredTotal   = filteredFiles.reduce((n, f) => n + f.executedLines.length + f.missingLines.length, 0);
+  updateStatusBar({
+    percentCovered: filteredTotal > 0 ? (filteredCovered / filteredTotal) * 100 : 0,
+    coveredStatements: filteredCovered,
+    numStatements: filteredTotal,
+  });
+
   updateDashboard(report);
+}
 
-  const { percentCovered, coveredStatements, numStatements } = report.totals;
-  vscode.window.showInformationMessage(
-    `Coverage [${formatUsed}]: ${percentCovered.toFixed(1)}% — ${coveredStatements}/${numStatements} statements`
-  );
+function resolvePython(workspaceFolder: string): string {
+  const candidates = [
+    path.join(workspaceFolder, '.venv', 'bin', 'python'),
+    path.join(workspaceFolder, '.venv', 'Scripts', 'python.exe'),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return 'python';
+}
+
+function checkPython(python: string, cwd: string, code: string): Promise<boolean> {
+  return new Promise(resolve => {
+    exec(`"${python}" -c "${code}"`, { cwd }, err => resolve(!err));
+  });
+}
+
+async function handleNoCoverage(workspaceFolder: string) {
+  if (noCoveragePromptActive) return;
+  noCoveragePromptActive = true;
+
+  try {
+    const python = resolvePython(workspaceFolder);
+    const [hasPytestCov, hasCoverage] = await Promise.all([
+      checkPython(python, workspaceFolder, 'import pytest_cov'),
+      checkPython(python, workspaceFolder, 'import coverage'),
+    ]);
+
+    if (!hasCoverage) {
+      vscode.window.showWarningMessage('coverage is not installed — add it as a dev dependency to enable auto-run.');
+      return;
+    }
+
+    const choice = await vscode.window.showInformationMessage(
+      'No coverage found.',
+      'Run pytest',
+      'Cancel'
+    );
+    if (choice !== 'Run pytest') return;
+
+    // Use spawn with the venv Python directly — no terminal, no VS Code Python
+    // extension interference. The extension auto-activates venv in *terminals*;
+    // background processes are unaffected.
+    const args = hasPytestCov
+      ? ['-m', 'pytest', '--cov=.', '--cov-report=json']
+      : ['-m', 'coverage', 'run', '-m', 'pytest'];
+
+    coverageRunInProgress = true;
+    coverageOutputChannel ??= vscode.window.createOutputChannel('Coverage Run');
+    coverageOutputChannel.clear();
+    coverageOutputChannel.show(true);
+    coverageOutputChannel.appendLine(`$ ${python} ${args.join(' ')}\n`);
+
+    const proc = spawn(python, args, { cwd: workspaceFolder });
+    proc.stdout.on('data', (d: Buffer) => coverageOutputChannel!.append(d.toString()));
+    proc.stderr.on('data', (d: Buffer) => coverageOutputChannel!.append(d.toString()));
+    proc.on('close', code => {
+      coverageRunInProgress = false;
+      coverageOutputChannel!.appendLine(`\n[exited ${code ?? '?'}]`);
+    });
+  } finally {
+    noCoveragePromptActive = false;
+  }
 }
 
 async function detectAndParse(
@@ -181,7 +266,18 @@ function clearCoverage() {
 }
 
 
+function isTestFile(fsPath: string): boolean {
+  const basename = path.basename(fsPath);
+  return basename.startsWith('test_') || basename.endsWith('_test.py') ||
+    fsPath.split(path.sep).some(seg => seg === 'tests' || seg === 'test');
+}
+
 function applyToEditor(editor: vscode.TextEditor, report: CoverageReport) {
+  if (getConfig().excludeTestFiles && isTestFile(editor.document.uri.fsPath)) {
+    editor.setDecorations(coveredDecoration, []);
+    editor.setDecorations(uncoveredDecoration, []);
+    return;
+  }
   const fileCoverage = findFileInReport(report, editor.document.uri.fsPath);
   if (!fileCoverage) {
     editor.setDecorations(coveredDecoration, []);
@@ -201,5 +297,6 @@ function linesToDecorations(lines: number[]): vscode.DecorationOptions[] {
 export function deactivate() {
   coveredDecoration?.dispose();
   uncoveredDecoration?.dispose();
+  coverageOutputChannel?.dispose();
   currentReport = undefined;
 }