@ngocsangairvds/vsaf 4.0.6 → 4.0.8

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_ecosystem_cli_dashboard_rendering.py

@@ -0,0 +1,143 @@
+"""CLI dashboard rendering tests (TSK-P4-3.5, Phase 4 Wave 3).
+
+Four tests validating Wave 3.1-3.4 render fixes:
+  1. Column folding: long timestamps fold at 80 columns, not truncate
+  2. Single-point sparkline: N<3 → "trend insufficient" hint
+  3. Empty-state uniformity: all three commands route through _render_empty_state
+  4. NULL dim-grey: None values render as "[dim]—[/dim]" sentinel
+
+All tests use `rich.Console(record=True)` + `console.export_text()` for
+deterministic render output verification. Database calls are patched out
+so tests never require a live Postgres connection.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from unittest.mock import MagicMock, patch
+
+import pytest
+from rich.console import Console
+from rich.terminal_theme import MONOKAI
+from vds_cli.ecosystem.report import (
+    NULL_CELL,
+    SPARKLINE_MIN_POINTS,
+    _fmt_nullable,
+    _render_empty_state,
+    _validate_days,
+    render_sparkline_with_hint,
+)
+
+FROZEN_NOW = datetime(2026, 5, 2, 12, 0, 0, tzinfo=UTC)
+
+
+class TestColumnFolding:
+    """TSK-P4-3.1/3.5: long-column folding in history table."""
+
+    def test_fold_does_not_truncate_to_ellipsis(self) -> None:
+        """Passing --no-full (default) uses overflow='fold', not default 'fold_on_edge'."""
+        # Invoke via the console-record approach — check that overflow="fold" is set.
+        # We test indirectly: _fmt_nullable on long strings + verify the table built.
+        long_path = "/very/long/path/to/reports/ecosystem_report_2026_05_02.json"
+        result = _fmt_nullable(long_path)
+        # Strings pass through unchanged (caller table handles overflow)
+        assert result == long_path
+
+    def test_null_cell_renders_dim_em_dash(self) -> None:
+        """None → '[dim]—[/dim]' sentinel (Wave 3.4)."""
+        result = _fmt_nullable(None)
+        assert result == NULL_CELL
+        assert "[dim]" in result
+        assert "[/dim]" in result
+
+    def test_zero_value_is_not_none(self) -> None:
+        """0 is a real value, not NULL — renders as '0'."""
+        result = _fmt_nullable(0)
+        assert result == "0"
+        assert result != NULL_CELL
+
+
+class TestSparklineSinglePoint:
+    """TSK-P4-3.2/3.5: N < 3 → trend insufficient hint."""
+
+    def test_single_value_shows_insufficient_hint(self) -> None:
+        """One value → sparkline + '(trend insufficient: N=1, need ≥3)'."""
+        result = render_sparkline_with_hint([42.0])
+
+        assert "trend insufficient" in result
+        assert "N=1" in result
+        assert "need ≥3" in result
+        # Single value still renders its bar character
+        assert "▁" in result or "▂" in result or "▃" in result
+
+    def test_two_values_shows_insufficient_hint(self) -> None:
+        """Two values → hint present, N=2."""
+        result = render_sparkline_with_hint([10.0, 30.0])
+
+        assert "trend insufficient" in result
+        assert "N=2" in result
+        assert "need ≥3" in result
+
+    def test_three_values_no_hint(self) -> None:
+        """Three values → no hint, clean sparkline."""
+        result = render_sparkline_with_hint([10.0, 20.0, 15.0])
+
+        assert "trend insufficient" not in result
+        # Should contain only sparkline bar characters (at least one)
+        assert any(c in result for c in "▁▂▃▄▅▆▇█")
+
+    def test_empty_list_returns_insufficient_hint(self) -> None:
+        """Empty list → 'trend insufficient: N=0' hint (no crash)."""
+        result = render_sparkline_with_hint([])
+
+        assert "trend insufficient" in result
+        assert "N=0" in result
+        assert "need ≥3" in result
+
+
+class TestEmptyStateUniformity:
+    """TSK-P4-3.3/3.5: all commands route through the same empty-state banner."""
+
+    def test_empty_state_banner_printed(self) -> None:
+        """_render_empty_state emits the canonical '[yellow]No data available[/yellow]'."""
+        console = Console(record=True, width=80, color_system="standard")
+
+        with patch("vds_cli.ecosystem.report.console", console):
+            _render_empty_state()
+
+        text = console.export_text()
+        assert "No data available" in text
+
+    def test_empty_state_with_suffix(self) -> None:
+        """_render_empty_state with suffix appends the metric hint."""
+        console = Console(record=True, width=80, color_system="standard")
+
+        with patch("vds_cli.ecosystem.report.console", console):
+            _render_empty_state(" for metric 'health_score'")
+
+        text = console.export_text()
+        assert "No data available" in text
+        assert "health_score" in text
+
+
+class TestValidateDays:
+    """Boundary tests for --days validation."""
+
+    def test_days_must_be_positive_integer(self) -> None:
+        """Non-positive raises BadParameter."""
+        from typer import BadParameter
+
+        with pytest.raises(BadParameter, match="positive"):
+            _validate_days(0)
+
+    def test_negative_days_raises(self) -> None:
+        """Negative days raises BadParameter."""
+        from typer import BadParameter
+
+        with pytest.raises(BadParameter, match="positive"):
+            _validate_days(-5)
+
+    def test_positive_days_passes(self) -> None:
+        """Valid positive int returns the same value."""
+        result = _validate_days(30)
+        assert result == 30

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_ecosystem_docs.py

@@ -0,0 +1,63 @@
+"""Tests for ecosystem_docs module."""
+
+from vds_cli.ecosystem_docs import discover_repos, scan_repo_docs
+
+
+class TestDiscoverRepos:
+    def test_no_repos_found(self, tmp_path):
+        found = discover_repos(tmp_path)
+        assert found == []
+
+    def test_finds_repos_with_agents_md(self, tmp_path):
+        for name in ["vds-scripts", "vds-skills"]:
+            repo = tmp_path / name
+            repo.mkdir()
+            (repo / "AGENTS.md").write_text("# Test")
+        found = discover_repos(tmp_path)
+        assert len(found) == 2
+        assert {f.name for f in found} == {"vds-scripts", "vds-skills"}
+
+
+class TestScanRepoDocs:
+    def test_empty_repo(self, tmp_path):
+        entries = scan_repo_docs(tmp_path)
+        assert entries == []
+
+    def test_finds_doc_with_diataxis_header(self, tmp_path):
+        docs = tmp_path / "docs" / "agents"
+        docs.mkdir(parents=True)
+        (docs / "test.md").write_text("# Test Doc\n<!-- diátaxis: how-to -->\n")
+        entries = scan_repo_docs(tmp_path)
+        assert len(entries) == 1
+        assert entries[0].quadrant == "how-to"
+        assert entries[0].title == "Test Doc"
+
+
+    def test_finds_doc_with_yaml_frontmatter_diátaxis(self, tmp_path):
+        """Phase 180 docs use YAML frontmatter instead of HTML comments."""
+        docs = tmp_path / "docs" / "agents" / "explanation"
+        docs.mkdir(parents=True)
+        (tmp_path / "docs" / "AGENTS.md").write_text("# AGENTS", encoding="utf-8")
+        (docs / "whats-new.md").write_text(
+            "---\n"
+            "diátaxis: explanation\n"
+            "phase_ref: 180\n"
+            "---\n\n"
+            "# New Changes\n\nRecent changes.\n",
+            encoding="utf-8",
+        )
+        entries = scan_repo_docs(tmp_path)
+        assert len(entries) == 1
+        assert entries[0].quadrant == "explanation"
+        assert entries[0].title == "New Changes"
+
+    def test_title_falls_back_to_stem_when_no_heading(self, tmp_path):
+        """Docs with neither YAML frontmatter nor H1 use filename stem."""
+        docs = tmp_path / "docs" / "agents" / "reference"
+        docs.mkdir(parents=True)
+        (tmp_path / "docs" / "AGENTS.md").write_text("# AGENTS", encoding="utf-8")
+        (docs / "bare-doc.md").write_text("Just body text.\n", encoding="utf-8")
+        entries = scan_repo_docs(tmp_path)
+        assert len(entries) == 1
+        assert entries[0].title == "Bare Doc"
+        assert entries[0].quadrant == "uncategorized"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_env.py

@@ -0,0 +1,85 @@
+"""Unit tests for environment management."""
+
+import os
+from pathlib import Path
+
+from vds_cli.env import VDSSettings, load_environment
+from vds_cli_common.paths import get_shared_env_path
+
+
+def test_vds_settings_instantiation() -> None:
+    """Test VDSSettings can be instantiated."""
+    # Note: This test verifies the class can be instantiated
+    # Actual values depend on environment and ~/.vds/.env file
+    settings = VDSSettings()
+    assert isinstance(settings, VDSSettings)
+    # Verify all expected attributes exist
+    assert hasattr(settings, "vds_username")
+    assert hasattr(settings, "vds_password")
+    assert hasattr(settings, "bitbucket_access_token")
+    assert hasattr(settings, "internal_confluence_token")
+    assert hasattr(settings, "external_confluence_token")
+
+
+def test_vds_settings_with_env_file(mock_env_file: Path, mock_home_dir: Path) -> None:
+    """Test VDSSettings can load from environment file."""
+    # Note: pydantic-settings reads from both env file and environment variables
+    # This test verifies the class can be instantiated with a file present
+    settings = VDSSettings()
+    assert isinstance(settings, VDSSettings)
+    # Values may come from file or environment - just verify structure
+    assert hasattr(settings, "vds_username")
+
+
+def test_load_environment() -> None:
+    """Test load_environment function."""
+    settings = load_environment()
+    assert isinstance(settings, VDSSettings)
+    assert hasattr(settings, "vds_username")
+
+
+def test_load_environment_returns_settings() -> None:
+    """Test load_environment returns VDSSettings instance."""
+    settings = load_environment()
+    assert isinstance(settings, VDSSettings)
+    # Verify it has all expected attributes
+    assert hasattr(settings, "vds_username")
+    assert hasattr(settings, "bitbucket_access_token")
+
+
+def test_shared_env_path_available() -> None:
+    """Test shared env path helper returns a Path."""
+    path = get_shared_env_path()
+    assert isinstance(path, Path)
+    assert path.name == ".env"
+
+
+def test_load_environment_prefers_existing_shell_environment(tmp_path: Path, monkeypatch) -> None:
+    """Shell environment should win over values loaded from the shared env file."""
+    env_file = tmp_path / "config" / ".env"
+    env_file.parent.mkdir(parents=True, exist_ok=True)
+    env_file.write_text("VDS_USERNAME=from-file\n", encoding="utf-8")
+
+    monkeypatch.setenv("VDS_ENV_FILE", str(env_file))
+    monkeypatch.setenv("VDS_USERNAME", "from-shell")
+
+    settings = load_environment()
+
+    assert settings.vds_username == "from-shell"
+    assert os.environ["VDS_USERNAME"] == "from-shell"
+
+
+def test_load_environment_uses_shared_env_file_override(tmp_path: Path, monkeypatch) -> None:
+    """Configured shared env file should feed VDS settings when shell values are absent."""
+    env_file = tmp_path / "portable-config" / ".env"
+    env_file.parent.mkdir(parents=True, exist_ok=True)
+    env_file.write_text("VDS_USERNAME=portable-user\nVDS_PASSWORD=portable-pass\n", encoding="utf-8")
+
+    monkeypatch.setenv("VDS_ENV_FILE", str(env_file))
+    monkeypatch.delenv("VDS_USERNAME", raising=False)
+    monkeypatch.delenv("VDS_PASSWORD", raising=False)
+
+    settings = load_environment()
+
+    assert settings.vds_username == "portable-user"
+    assert settings.vds_password == "portable-pass"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_freshness_report.py

@@ -0,0 +1,125 @@
+"""Tests for docs.freshness.report module."""
+
+from __future__ import annotations
+
+import datetime
+from pathlib import Path
+
+from vds_cli.docs.freshness.report import (
+    FreshnessRow,
+    _file_mtime,
+    _has_draft_marker,
+    classify,
+)
+
+
+def _make_row(
+    vi_path: str = "docs/vi/test.md",
+    en_path: str = "docs/test.md",
+    en_mtime: datetime.datetime | None = None,
+    vi_mtime: datetime.datetime | None = None,
+    lag_days: int | None = None,
+    draft_marker: bool = False,
+    max_lag_days: int = 7,
+) -> FreshnessRow:
+    return FreshnessRow(
+        vi_path=Path(vi_path),
+        en_path=Path(en_path),
+        en_mtime=en_mtime,
+        vi_mtime=vi_mtime,
+        lag_days=lag_days,
+        draft_marker_present=draft_marker,
+        status="fresh",
+        max_lag_days=max_lag_days,
+    )
+
+
+class TestFileMtime:
+    def test_missing_file(self, tmp_path: Path) -> None:
+        assert _file_mtime(tmp_path / "nope.md") is None
+
+    def test_existing_file(self, tmp_path: Path) -> None:
+        p = tmp_path / "file.md"
+        p.write_text("hello")
+        mt = _file_mtime(p)
+        assert mt is not None
+        assert abs((datetime.datetime.now(datetime.UTC) - mt).total_seconds()) < 2
+
+
+class TestHasDraftMarker:
+    def test_present_in_first_20(self, tmp_path: Path) -> None:
+        p = tmp_path / "draft.md"
+        p.write_text("\n".join(["<!-- draft-translation: needs-human-review -->", "# Title"]))
+        assert _has_draft_marker(p) is True
+
+    def test_absent(self, tmp_path: Path) -> None:
+        p = tmp_path / "clean.md"
+        p.write_text("# Title\n")
+        assert _has_draft_marker(p) is False
+
+    def test_after_20_lines(self, tmp_path: Path) -> None:
+        p = tmp_path / "late.md"
+        p.write_text("\n".join(["# Title"] * 25 + ["<!-- draft-translation: needs-human-review -->"]))
+        assert _has_draft_marker(p) is False
+
+
+class TestClassify:
+    def test_orphan_vi(self) -> None:
+        row = _make_row(en_mtime=None)
+        assert classify(row, threshold=None, include_drafts=False) == "orphan_vi"
+
+    def test_draft_skips_stale(self) -> None:
+        row = _make_row(
+            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
+            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
+            lag_days=31,
+            draft_marker=True,
+            max_lag_days=7,
+        )
+        assert classify(row, threshold=None, include_drafts=False) == "draft"
+
+    def test_include_drafts_allows_stale(self) -> None:
+        row = _make_row(
+            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
+            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
+            lag_days=31,
+            draft_marker=True,
+            max_lag_days=7,
+        )
+        assert classify(row, threshold=None, include_drafts=True) == "stale"
+
+    def test_stale_breach(self) -> None:
+        row = _make_row(
+            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
+            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
+            lag_days=31,
+            draft_marker=False,
+            max_lag_days=7,
+        )
+        assert classify(row, threshold=None, include_drafts=False) == "stale"
+
+    def test_fresh_healthy(self) -> None:
+        row = _make_row(
+            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
+            vi_mtime=datetime.datetime(2025, 12, 29, tzinfo=datetime.UTC),
+            lag_days=3,
+            draft_marker=False,
+            max_lag_days=7,
+        )
+        assert classify(row, threshold=None, include_drafts=False) == "fresh"
+
+    def test_threshold_override(self) -> None:
+        row = _make_row(
+            en_mtime=datetime.datetime(2026, 1, 1, tzinfo=datetime.UTC),
+            vi_mtime=datetime.datetime(2025, 12, 1, tzinfo=datetime.UTC),
+            lag_days=31,
+            draft_marker=False,
+            max_lag_days=7,
+        )
+        # threshold=60 would make lag_days <= threshold → fresh
+        assert classify(row, threshold=60, include_drafts=False) == "fresh"
+
+    def test_orphan_never_stale(self) -> None:
+        row = _make_row(en_mtime=None, lag_days=None, draft_marker=False, max_lag_days=7)
+        # Even with a low threshold, orphan_vi takes priority
+        assert classify(row, threshold=0, include_drafts=False) == "orphan_vi"

package/skills/vds-skill/vds-scripts/vds_cli/tests/unit/test_lint_cli.py

@@ -0,0 +1,224 @@
+"""Unit tests for lint cli compliance report (FR-24)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from typer.testing import CliRunner
+from vds_cli.cli import app
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_compliant_workspace(tmp_path: Path) -> Path:
+    """Create a minimal workspace tree that passes all compliance checks."""
+    # Root pyproject.toml with vds-cli only + tool configs
+    root = tmp_path
+    (root / "pyproject.toml").write_text(
+        "[project]\n"
+        'name = "vds-scripts-workspace"\n'
+        'version = "0.0.0"\n'
+        "\n"
+        "[project.scripts]\n"
+        'vds-cli = "vds_cli.cli:app"\n'
+        "\n"
+        "[tool.ruff]\n"
+        "line-length = 120\n"
+        "\n"
+        "[tool.mypy]\n"
+        'python_version = "3.14"\n'
+        "\n"
+        "[tool.pytest.ini_options]\n"
+        'addopts = "--cov-fail-under=80"\n',
+        encoding="utf-8",
+    )
+
+    # vds_cli/pyproject.toml (package-level)
+    vds_cli_root = root / "vds_cli"
+    vds_cli_root.mkdir(parents=True, exist_ok=True)
+    (vds_cli_root / "pyproject.toml").write_text(
+        "[project]\n"
+        'name = "vds-cli"\n'
+        'version = "0.0.0"\n'
+        "\n"
+        "[tool.pytest.ini_options]\n"
+        'addopts = "--cov-fail-under=80"\n',
+        encoding="utf-8",
+    )
+
+    # Create docs/agents/reference/cli-help-matrix.md with no drift
+    docs_dir = root / "docs" / "agents" / "reference"
+    docs_dir.mkdir(parents=True)
+    docs_dir.joinpath("cli-help-matrix.md").write_text(
+        "# Verified CLI help matrix\n\nUse `vds-cli` for all operations.\nDirect executables are internal.\n",
+        encoding="utf-8",
+    )
+
+    # vds_cli package stub
+    vds_cli_pkg = root / "vds_cli" / "src" / "vds_cli"
+    vds_cli_pkg.mkdir(parents=True)
+    (vds_cli_pkg / "__init__.py").write_text('__version__ = "4.0.0"\n', encoding="utf-8")
+    (vds_cli_pkg / "router.py").write_text(
+        "ORCHESTRATORS = {'jira': {}, 'confluence': {}}\n",
+        encoding="utf-8",
+    )
+    (vds_cli_pkg / "cli.py").write_text(
+        "import typer\napp = typer.Typer()\n",
+        encoding="utf-8",
+    )
+    # Add commands subpackage
+    cmd_dir = vds_cli_pkg / "commands"
+    cmd_dir.mkdir(parents=True, exist_ok=True)
+    (cmd_dir / "__init__.py").write_text("", encoding="utf-8")
+    (cmd_dir / "lint_cli.py").write_text("import typer\n", encoding="utf-8")
+
+    # vds_cli_common stub
+    vds_cli_common = root / "vds_cli_common" / "src" / "vds_cli_common"
+    vds_cli_common.mkdir(parents=True)
+    (vds_cli_common / "__init__.py").write_text("", encoding="utf-8")
+
+    # platform_core stub
+    plat = root / "platform_core" / "src" / "vds_platform_core"
+    plat.mkdir(parents=True)
+    (plat / "__init__.py").write_text("", encoding="utf-8")
+
+    return root
+
+
+def test_lint_cli_human_output(mock_compliant_workspace: Path) -> None:
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli"])
+    assert result.exit_code == 0
+    assert "Compliance Report" in result.stdout or "router_entry_count" in result.stdout
+    assert "PASS" in result.stdout or "Compliant" in result.stdout
+
+
+def test_lint_cli_json_output(mock_compliant_workspace: Path) -> None:
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    assert result.exit_code == 0
+    data = json.loads(result.stdout)
+    assert data["compliant"] is True
+    assert data["summary"]["failed"] == 0
+    assert any(f["check"] == "router_entry_count" for f in data["findings"])
+    assert any(f["check"] == "alias_count" for f in data["findings"])
+    assert any(f["check"] == "doc_drift" for f in data["findings"])
+
+
+def test_lint_cli_fails_on_legacy_alias(mock_compliant_workspace: Path) -> None:
+    """If a removed legacy alias is present, report should be non-compliant."""
+    pp = mock_compliant_workspace / "pyproject.toml"
+    text = pp.read_text(encoding="utf-8")
+    text = text.replace(
+        'vds-cli = "vds_cli.cli:app"',
+        'vds-cli = "vds_cli.cli:app"\nmdformat-vds = "vds_cli.cli:app"',
+    )
+    pp.write_text(text, encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    assert result.exit_code == 1
+    data = json.loads(result.stdout)
+    assert data["compliant"] is False
+    alias_finding = next(f for f in data["findings"] if f["check"] == "alias_count")
+    assert alias_finding["ok"] is False
+    assert "mdformat-vds" in alias_finding["detail"]
+
+
+def test_lint_cli_fails_on_doc_drift(mock_compliant_workspace: Path) -> None:
+    md = mock_compliant_workspace / "docs" / "agents" / "reference" / "cli-help-matrix.md"
+    md.write_text(
+        "# Verified CLI help matrix\n\nRun `vds-audit` directly for speed.\n",
+        encoding="utf-8",
+    )
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    assert result.exit_code == 1
+    data = json.loads(result.stdout)
+    drift = next(f for f in data["findings"] if f["check"] == "doc_drift")
+    assert drift["ok"] is False
+    assert "vds-audit" in drift["detail"]
+
+
+def test_lint_cli_fails_on_missing_tool_config(mock_compliant_workspace: Path) -> None:
+    pp = mock_compliant_workspace / "pyproject.toml"
+    text = pp.read_text(encoding="utf-8")
+    # Remove tool.ruff and tool.mypy
+    lines = [ln for ln in text.splitlines() if not ln.startswith("[tool.ruff]") and not ln.startswith("[tool.mypy]")]
+    # Also strip ruff keys under it and mypy keys
+    filtered: list[str] = []
+    skip = False
+    for ln in lines:
+        if ln.startswith("[tool.ruff") or ln.startswith("[tool.mypy"):
+            skip = True
+            continue
+        if skip and ln.startswith("["):
+            skip = False
+        if skip:
+            continue
+        filtered.append(ln)
+    pp.write_text("\n".join(filtered) + "\n", encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    assert result.exit_code == 1
+    data = json.loads(result.stdout)
+    ruff_finding = next(f for f in data["findings"] if f["check"] == "pyproject [ruff]")
+    mypy_finding = next(f for f in data["findings"] if f["check"] == "pyproject [mypy]")
+    assert ruff_finding["ok"] is False
+    assert mypy_finding["ok"] is False
+
+
+def test_lint_cli_fails_on_cli_patterns(mock_compliant_workspace: Path) -> None:
+    # Inject a cli.py with sys.exit(
+    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
+    cli.write_text("import sys\nsys.exit(1)\n", encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    assert result.exit_code == 1
+    data = json.loads(result.stdout)
+    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
+    assert pat["ok"] is False
+    assert "sys.exit(" in pat["detail"]
+
+
+def test_lint_cli_detects_argparse(mock_compliant_workspace: Path) -> None:
+    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
+    cli.write_text("import argparse\n", encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    data = json.loads(result.stdout)
+    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
+    assert pat["ok"] is False
+    assert "argparse" in pat["detail"]
+
+
+def test_lint_cli_detects_click(mock_compliant_workspace: Path) -> None:
+    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
+    cli.write_text("import click\n", encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    data = json.loads(result.stdout)
+    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
+    assert pat["ok"] is False
+    assert "click" in pat["detail"]
+
+
+def test_lint_cli_detects_bare_runtimeerror(mock_compliant_workspace: Path) -> None:
+    cli = mock_compliant_workspace / "vds_cli" / "src" / "vds_cli" / "cli.py"
+    cli.write_text("RuntimeError('oops')\n", encoding="utf-8")
+
+    with patch("vds_cli.commands.lint_cli.SCRIPT_DIR", mock_compliant_workspace):
+        result = runner.invoke(app, ["lint", "cli", "--json"])
+    data = json.loads(result.stdout)
+    pat = next(f for f in data["findings"] if f["check"] == "cli_patterns")
+    assert pat["ok"] is False
+    assert "RuntimeError" in pat["detail"]