fix: packaging config, ruff cleanup, and 7 new test suites (#34)

* fix: sort imports with ruff I001 in scanner and tests

* fix: resolve E501 line-too-long ruff violations in cli.py and tests

* build: add py.typed to package-data config in pyproject.toml

Adds include-package-data = true and explicit package-data entry
for py.typed marker. The file physically exists in the package but
was missing the setuptools config needed to include it in wheels.
This ensures PEP 561 type checking support for package consumers.

* test: verify py.typed package-data config in pyproject.toml

Adds test_package_data_includes_py_typed to TestPackagingQuality,
confirming py.typed is explicitly listed under [tool.setuptools.package-data]
for the deadcode package. Bundled with the pyproject.toml config change
as a related packaging quality improvement.

* test: add __main__ entry point and CLI edge-case tests

- test_main_module_runs_help: python -m deadcode --help covers __main__.py (0% coverage)

- test_non_existent_project_exits_1: scan with nonexistent path exits 1 (cli.py:88-90)

- 2 tests, 27 lines added

* test: add format output tests for compact, github, pretty, and legacy json-output

* fix: ruff I001 import sort in test_cli_edge_cases.py

* test: add coverage for --fail threshold and --ignore flag

Adds 2 new CLI edge case tests covering:
- test_fail_threshold_exits_high — --fail=0 exits 1 when findings exist
- test_ignore_flag_before_subcommand — --ignore group option excludes patterns

These cover uncovered paths in cli.py (fail threshold logic) and
_merge_config_ignore function.

* test: add coverage for remove --dry-run and stats commands

* fix: update site URLs back to devforge after repo rename

* test: add coverage for config yaml-list edge case, removed-file skip, default imports, and ignore-spec filter paths

* docs: add ops-heartbeat automation observations

---------

Co-authored-by: DevForge Engineer <engineer@devforge.dev>
Co-authored-by: Senior Dev Rotation <senior-dev@devforge.dev>

Author: 3 people

automation/ops-heartbeat/references/ops-heartbeat-observations.md

@@ -0,0 +1,6 @@
+date: 2026-06-10
+project: deadcode-cli
+runner: pytest on Python 3.12
+findings:
+  - 2026-06-10T__:fast smoke `py -3.12 -m pytest --no-header -q -q --maxfail=1` passed.
+  - full suite: pending

pyproject.toml

@@ -46,9 +46,15 @@ Changelog = "https://github.com/Coding-Dev-Tools/deadcode/releases"
 [project.scripts]
 deadcode = "deadcode.cli:cli"
 
+[tool.setuptools]
+include-package-data = true
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+deadcode = ["py.typed"]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = ["test_*.py"]

tests/test_cli_edge_cases.py

@@ -0,0 +1,148 @@
+"""Tests for __main__.py entry point and CLI edge cases."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+
+import pytest
+
+from deadcode.cli import cli
+
+
+class TestMainModule:
+    """Tests for __main__.py entry point (0% coverage)."""
+
+    def test_main_module_runs_help(self):
+        """python -m deadcode --help works (covers __main__.py:2-5)."""
+        result = subprocess.run(
+            [sys.executable, "-m", "deadcode", "--help"],
+            capture_output=True, text=False,
+        )
+        assert result.returncode == 0
+        assert b"Usage" in result.stdout
+
+
+class TestCliEdgeCases:
+    """Edge cases for CLI uncovered paths."""
+
+    def test_non_existent_project_exits_1(self):
+        """Scan with non-existent project exits 1 (cli.py:88-90)."""
+        result = subprocess.run(
+            [sys.executable, "-m", "deadcode", "--project", "/nonexistent/path", "scan"],
+            capture_output=True, text=False,
+        )
+        assert result.returncode == 1
+
+    def test_fail_threshold_exits_high(self, tmp_path):
+        """--fail=0 exits 1 when findings exist (covers fail threshold path)."""
+        (tmp_path / "src" / "unused.ts").parent.mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "unused.ts").write_text("export function unused() { return 1; }\n")
+        result = subprocess.run(
+            [sys.executable, "-m", "deadcode", "-p", str(tmp_path), "scan",
+             "--fail", "0"],
+            capture_output=True, text=True,
+        )
+        assert result.returncode == 1
+        assert "FAIL" in result.stdout
+
+    def test_ignore_flag_before_subcommand(self, tmp_path):
+        """--ignore group option rejects submodule patterns (covers _merge_config_ignore)."""
+        (tmp_path / "src" / "used.ts").parent.mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "used.ts").write_text("export function used() { return 1; }\n")
+        (tmp_path / "src" / "unused.ts").write_text("export function unused() { return 2; }\n")
+        result = subprocess.run(
+            [sys.executable, "-m", "deadcode", "-p", str(tmp_path),
+             "--ignore", "**/unused.ts", "scan"],
+            capture_output=True, text=True,
+        )
+        assert result.returncode == 0
+        assert "unused" not in result.stdout
+
+
+class TestCliFormatOutput:
+    """Tests for scan --format output modes (added in PR #34)."""
+
+    @pytest.fixture
+    def runner(self):
+        from click.testing import CliRunner
+        return CliRunner()
+
+    @pytest.fixture
+    def sample(self, tmp_path):
+        """A tiny TS project with at least one dead export."""
+        mod = tmp_path / "src" / "mod.ts"
+        mod.parent.mkdir(parents=True, exist_ok=True)
+        mod.write_text(
+            'export function usedHelper() { return 1; }\n'
+            'export function unusedHelper() { return 2; }\n'
+        )
+        return tmp_path
+
+    def test_format_compact_output(self, runner, sample):
+        """--format=compact produces one-line-per-finding output."""
+        result = runner.invoke(cli, ["-p", str(sample), "scan", "--format", "compact"])
+        assert result.exit_code == 0
+        assert "0 findings" not in result.output
+        assert "unusedHelper" in result.output
+        assert "unused_export" in result.output
+
+    def test_format_github_annotations(self, runner, sample):
+        """--format=github produces ::warning/::error annotations."""
+        result = runner.invoke(cli, ["-p", str(sample), "scan", "--format", "github"])
+        assert result.exit_code == 0
+        assert "::warning" in result.output or "::error" in result.output
+        assert "unusedHelper" in result.output
+
+    def test_format_pretty_default(self, runner, sample):
+        """Default pretty format shows table output."""
+        result = runner.invoke(cli, ["-p", str(sample), "scan", "--format", "pretty"])
+        assert result.exit_code == 0
+        assert "DeadCode Scan" in result.output
+
+    def test_legacy_json_output_still_works(self, runner, sample):
+        """Legacy --json-output flag maps to --format=json."""
+        result = runner.invoke(cli, ["-p", str(sample), "scan", "--json-output"])
+        assert result.exit_code == 0
+        # Scanner details may contain newlines; use strict=False
+        payload = json.loads(result.output, strict=False)
+        assert "findings" in payload
+        assert "files_scanned" in payload
+        assert len(payload["findings"]) >= 1
+
+
+class TestRemoveCommand:
+    """Tests for the `remove` CLI command."""
+
+    @pytest.fixture
+    def runner(self):
+        from click.testing import CliRunner
+        return CliRunner()
+
+    def test_remove_dry_run_nothing_removable(self, runner, tmp_path):
+        """remove --dry-run on clean project prints nothing removable."""
+        (tmp_path / "src" / "clean.ts").parent.mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "clean.ts").write_text("const x = 1;\n")
+        result = runner.invoke(cli, ["-p", str(tmp_path), "remove", "--dry-run"])
+        assert result.exit_code == 0
+        assert "Nothing removable" in result.output
+
+
+class TestStatsCommand:
+    """Tests for the `stats` CLI command."""
+
+    @pytest.fixture
+    def runner(self):
+        from click.testing import CliRunner
+        return CliRunner()
+
+    def test_stats_basic(self, runner, tmp_path):
+        """stats command shows scan summary."""
+        (tmp_path / "src" / "unused.ts").parent.mkdir(parents=True, exist_ok=True)
+        (tmp_path / "src" / "unused.ts").write_text(
+            "export function unusedHelper() { return 1; }\n"
+        )
+        result = runner.invoke(cli, ["-p", str(tmp_path), "stats"])
+        assert result.exit_code == 0
+        assert "Files scanned" in result.output

tests/test_config_and_fixes.py

@@ -129,6 +129,14 @@ def test_load_invalid_yml(self, tmp_path):
         # Should fall back to defaults
         assert config.ignore == []
 
+    def test_load_yaml_list_returns_defaults(self, tmp_path):
+        """When .deadcode.yml is a list (not a dict), config falls back to defaults (covers config.py:56)."""
+        config_file = tmp_path / ".deadcode.yml"
+        config_file.write_text("- item1\n- item2\n")
+        config = DeadCodeConfig.load(tmp_path)
+        assert config.ignore == []
+        assert config.fail_threshold == -1
+
 
 class TestFailOption:
     def test_fail_exits_1_when_threshold_met(self, runner, sample_project):
@@ -193,6 +201,23 @@ def test_cli_ignore_overrides_config(self, runner, tmp_path):
         data = json.loads(result.output, strict=False)
         assert len(data["findings"]) == 0
 
+    def test_merge_config_and_cli_ignore(self, runner, tmp_path):
+        """Both config ignore AND CLI --ignore should merge together (covers cli.py:52 branch)."""
+        mod = tmp_path / "src" / "mod.ts"
+        mod.parent.mkdir(parents=True, exist_ok=True)
+        mod.write_text('export function unused() { return 1; }\n')
+
+        config = tmp_path / ".deadcode.yml"
+        config.write_text('ignore:\n  - "nonexistent/"\n')
+
+        # CLI --ignore with a matching pattern
+        result = runner.invoke(cli, ["-p", str(tmp_path), "-i", "*.ts", "scan", "--json-output"])
+        assert result.exit_code == 0
+        data = json.loads(result.output, strict=False)
+        # Both ignores combined should cover the .ts file
+        assert len(data["findings"]) == 0, \
+            f"Expected 0 findings with merged ignores, got {len(data['findings'])}"
+
 
 class TestBugFixUnreferencedComponents:
     def test_component_imported_not_reported(self, tmp_path):
@@ -441,6 +466,28 @@ def test_remove_no_removable_findings(self, tmp_path):
             # If there are removable findings, verify the output is still valid
             assert result.exit_code == 0
 
+    def test_remove_missing_file_skips_gracefully(self, tmp_path):
+        """remove should skip files that disappeared after scan (covers cli.py:248 path)."""
+        mod = tmp_path / "src" / "mod.ts"
+        mod.parent.mkdir(parents=True, exist_ok=True)
+        mod.write_text('export function unusedFunc() { return 1; }\n')
+
+        from click.testing import CliRunner
+        runner = CliRunner()
+
+        import json
+        scan_result = runner.invoke(cli, ["-p", str(tmp_path), "scan", "--json-output"])
+        assert scan_result.exit_code == 0
+        data = json.loads(scan_result.output, strict=False)
+        removable = [f for f in data["findings"] if f.get("removable")]
+        if removable:
+            fpath = tmp_path / removable[0]["file"]
+            if fpath.exists():
+                fpath.unlink()
+
+        result = runner.invoke(cli, ["-p", str(tmp_path), "remove", "-c", "unused_export"])
+        assert result.exit_code == 0
+
 
 class TestPackagingQuality:
     """Tests for packaging quality: entry point, py.typed, ruff config."""
@@ -479,6 +526,20 @@ def test_ruff_known_first_party(self):
         kfp = isort_cfg.get("known-first-party", [])
         assert kfp == ["deadcode"], f"known-first-party should be ['deadcode'], got {kfp}"
 
+    def test_package_data_includes_py_typed(self):
+        """pyproject.toml should have package-data config for py.typed."""
+        from pathlib import Path
+
+        import tomllib
+
+        pyproject = Path(__file__).parent.parent / "pyproject.toml"
+        with open(pyproject, "rb") as f:
+            data = tomllib.load(f)
+        pkg_data = data.get("tool", {}).get("setuptools", {}).get("package-data", {})
+        assert "deadcode" in pkg_data, "Expected [tool.setuptools.package-data] section for 'deadcode'"
+        assert "py.typed" in pkg_data["deadcode"], \
+            f"Expected 'py.typed' in package-data for deadcode, got {pkg_data['deadcode']}"
+
 
 class TestScannerEdgeCases:
     """Edge case tests for scanner uncovered paths."""
@@ -590,4 +651,37 @@ def _failing_read_text(self_path, *args, **kwargs):
             result = scanner.scan()
 
         assert len(result.errors) > 0
-        assert result.files_scanned == 1  # file was still counted
+        assert result.files_scanned == 1
+
+    def test_default_import_parsed_correctly(self, tmp_path):
+        """Default imports (import Foo from) should be parsed (covers scanner.py:290-292)."""
+        mod = tmp_path / "src" / "helper.ts"
+        mod.parent.mkdir(parents=True, exist_ok=True)
+        mod.write_text('export function helper() { return 1; }\n')
+
+        consumer = tmp_path / "src" / "consumer.ts"
+        consumer.write_text('import helper from "./helper";\nhelper();\n')
+
+        scanner = DeadCodeScanner(tmp_path)
+        result = scanner.scan()
+
+        unused_names = {f.name for f in result.unused_exports}
+        assert "helper" not in unused_names, \
+            "helper should be recognized as imported via default import"
+
+    def test_scan_collect_files_with_ignore(self, tmp_path):
+        """Scanner._collect_files handles ignore_spec correctly (covers scanner.py:238-241)."""
+        mod = tmp_path / "src" / "mod.ts"
+        mod.parent.mkdir(parents=True, exist_ok=True)
+        mod.write_text('export function foo() { return 1; }\n')
+
+        internal = tmp_path / "src" / "internal" / "helper.ts"
+        internal.parent.mkdir(parents=True, exist_ok=True)
+        internal.write_text('export function bar() { return 2; }\n')
+
+        scanner = DeadCodeScanner(tmp_path, ignore_patterns=["src/internal/"])
+        result = scanner.scan()
+        assert result.files_scanned == 1, "internal/ should be ignored"
+        unused_names = {f.name for f in result.unused_exports}
+        assert "foo" in unused_names
+        assert "bar" not in unused_names  # file was still counted