python-vibe-guard 0.10.0__tar.gz → 0.11.0__tar.gz

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-vibe-guard
-Version: 0.10.0
+Version: 0.11.0
 Summary: Runtime anti-pattern scanner for async Python — detects what AI-generated code gets wrong
 License: MIT
 Keywords: async,linter,fastapi,asyncio,static-analysis
@@ -173,6 +173,10 @@ python -m pyvibe src/ --exclude tests
 # Show the research evidence behind a rule (accuracy, false positives, sources)
 python -m pyvibe explain PYVIBE-002
 
+# Baseline mode: suppress pre-existing findings, only fail on new ones
+python -m pyvibe baseline create src/     # snapshot current findings
+python -m pyvibe src/ --baseline          # only reports findings NOT in the baseline
+
 # Exit code: 0 = clean, 1 = violations found, 2 = path error
 ```
 
@@ -255,6 +259,38 @@ python -m pyvibe explain PYVIBE-002
 If a rule has no evidence file, it prints a clear `No evidence file found for PYVIBE-XXX`
 and exits non-zero — it never invents data.
 
+### Baseline mode
+
+Adopting python-vibe-guard on an existing codebase usually means hundreds of pre-existing
+findings you can't fix before CI needs to go green. Baseline mode snapshots the current
+findings once, then only fails on genuinely **new** ones:
+
+```bash
+# Snapshot every current finding into .pyvibe-baseline.json
+python -m pyvibe baseline create src/
+
+# Refuses to run if a baseline already exists — use `update` to overwrite it
+python -m pyvibe baseline update src/
+
+# Full scan, but only reports findings NOT already in the baseline
+python -m pyvibe src/ --baseline
+python -m pyvibe src/ --baseline --json
+python -m pyvibe src/ --baseline --sarif
+
+# `pyvibe scan` is an equivalent, explicit subcommand form of the same flags
+python -m pyvibe scan src/ --baseline
+```
+
+A finding is considered "already known" on an exact match of `(file path, rule ID, line
+number)`. Anything that doesn't match — a new violation, or an existing one that moved to
+a different line — is reported and fails the scan (exit code `1`); an unchanged baseline
+produces exit code `0`.
+
+`.pyvibe-baseline.json` is a plain JSON file — whether to commit it or add it to
+`.gitignore` is up to your team. Commit it if you want the accepted-debt snapshot shared
+and reviewed like any other file; gitignore it if each contributor/CI run should
+regenerate its own baseline instead.
+
 ---
 
 ## CI/CD integration
@@ -352,7 +388,7 @@ python -m pytest tests/ -v
 python tests/test_rules.py
 ```
 
-226 tests: true positives + false-positive guards for every rule, plus SARIF output and `pyvibe explain` coverage.
+268 tests: true positives + false-positive guards for every rule, plus SARIF output, `pyvibe explain`, `pyvibe review`, and baseline mode coverage.
 
 ---
 

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/README.md

@@ -158,6 +158,10 @@ python -m pyvibe src/ --exclude tests
 # Show the research evidence behind a rule (accuracy, false positives, sources)
 python -m pyvibe explain PYVIBE-002
 
+# Baseline mode: suppress pre-existing findings, only fail on new ones
+python -m pyvibe baseline create src/     # snapshot current findings
+python -m pyvibe src/ --baseline          # only reports findings NOT in the baseline
+
 # Exit code: 0 = clean, 1 = violations found, 2 = path error
 ```
 
@@ -240,6 +244,38 @@ python -m pyvibe explain PYVIBE-002
 If a rule has no evidence file, it prints a clear `No evidence file found for PYVIBE-XXX`
 and exits non-zero — it never invents data.
 
+### Baseline mode
+
+Adopting python-vibe-guard on an existing codebase usually means hundreds of pre-existing
+findings you can't fix before CI needs to go green. Baseline mode snapshots the current
+findings once, then only fails on genuinely **new** ones:
+
+```bash
+# Snapshot every current finding into .pyvibe-baseline.json
+python -m pyvibe baseline create src/
+
+# Refuses to run if a baseline already exists — use `update` to overwrite it
+python -m pyvibe baseline update src/
+
+# Full scan, but only reports findings NOT already in the baseline
+python -m pyvibe src/ --baseline
+python -m pyvibe src/ --baseline --json
+python -m pyvibe src/ --baseline --sarif
+
+# `pyvibe scan` is an equivalent, explicit subcommand form of the same flags
+python -m pyvibe scan src/ --baseline
+```
+
+A finding is considered "already known" on an exact match of `(file path, rule ID, line
+number)`. Anything that doesn't match — a new violation, or an existing one that moved to
+a different line — is reported and fails the scan (exit code `1`); an unchanged baseline
+produces exit code `0`.
+
+`.pyvibe-baseline.json` is a plain JSON file — whether to commit it or add it to
+`.gitignore` is up to your team. Commit it if you want the accepted-debt snapshot shared
+and reviewed like any other file; gitignore it if each contributor/CI run should
+regenerate its own baseline instead.
+
 ---
 
 ## CI/CD integration
@@ -337,7 +373,7 @@ python -m pytest tests/ -v
 python tests/test_rules.py
 ```
 
-226 tests: true positives + false-positive guards for every rule, plus SARIF output and `pyvibe explain` coverage.
+268 tests: true positives + false-positive guards for every rule, plus SARIF output, `pyvibe explain`, `pyvibe review`, and baseline mode coverage.
 
 ---
 

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-vibe-guard"
-version = "0.10.0"
+version = "0.11.0"
 description = "Runtime anti-pattern scanner for async Python — detects what AI-generated code gets wrong"
 readme = "README.md"
 requires-python = ">=3.10"

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/python_vibe_guard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-vibe-guard
-Version: 0.10.0
+Version: 0.11.0
 Summary: Runtime anti-pattern scanner for async Python — detects what AI-generated code gets wrong
 License: MIT
 Keywords: async,linter,fastapi,asyncio,static-analysis
@@ -173,6 +173,10 @@ python -m pyvibe src/ --exclude tests
 # Show the research evidence behind a rule (accuracy, false positives, sources)
 python -m pyvibe explain PYVIBE-002
 
+# Baseline mode: suppress pre-existing findings, only fail on new ones
+python -m pyvibe baseline create src/     # snapshot current findings
+python -m pyvibe src/ --baseline          # only reports findings NOT in the baseline
+
 # Exit code: 0 = clean, 1 = violations found, 2 = path error
 ```
 
@@ -255,6 +259,38 @@ python -m pyvibe explain PYVIBE-002
 If a rule has no evidence file, it prints a clear `No evidence file found for PYVIBE-XXX`
 and exits non-zero — it never invents data.
 
+### Baseline mode
+
+Adopting python-vibe-guard on an existing codebase usually means hundreds of pre-existing
+findings you can't fix before CI needs to go green. Baseline mode snapshots the current
+findings once, then only fails on genuinely **new** ones:
+
+```bash
+# Snapshot every current finding into .pyvibe-baseline.json
+python -m pyvibe baseline create src/
+
+# Refuses to run if a baseline already exists — use `update` to overwrite it
+python -m pyvibe baseline update src/
+
+# Full scan, but only reports findings NOT already in the baseline
+python -m pyvibe src/ --baseline
+python -m pyvibe src/ --baseline --json
+python -m pyvibe src/ --baseline --sarif
+
+# `pyvibe scan` is an equivalent, explicit subcommand form of the same flags
+python -m pyvibe scan src/ --baseline
+```
+
+A finding is considered "already known" on an exact match of `(file path, rule ID, line
+number)`. Anything that doesn't match — a new violation, or an existing one that moved to
+a different line — is reported and fails the scan (exit code `1`); an unchanged baseline
+produces exit code `0`.
+
+`.pyvibe-baseline.json` is a plain JSON file — whether to commit it or add it to
+`.gitignore` is up to your team. Commit it if you want the accepted-debt snapshot shared
+and reviewed like any other file; gitignore it if each contributor/CI run should
+regenerate its own baseline instead.
+
 ---
 
 ## CI/CD integration
@@ -352,7 +388,7 @@ python -m pytest tests/ -v
 python tests/test_rules.py
 ```
 
-226 tests: true positives + false-positive guards for every rule, plus SARIF output and `pyvibe explain` coverage.
+268 tests: true positives + false-positive guards for every rule, plus SARIF output, `pyvibe explain`, `pyvibe review`, and baseline mode coverage.
 
 ---
 

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/python_vibe_guard.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ pyvibe/__init__.py
 pyvibe/__main__.py
 pyvibe/analyzer.py
 pyvibe/autofix.py
+pyvibe/baseline.py
 pyvibe/cli.py
 pyvibe/diff.py
 pyvibe/explain.py
@@ -36,6 +37,7 @@ pyvibe/rules/sqlite_async.py
 pyvibe/rules/subprocess_async.py
 pyvibe/rules/threading_lock.py
 pyvibe/rules/while_true_no_await.py
+tests/test_baseline.py
 tests/test_diff.py
 tests/test_exclude.py
 tests/test_explain.py

python_vibe_guard-0.11.0/pyvibe/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.11.0"

python_vibe_guard-0.11.0/pyvibe/baseline.py

@@ -0,0 +1,73 @@
+"""Baseline support — `pyvibe baseline create/update` and `pyvibe scan --baseline`.
+
+A baseline is a snapshot of existing findings ({filepath: [{rule_id, line,
+message}, ...]}) that a team can choose to commit or gitignore (see README).
+Once created, `pyvibe scan --baseline` only reports genuinely NEW
+violations — anything already in the baseline is suppressed — so a
+codebase can adopt python-vibe-guard incrementally instead of having to
+fix every existing hit before CI goes green.
+"""
+import json
+from pathlib import Path
+from typing import Dict, Set, Tuple
+
+DEFAULT_BASELINE_PATH = ".pyvibe-baseline.json"
+
+
+class BaselineNotFoundError(Exception):
+    """Raised when `pyvibe scan --baseline` can't find/parse the baseline file."""
+
+
+def build_baseline(file_results: Dict) -> dict:
+    """file_results: {path: [Violation, ...]} as produced by analyze_file /
+    analyze_directory. Returns the JSON-serializable baseline:
+    {filepath: [{rule_id, line, message}, ...]}.
+    """
+    return {
+        str(path): [
+            {"rule_id": v.rule_id, "line": v.line, "message": v.message}
+            for v in violations
+        ]
+        for path, violations in file_results.items()
+    }
+
+
+def write_baseline(file_results: Dict, output_path=DEFAULT_BASELINE_PATH) -> None:
+    baseline = build_baseline(file_results)
+    Path(output_path).write_text(json.dumps(baseline, indent=2), encoding="utf-8")
+
+
+def load_baseline(path=DEFAULT_BASELINE_PATH) -> dict:
+    baseline_path = Path(path)
+    if not baseline_path.exists():
+        raise BaselineNotFoundError(
+            f"No baseline found at {path}. Run `pyvibe baseline create` first."
+        )
+    try:
+        return json.loads(baseline_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        raise BaselineNotFoundError(f"Baseline at {path} is not valid JSON: {e}") from e
+
+
+def _baseline_keys(baseline: dict) -> Set[Tuple[str, str, int]]:
+    """Flatten the baseline into (filepath, rule_id, line) triples for exact,
+    O(1) membership checks.
+    """
+    return {
+        (filepath, entry["rule_id"], entry["line"])
+        for filepath, entries in baseline.items()
+        for entry in entries
+    }
+
+
+def filter_new_violations(file_results: Dict, baseline: dict) -> Dict:
+    """Return only the violations in file_results NOT present in baseline,
+    matched exactly on (filepath, rule_id, line).
+    """
+    known = _baseline_keys(baseline)
+    new_results = {}
+    for path, violations in file_results.items():
+        new = [v for v in violations if (str(path), v.rule_id, v.line) not in known]
+        if new:
+            new_results[path] = new
+    return new_results

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/pyvibe/cli.py

@@ -11,6 +11,10 @@ Usage:
     python -m pyvibe explain PYVIBE-002       # show research evidence for a rule
     python -m pyvibe review                   # PR review: only diff-touched lines (git diff HEAD~1)
     python -m pyvibe review --base main       # diff against another ref
+    python -m pyvibe baseline create [path]   # snapshot existing findings to .pyvibe-baseline.json
+    python -m pyvibe baseline update [path]   # overwrite the existing baseline
+    python -m pyvibe <path> --baseline        # scan, suppressing findings already in the baseline
+    python -m pyvibe scan <path> --baseline   # equivalent, explicit subcommand form
 """
 import argparse
 import json
@@ -26,6 +30,7 @@ from pyvibe.analyzer import (
     TEST_FILE_DOWNGRADE,
     _is_test_file,
 )
+from pyvibe.baseline import DEFAULT_BASELINE_PATH
 
 
 def main():
@@ -37,6 +42,14 @@ def main():
         _main_review(sys.argv[2:])
         return
 
+    if len(sys.argv) > 1 and sys.argv[1] == "baseline":
+        _main_baseline(sys.argv[2:])
+        return
+
+    if len(sys.argv) > 1 and sys.argv[1] == "scan":
+        _main_scan(sys.argv[2:])
+        return
+
     parser = argparse.ArgumentParser(
         prog="pyvibe",
         description="Detect runtime anti-patterns in async Python code",
@@ -82,8 +95,34 @@ def main():
             "Default: only PYVIBE-001, PYVIBE-007, and PYVIBE-013 are downgraded."
         ),
     )
+    parser.add_argument(
+        "--baseline",
+        action="store_true",
+        help="Only report findings not already present in the baseline (see `pyvibe baseline create`)",
+    )
+    parser.add_argument(
+        "--baseline-path",
+        metavar="PATH",
+        default=DEFAULT_BASELINE_PATH,
+        help=f"Path to the baseline file (default: {DEFAULT_BASELINE_PATH})",
+    )
     args = parser.parse_args()
 
+    file_results = _resolve_file_results(args)
+    file_results = _apply_baseline_filter(args, file_results)
+    total_violations = sum(len(v) for v in file_results.values())
+    total_files = sum(1 for v in file_results.values() if v)
+
+    _emit_scan_output(args, file_results, total_violations, total_files)
+
+    sys.exit(1 if total_violations > 0 else 0)
+
+
+def _resolve_file_results(args) -> dict:
+    """Shared by the bare `pyvibe <path>` command and `pyvibe scan`.
+
+    Expects args.path/.exclude/.no_test_files/.downgrade_in_tests.
+    """
     target = Path(args.path)
     if not target.exists():
         print(f"Error: {target} does not exist", file=sys.stderr)
@@ -104,22 +143,42 @@ def main():
 
     if target.is_file():
         if target.suffix != ".py":
-            file_results = {}
-        elif skip_test_files and _is_test_file(str(target)):
-            file_results = {}
-        else:
-            file_results = {target: analyze_file(target, downgrade_in_tests=downgrade_in_tests)}
-    else:
-        file_results = analyze_directory(
-            target,
-            exclude=exclude,
-            skip_test_files=skip_test_files,
-            downgrade_in_tests=downgrade_in_tests,
-        )
+            return {}
+        if skip_test_files and _is_test_file(str(target)):
+            return {}
+        return {target: analyze_file(target, downgrade_in_tests=downgrade_in_tests)}
+
+    return analyze_directory(
+        target,
+        exclude=exclude,
+        skip_test_files=skip_test_files,
+        downgrade_in_tests=downgrade_in_tests,
+    )
 
-    total_violations = sum(len(v) for v in file_results.values())
-    total_files = sum(1 for v in file_results.values() if v)
 
+def _apply_baseline_filter(args, file_results: dict) -> dict:
+    """Shared by the bare `pyvibe <path>` command and `pyvibe scan`.
+
+    Expects args.baseline/.baseline_path. No-op when --baseline wasn't passed.
+    """
+    if not args.baseline:
+        return file_results
+
+    from pyvibe.baseline import BaselineNotFoundError, filter_new_violations, load_baseline
+
+    try:
+        baseline = load_baseline(args.baseline_path)
+    except BaselineNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(2)
+    return filter_new_violations(file_results, baseline)
+
+
+def _emit_scan_output(args, file_results: dict, total_violations: int, total_files: int):
+    """Shared by the bare `pyvibe <path>` command and `pyvibe scan`.
+
+    Expects args.sarif/.sarif_output/.json.
+    """
     if args.sarif:
         from pyvibe.sarif import write_sarif
 
@@ -144,8 +203,6 @@ def main():
     else:
         _print_human(file_results, total_violations, total_files)
 
-    sys.exit(1 if total_violations > 0 else 0)
-
 
 def _print_human(file_results: dict, total_violations: int, total_files: int):
     print()
@@ -285,6 +342,123 @@ def _print_review(file_results: dict, changed: dict, total_violations: int):
     print()
 
 
+def _main_scan(argv):
+    parser = argparse.ArgumentParser(
+        prog="pyvibe scan",
+        description="Scan for anti-patterns (same as bare `pyvibe <path>`), with optional baseline filtering",
+    )
+    parser.add_argument("path", help="File or directory to scan")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument(
+        "--sarif",
+        action="store_true",
+        help="Also write SARIF 2.1.0 output (for GitHub Code Scanning)",
+    )
+    parser.add_argument(
+        "--sarif-output",
+        metavar="PATH",
+        default="results.sarif",
+        help="Path to write SARIF output to (default: results.sarif)",
+    )
+    parser.add_argument(
+        "--exclude",
+        metavar="DIR",
+        action="append",
+        default=[],
+        help=(
+            "Directory name to exclude (can be repeated). "
+            "Added on top of the built-in defaults: "
+            + ", ".join(sorted(DEFAULT_EXCLUDES))
+        ),
+    )
+    parser.add_argument("--no-test-files", action="store_true", help="Exclude test files from the scan entirely")
+    parser.add_argument(
+        "--downgrade-in-tests",
+        action="store_true",
+        help="Downgrade ALL violations in test files from CRITICAL to WARNING",
+    )
+    parser.add_argument(
+        "--baseline",
+        action="store_true",
+        help="Only report findings not already present in the baseline (see `pyvibe baseline create`)",
+    )
+    parser.add_argument(
+        "--baseline-path",
+        metavar="PATH",
+        default=DEFAULT_BASELINE_PATH,
+        help=f"Path to the baseline file (default: {DEFAULT_BASELINE_PATH})",
+    )
+    args = parser.parse_args(argv)
+
+    file_results = _resolve_file_results(args)
+    file_results = _apply_baseline_filter(args, file_results)
+
+    total_violations = sum(len(v) for v in file_results.values())
+    total_files = sum(1 for v in file_results.values() if v)
+
+    _emit_scan_output(args, file_results, total_violations, total_files)
+
+    sys.exit(1 if total_violations > 0 else 0)
+
+
+def _main_baseline(argv):
+    parser = argparse.ArgumentParser(
+        prog="pyvibe baseline",
+        description="Snapshot existing findings so future scans only report new ones",
+    )
+    parser.add_argument("action", choices=["create", "update"], help="create: refuses to overwrite an existing baseline; update: always overwrites")
+    parser.add_argument("path", nargs="?", default=".", help="File or directory to scan (default: current directory)")
+    parser.add_argument(
+        "--baseline-path",
+        metavar="PATH",
+        default=DEFAULT_BASELINE_PATH,
+        help=f"Path to write the baseline to (default: {DEFAULT_BASELINE_PATH})",
+    )
+    parser.add_argument(
+        "--exclude",
+        metavar="DIR",
+        action="append",
+        default=[],
+        help="Directory name to exclude (can be repeated)",
+    )
+    parser.add_argument("--no-test-files", action="store_true", help="Exclude test files from the baseline entirely")
+    args = parser.parse_args(argv)
+
+    if args.action == "create" and Path(args.baseline_path).exists():
+        print(
+            f"Error: {args.baseline_path} already exists. "
+            "Use `pyvibe baseline update` to overwrite it.",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+
+    target = Path(args.path)
+    if not target.exists():
+        print(f"Error: {target} does not exist", file=sys.stderr)
+        sys.exit(2)
+
+    exclude = DEFAULT_EXCLUDES | frozenset(args.exclude)
+
+    if target.is_file():
+        if target.suffix != ".py":
+            file_results = {}
+        elif args.no_test_files and _is_test_file(str(target)):
+            file_results = {}
+        else:
+            file_results = {target: analyze_file(target)}
+    else:
+        file_results = analyze_directory(target, exclude=exclude, skip_test_files=args.no_test_files)
+
+    from pyvibe.baseline import write_baseline
+
+    total_findings = sum(len(v) for v in file_results.values())
+    write_baseline(file_results, args.baseline_path)
+
+    verb = "created" if args.action == "create" else "updated"
+    print(f"Baseline {verb}: {total_findings} findings saved to {args.baseline_path}")
+    sys.exit(0)
+
+
 def _main_explain(argv):
     parser = argparse.ArgumentParser(
         prog="pyvibe explain",

python_vibe_guard-0.11.0/tests/test_baseline.py

@@ -0,0 +1,234 @@
+"""Tests for baseline support (pyvibe/baseline.py + `pyvibe baseline` /
+`pyvibe scan --baseline` CLI subcommands)."""
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import pytest
+
+from pyvibe.analyzer import analyze_source
+from pyvibe.baseline import (
+    BaselineNotFoundError,
+    build_baseline,
+    filter_new_violations,
+    load_baseline,
+    write_baseline,
+)
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+VIOLATION_SRC = """\
+import time
+
+async def handler():
+    time.sleep(5)
+
+async def other():
+    time.sleep(9)
+"""
+
+
+# ─── build_baseline() / write_baseline() / load_baseline() unit tests ──────
+
+def test_build_baseline_shapes_output():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    baseline = build_baseline({Path("app.py"): violations})
+
+    assert baseline == {
+        "app.py": [
+            {"rule_id": "PYVIBE-001", "line": 4, "message": violations[0].message},
+            {"rule_id": "PYVIBE-001", "line": 7, "message": violations[1].message},
+        ]
+    }
+
+
+def test_write_and_load_baseline_roundtrip(tmp_path):
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    out = tmp_path / "baseline.json"
+
+    write_baseline({Path("app.py"): violations}, out)
+    loaded = load_baseline(out)
+
+    assert loaded == build_baseline({Path("app.py"): violations})
+
+
+def test_load_baseline_missing_file_raises(tmp_path):
+    with pytest.raises(BaselineNotFoundError, match="No baseline found"):
+        load_baseline(tmp_path / "nope.json")
+
+
+def test_load_baseline_invalid_json_raises(tmp_path):
+    bad = tmp_path / "bad.json"
+    bad.write_text("not json{{{")
+    with pytest.raises(BaselineNotFoundError, match="not valid JSON"):
+        load_baseline(bad)
+
+
+# ─── filter_new_violations() unit tests ────────────────────────────────────
+
+def test_filter_new_violations_excludes_exact_match():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    baseline = build_baseline({Path("app.py"): violations})
+
+    result = filter_new_violations({Path("app.py"): violations}, baseline)
+
+    assert result == {}
+
+
+def test_filter_new_violations_reports_new_line():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    baseline = build_baseline({Path("app.py"): [violations[0]]})  # only line 4 known
+
+    result = filter_new_violations({Path("app.py"): violations}, baseline)
+
+    assert list(result.keys()) == [Path("app.py")]
+    assert [v.line for v in result[Path("app.py")]] == [7]
+
+
+def test_filter_new_violations_reports_new_rule_on_same_line():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    baseline = {"app.py": [{"rule_id": "PYVIBE-999", "line": 4, "message": "unrelated"}]}
+
+    result = filter_new_violations({Path("app.py"): violations}, baseline)
+
+    assert {v.line for v in result[Path("app.py")]} == {4, 7}
+
+
+def test_filter_new_violations_empty_baseline_returns_everything():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+
+    result = filter_new_violations({Path("app.py"): violations}, {})
+
+    assert result == {Path("app.py"): violations}
+
+
+def test_filter_new_violations_drops_file_with_no_remaining_new_violations():
+    violations = analyze_source(VIOLATION_SRC, filepath="app.py")
+    baseline = build_baseline({Path("app.py"): violations})
+
+    clean_file_results = {Path("app.py"): violations, Path("clean.py"): []}
+    result = filter_new_violations(clean_file_results, baseline)
+
+    assert result == {}
+
+
+# ─── `pyvibe baseline` / `pyvibe scan --baseline` CLI (subprocess) ─────────
+
+def _run_cli(args, cwd):
+    # cwd is a throwaway tmp_path, not REPO_ROOT, so `-m pyvibe` needs
+    # PYTHONPATH set explicitly to find the package in a test environment
+    # where it isn't pip-installed (see the review-subcommand CI fix).
+    env = {**os.environ, "PYTHONPATH": str(REPO_ROOT)}
+    return subprocess.run(
+        [sys.executable, "-m", "pyvibe", *args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+
+def test_cli_baseline_create_writes_file_and_message(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+
+    result = _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    assert result.returncode == 0
+    assert "Baseline created: 2 findings saved to .pyvibe-baseline.json" in result.stdout
+    baseline_file = tmp_path / ".pyvibe-baseline.json"
+    assert baseline_file.exists()
+    assert len(json.loads(baseline_file.read_text())["app.py"]) == 2
+
+
+def test_cli_baseline_create_refuses_to_overwrite_existing(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+    _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    result = _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    assert result.returncode == 2
+    assert "already exists" in result.stderr
+
+
+def test_cli_baseline_update_overwrites_existing(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+    _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    (tmp_path / "app.py").write_text(VIOLATION_SRC + "\nasync def third():\n    time.sleep(1)\n")
+    result = _run_cli(["baseline", "update", "."], cwd=tmp_path)
+
+    assert result.returncode == 0
+    assert "Baseline updated: 3 findings saved to .pyvibe-baseline.json" in result.stdout
+
+
+def test_cli_scan_baseline_reports_only_new_finding(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+    _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    (tmp_path / "app.py").write_text(
+        VIOLATION_SRC + "\nasync def third():\n    time.sleep(1)\n"
+    )
+
+    result = _run_cli(["scan", ".", "--baseline", "--json"], cwd=tmp_path)
+    output = json.loads(result.stdout)
+
+    assert result.returncode == 1
+    assert len(output) == 1
+    assert output[0]["line"] == 10
+
+
+def test_cli_scan_baseline_clean_when_no_new_findings(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+    _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    result = _run_cli(["scan", ".", "--baseline"], cwd=tmp_path)
+
+    assert result.returncode == 0
+    assert "No violations found" in result.stdout
+
+
+def test_cli_scan_baseline_missing_file_exits_2(tmp_path):
+    (tmp_path / "app.py").write_text("print('clean')\n")
+
+    result = _run_cli(["scan", ".", "--baseline"], cwd=tmp_path)
+
+    assert result.returncode == 2
+    assert "No baseline found" in result.stderr
+
+
+def test_cli_scan_without_baseline_flag_matches_bare_invocation(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+
+    scan_result = _run_cli(["scan", ".", "--json"], cwd=tmp_path)
+    bare_result = _run_cli([".", "--json"], cwd=tmp_path)
+
+    assert json.loads(scan_result.stdout) == json.loads(bare_result.stdout)
+
+
+def test_cli_bare_command_supports_baseline_flag(tmp_path):
+    (tmp_path / "app.py").write_text(VIOLATION_SRC)
+    _run_cli(["baseline", "create", "."], cwd=tmp_path)
+
+    (tmp_path / "app.py").write_text(
+        VIOLATION_SRC + "\nasync def third():\n    time.sleep(1)\n"
+    )
+
+    result = _run_cli([".", "--baseline", "--json"], cwd=tmp_path)
+    output = json.loads(result.stdout)
+
+    assert result.returncode == 1
+    assert len(output) == 1
+    assert output[0]["line"] == 10
+
+
+def test_cli_bare_command_baseline_missing_file_exits_2(tmp_path):
+    (tmp_path / "app.py").write_text("print('clean')\n")
+
+    result = _run_cli([".", "--baseline"], cwd=tmp_path)
+
+    assert result.returncode == 2
+    assert "No baseline found" in result.stderr

{python_vibe_guard-0.10.0 → python_vibe_guard-0.11.0}/tests/test_diff.py

@@ -176,11 +176,16 @@ def test_analyze_file_without_line_filter_returns_everything(tmp_path):
 # ─── `pyvibe review` CLI (subprocess, end-to-end against a real git repo) ──
 
 def _run_cli(args, cwd):
+    # cwd here is a throwaway temp git repo, not REPO_ROOT, so `-m pyvibe`
+    # can't rely on cwd-insertion to find the package — it must be told
+    # explicitly via PYTHONPATH (pyvibe isn't installed in the test env).
+    env = {**os.environ, "PYTHONPATH": str(REPO_ROOT)}
     return subprocess.run(
         [sys.executable, "-m", "pyvibe", *args],
         cwd=cwd,
         capture_output=True,
         text=True,
+        env=env,
     )
 
 

python_vibe_guard-0.10.0/pyvibe/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.10.0"