Refuse a Path That Does Not Exist, Rather Than Scanning the Caller's Directory

`discover` reads any argument that is neither a file nor a directory as
`.`, so a typo scanned the caller's directory while the rule set anchored
on the missing path's parent. The run then described one tree and judged it
by another, which is this PR's own subject in a different guise.

A missing path is now refused, naming each one.

Two existing cases passed fake paths as a mocking convenience and were
refused by the new check before reaching the guard they exist to test. They
use real directories now, which preserves what they assert rather than
loosening the check to accommodate them.

Two cases added: a missing path is refused, and an existing one is not.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ptr727

scripts/prose_lint.py

@@ -1110,6 +1110,14 @@ def main(argv: list[str] | None = None) -> int:
     # Only a repository declares a model, so two of them refuse and anything else resolves to one anchor.
     # TestScanRootDecidesTheRuleSet carries the cases and the reason each one exists.
     scan_paths = a.paths or ['.']
+    # A path that does not exist is refused rather than absorbed.
+    # `discover` reads a non-file, non-directory argument as `.`, so a typo scanned the caller's directory while the rule set anchored on the missing path's parent.
+    absent = [p for p in scan_paths if not Path(p).exists()]
+    if absent:
+        print(f"error: requested path(s) do not exist: {', '.join(sorted(absent))}. Refusing "
+              'rather than falling back to the current directory, which would scan one tree and '
+              'choose the rule set from another.', file=sys.stderr)
+        return 2
     git_roots = {found for found in (repo_root(Path(p)) for p in scan_paths) if found}
     if len(git_roots) > 1:
         print('error: the requested paths span more than one repository (' +

scripts/test_prose_lint.py

@@ -1528,20 +1528,26 @@ def test_a_path_under_no_repository_is_refused_too(self) -> None:
         repository-relative ones, so the scope drops every file and the run exits 0. Testing for
         a *different* root missed this, because there is no root to differ from.
         """
+        # A real directory, since a path that does not exist is refused earlier for another reason.
+        # That would pass this assertion without ever exercising the diff guard.
+        loose = self.tmp / 'loose'
+        loose.mkdir()
         with mock.patch.object(prose_lint, 'repo_root',
                                side_effect=lambda p: '/hub' if str(p) == '.' else ''), \
                 contextlib.redirect_stderr(io.StringIO()) as err:
-            self.assertEqual(2, prose_lint.main(['--diff', 'HEAD', '/tmp/loose']))
+            self.assertEqual(2, prose_lint.main(['--diff', 'HEAD', str(loose)]))
         self.assertIn('no git repository', err.getvalue())
 
     def test_list_files_still_reports_scope_across_repositories(self) -> None:
         """It reports the scan scope and never consults the diff, so the guard must not stop it."""
         clean = self.tmp / 'clean.md'
         clean.write_text('fine\n', encoding='utf-8')
+        other = self.tmp / 'other'
+        other.mkdir()
         with mock.patch.object(prose_lint, 'repo_root',
                                side_effect=lambda p: '/hub' if str(p) == '.' else '/other'), \
                 mock.patch.object(prose_lint, 'discover', return_value=[clean]):
-            self.assertEqual(0, prose_lint.main(['--list-files', '--diff', 'HEAD', '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/other/tree']))
+            self.assertEqual(0, prose_lint.main(['--list-files', '--diff', 'HEAD', str(other)]))
 
     def test_a_matching_repository_is_not_refused(self) -> None:
         """The guard must not reject the ordinary case it sits in front of."""
@@ -1851,6 +1857,26 @@ def test_paths_spanning_two_repositories_refuse_rather_than_pick_one(self) -> No
                 [str(self.release), str(self.operational), '--check', 'home-path']))
         self.assertIn('more than one repository', self.err.getvalue())
 
+    def test_a_path_that_does_not_exist_is_refused_rather_than_absorbed(self) -> None:
+        """`discover` reads a non-file, non-directory argument as `.`.
+
+        A typo therefore scanned the caller's directory while the rule set anchored on the missing
+        path's parent, so the run described one tree and judged it by another.
+        """
+        with mock.patch.object(prose_lint, 'repo_root', return_value=''):
+            self.assertEqual(2, prose_lint.main(
+                [str(self.tmp / 'no-such-dir'), '--check', 'home-path']))
+        self.assertIn('do not exist', self.err.getvalue())
+
+    def test_an_existing_path_is_not_refused_by_that_check(self) -> None:
+        """The guard must not reject the ordinary case it sits in front of."""
+        good = self.tmp / 'good.md'
+        good.write_text('Nothing here breaks a rule.\n', encoding='utf-8')
+        with mock.patch.object(prose_lint, 'repo_root', return_value=''), \
+                mock.patch.object(prose_lint, 'discover', return_value=[good]):
+            self.assertEqual(0, prose_lint.main([str(good), '--check', 'home-path']))
+        self.assertNotIn('do not exist', self.err.getvalue())
+
     def test_several_paths_under_no_repository_are_not_a_conflict(self) -> None:
         """Only a repository declares a model, so two loose paths are not ambiguous.