@pennyfarthing/core 11.3.3 → 11.3.5

package/{pennyfarthing_scripts → pennyfarthing-dist/pf}/tests/test_cli_modules.py

@@ -1,6 +1,6 @@
 """Tests for CLI entry point modules.
 
-Story 63-9: Reorganize pennyfarthing_scripts into fan-out CLI pattern.
+Story 63-9: Reorganize pf into fan-out CLI pattern.
 
 These tests verify the CLI modules work as entry points and
 properly delegate to library modules.
@@ -16,7 +16,7 @@ class TestJiraCLIModule:
     def test_jira_cli_help(self) -> None:
         """jira CLI should show help with --help."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "--help"],
+            [sys.executable, "-m", "pf.jira", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -29,7 +29,7 @@ class TestJiraCLIModule:
     def test_jira_cli_view_subcommand(self) -> None:
         """jira CLI should have view subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "view", "--help"],
+            [sys.executable, "-m", "pf.jira", "view", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -41,7 +41,7 @@ class TestJiraCLIModule:
     def test_jira_cli_sync_subcommand(self) -> None:
         """jira CLI should have sync subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "sync", "--help"],
+            [sys.executable, "-m", "pf.jira", "sync", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -52,7 +52,7 @@ class TestJiraCLIModule:
     def test_jira_cli_claim_subcommand(self) -> None:
         """jira CLI should have claim subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "claim", "--help"],
+            [sys.executable, "-m", "pf.jira", "claim", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -63,7 +63,7 @@ class TestJiraCLIModule:
     def test_jira_cli_create_subcommand(self) -> None:
         """jira CLI should have create subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "create", "--help"],
+            [sys.executable, "-m", "pf.jira", "create", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -74,7 +74,7 @@ class TestJiraCLIModule:
     def test_jira_cli_bidirectional_subcommand(self) -> None:
         """jira CLI should have bidirectional subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "bidirectional", "--help"],
+            [sys.executable, "-m", "pf.jira", "bidirectional", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -89,7 +89,7 @@ class TestSprintCLIModule:
     def test_sprint_cli_help(self) -> None:
         """sprint CLI should show help with --help."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "--help"],
+            [sys.executable, "-m", "pf.sprint", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -101,7 +101,7 @@ class TestSprintCLIModule:
     def test_sprint_cli_status_subcommand(self) -> None:
         """sprint CLI should have status subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "status", "--help"],
+            [sys.executable, "-m", "pf.sprint", "status", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -112,7 +112,7 @@ class TestSprintCLIModule:
     def test_sprint_cli_backlog_subcommand(self) -> None:
         """sprint CLI should have backlog subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "backlog", "--help"],
+            [sys.executable, "-m", "pf.sprint", "backlog", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -123,7 +123,7 @@ class TestSprintCLIModule:
     def test_sprint_cli_work_subcommand(self) -> None:
         """sprint CLI should have work subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "work", "--help"],
+            [sys.executable, "-m", "pf.sprint", "work", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -134,7 +134,7 @@ class TestSprintCLIModule:
     def test_sprint_cli_archive_subcommand(self) -> None:
         """sprint CLI should have archive subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "archive", "--help"],
+            [sys.executable, "-m", "pf.sprint", "archive", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -149,7 +149,7 @@ class TestStoryCLIModule:
     def test_story_cli_help(self) -> None:
         """story CLI should show help with --help."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.story", "--help"],
+            [sys.executable, "-m", "pf.story", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -161,7 +161,7 @@ class TestStoryCLIModule:
     def test_story_cli_size_subcommand(self) -> None:
         """story CLI should have size subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.story", "size", "--help"],
+            [sys.executable, "-m", "pf.story", "size", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -172,7 +172,7 @@ class TestStoryCLIModule:
     def test_story_cli_template_subcommand(self) -> None:
         """story CLI should have template subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.story", "template", "--help"],
+            [sys.executable, "-m", "pf.story", "template", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -183,7 +183,7 @@ class TestStoryCLIModule:
     def test_story_cli_create_subcommand(self) -> None:
         """story CLI should have create subcommand."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.story", "create", "--help"],
+            [sys.executable, "-m", "pf.story", "create", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -198,7 +198,7 @@ class TestOldCLICompatibility:
     def test_jira_sync_module_runnable(self) -> None:
         """jira_sync.py should still be runnable as module."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira_sync", "--help"],
+            [sys.executable, "-m", "pf.jira_sync", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -210,7 +210,7 @@ class TestOldCLICompatibility:
     def test_jira_bidirectional_sync_module_runnable(self) -> None:
         """jira_bidirectional_sync.py should still be runnable."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira_bidirectional_sync", "--help"],
+            [sys.executable, "-m", "pf.jira_bidirectional_sync", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -221,7 +221,7 @@ class TestOldCLICompatibility:
     def test_jira_epic_creation_module_runnable(self) -> None:
         """jira_epic_creation.py should still be runnable."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira_epic_creation", "--help"],
+            [sys.executable, "-m", "pf.jira_epic_creation", "--help"],
             capture_output=True,
             text=True,
             timeout=30,
@@ -232,7 +232,7 @@ class TestOldCLICompatibility:
     def test_jira_sync_story_module_runnable(self) -> None:
         """jira_sync_story.py should still be runnable."""
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira_sync_story", "--help"],
+            [sys.executable, "-m", "pf.jira_sync_story", "--help"],
             capture_output=True,
             text=True,
             timeout=30,

package/{pennyfarthing_scripts → pennyfarthing-dist/pf}/tests/test_cli_normalization.py

@@ -21,7 +21,7 @@ import click.testing
 
 def _get_cli():
     """Import the CLI group lazily to avoid import-time side effects."""
-    from pennyfarthing_scripts.cli import cli
+    from pf.cli import cli
     return cli
 
 

package/{pennyfarthing_scripts → pennyfarthing-dist/pf}/tests/test_codemarkers.py

@@ -26,7 +26,7 @@ class TestCodeMarkerModel:
 
     def test_required_fields(self) -> None:
         """CodeMarker requires path, line, marker_type, text."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.models import CodeMarker
 
         m = CodeMarker(path="src/app.ts", line=42, marker_type="TODO", text="TODO: refactor")
         assert m.path == "src/app.ts"
@@ -36,7 +36,7 @@ class TestCodeMarkerModel:
 
     def test_default_blame_fields(self) -> None:
         """Blame fields default to empty/zero."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.models import CodeMarker
 
         m = CodeMarker(path="a.py", line=1, marker_type="FIXME", text="FIXME: broken")
         assert m.author == ""
@@ -46,7 +46,7 @@ class TestCodeMarkerModel:
 
     def test_stale_marker(self) -> None:
         """is_stale can be set to True."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.models import CodeMarker
 
         m = CodeMarker(
             path="old.py", line=10, marker_type="TODO", text="TODO: old",
@@ -57,7 +57,7 @@ class TestCodeMarkerModel:
 
     def test_serializable(self) -> None:
         """CodeMarker should be serializable via dataclasses.asdict."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.models import CodeMarker
 
         m = CodeMarker(path="x.py", line=5, marker_type="HACK", text="HACK: workaround")
         d = asdict(m)
@@ -71,7 +71,7 @@ class TestMarkerSummaryModel:
 
     def test_defaults(self) -> None:
         """MarkerSummary fields default to zero/empty."""
-        from pennyfarthing_scripts.codemarkers.models import MarkerSummary
+        from pf.codemarkers.models import MarkerSummary
 
         s = MarkerSummary()
         assert s.total_markers == 0
@@ -80,7 +80,7 @@ class TestMarkerSummaryModel:
 
     def test_populated(self) -> None:
         """MarkerSummary with values."""
-        from pennyfarthing_scripts.codemarkers.models import MarkerSummary
+        from pf.codemarkers.models import MarkerSummary
 
         s = MarkerSummary(
             total_markers=10, stale_markers=3,
@@ -95,7 +95,7 @@ class TestCodeMarkersResultModel:
 
     def test_success_result(self) -> None:
         """Successful result has success=True and markers list."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker, CodeMarkersResult
+        from pf.codemarkers.models import CodeMarker, CodeMarkersResult
 
         r = CodeMarkersResult(
             success=True, repo_name="test", repo_path="/tmp/test",
@@ -108,7 +108,7 @@ class TestCodeMarkersResultModel:
 
     def test_error_result(self) -> None:
         """Error result has success=False and error message."""
-        from pennyfarthing_scripts.codemarkers.models import CodeMarkersResult
+        from pf.codemarkers.models import CodeMarkersResult
 
         r = CodeMarkersResult(
             success=False, repo_name="bad", repo_path="/nonexistent",
@@ -119,7 +119,7 @@ class TestCodeMarkersResultModel:
 
     def test_json_serializable(self) -> None:
         """Full result serializes to JSON via asdict."""
-        from pennyfarthing_scripts.codemarkers.models import (
+        from pf.codemarkers.models import (
             CodeMarker,
             CodeMarkersResult,
             MarkerSummary,
@@ -147,7 +147,7 @@ class TestGrepMarkers:
 
     def test_finds_todo(self, tmp_path: Path) -> None:
         """Detects TODO comments."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "app.py"
         f.write_text("x = 1\n# TODO: fix this\ny = 2\n")
@@ -158,7 +158,7 @@ class TestGrepMarkers:
 
     def test_finds_fixme(self, tmp_path: Path) -> None:
         """Detects FIXME comments."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "bug.ts"
         f.write_text("// FIXME: null check needed\n")
@@ -168,7 +168,7 @@ class TestGrepMarkers:
 
     def test_finds_hack(self, tmp_path: Path) -> None:
         """Detects HACK comments."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "util.js"
         f.write_text("/* HACK: temporary workaround */\n")
@@ -178,7 +178,7 @@ class TestGrepMarkers:
 
     def test_finds_xxx(self, tmp_path: Path) -> None:
         """Detects XXX comments."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "danger.py"
         f.write_text("# XXX: this is terrible\n")
@@ -188,7 +188,7 @@ class TestGrepMarkers:
 
     def test_multiple_markers_same_file(self, tmp_path: Path) -> None:
         """Finds multiple markers in a single file."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "multi.py"
         f.write_text("# TODO: first\nx = 1\n# FIXME: second\n# HACK: third\n")
@@ -199,7 +199,7 @@ class TestGrepMarkers:
 
     def test_excludes_node_modules(self, tmp_path: Path) -> None:
         """Files matching exclude patterns are skipped."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         nm = tmp_path / "node_modules" / "pkg"
         nm.mkdir(parents=True)
@@ -213,7 +213,7 @@ class TestGrepMarkers:
 
     def test_case_sensitive(self, tmp_path: Path) -> None:
         """Markers must be uppercase to match."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         f = tmp_path / "lower.py"
         f.write_text("# todo: lowercase should not match\n# TODO: uppercase matches\n")
@@ -223,7 +223,7 @@ class TestGrepMarkers:
 
     def test_nested_directories(self, tmp_path: Path) -> None:
         """Scans recursively into subdirectories."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         sub = tmp_path / "src" / "lib"
         sub.mkdir(parents=True)
@@ -233,7 +233,7 @@ class TestGrepMarkers:
 
     def test_empty_directory(self, tmp_path: Path) -> None:
         """Returns empty list for directory with no markers."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         (tmp_path / "clean.py").write_text("x = 1\ny = 2\n")
         markers = _grep_markers(tmp_path, excludes=[])
@@ -241,7 +241,7 @@ class TestGrepMarkers:
 
     def test_binary_files_skipped(self, tmp_path: Path) -> None:
         """Binary files should not cause crashes."""
-        from pennyfarthing_scripts.codemarkers.analyze import _grep_markers
+        from pf.codemarkers.analyze import _grep_markers
 
         (tmp_path / "image.png").write_bytes(b"\x89PNG\r\n\x1a\n" + b"\x00" * 100)
         (tmp_path / "code.py").write_text("# TODO: real marker\n")
@@ -254,7 +254,7 @@ class TestParseBlameOutput:
 
     def test_parses_author_and_time(self) -> None:
         """Extracts author name and author-time from porcelain output."""
-        from pennyfarthing_scripts.codemarkers.analyze import _parse_blame_porcelain
+        from pf.codemarkers.analyze import _parse_blame_porcelain
 
         porcelain = (
             "abc123 1 1 1\n"
@@ -276,7 +276,7 @@ class TestParseBlameOutput:
 
     def test_empty_output(self) -> None:
         """Returns empty dict for empty output."""
-        from pennyfarthing_scripts.codemarkers.analyze import _parse_blame_porcelain
+        from pf.codemarkers.analyze import _parse_blame_porcelain
 
         result = _parse_blame_porcelain("", line=1)
         assert result == {} or result.get("author") == ""
@@ -288,7 +288,7 @@ class TestBatchBlame:
     @pytest.mark.asyncio
     async def test_blames_entire_file(self) -> None:
         """Blames the whole file and returns data for requested lines."""
-        from pennyfarthing_scripts.codemarkers.analyze import _batch_blame_file
+        from pf.codemarkers.analyze import _batch_blame_file
 
         blame_output = (
             "abc123 1 1 1\n"
@@ -314,7 +314,7 @@ class TestBatchBlame:
         )
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._run_git_command",
+            "pf.codemarkers.analyze._run_git_command",
             new_callable=AsyncMock,
             return_value=(blame_output, "", 0),
         ):
@@ -329,10 +329,10 @@ class TestBatchBlame:
     @pytest.mark.asyncio
     async def test_git_blame_failure_returns_empty(self) -> None:
         """When git blame fails, returns empty dict for all lines."""
-        from pennyfarthing_scripts.codemarkers.analyze import _batch_blame_file
+        from pf.codemarkers.analyze import _batch_blame_file
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._run_git_command",
+            "pf.codemarkers.analyze._run_git_command",
             new_callable=AsyncMock,
             return_value=("", "fatal: not a git repo", 128),
         ):
@@ -346,7 +346,7 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_nonexistent_path(self) -> None:
         """Returns error result for nonexistent path."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         result = await analyze_repo("bad", Path("/nonexistent/repo"), days=90)
         assert result.success is False
@@ -355,13 +355,13 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_empty_repo(self, tmp_path: Path) -> None:
         """Returns success with empty markers for repo with no markers."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         (tmp_path / ".git").mkdir()
         (tmp_path / "clean.py").write_text("x = 1\n")
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._batch_blame_file",
+            "pf.codemarkers.analyze._batch_blame_file",
             new_callable=AsyncMock,
             return_value={},
         ):
@@ -372,7 +372,7 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_markers_enriched_with_blame(self, tmp_path: Path) -> None:
         """Markers get author, date, age_days from git blame."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         (tmp_path / ".git").mkdir()
         (tmp_path / "app.py").write_text("x = 1\n# TODO: fix this\ny = 2\n")
@@ -387,7 +387,7 @@ class TestAnalyzeRepo:
             }
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._batch_blame_file",
+            "pf.codemarkers.analyze._batch_blame_file",
             side_effect=mock_blame,
         ):
             result = await analyze_repo("test", tmp_path, days=90)
@@ -399,7 +399,7 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_stale_threshold(self, tmp_path: Path) -> None:
         """Markers older than threshold are flagged is_stale=True."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         (tmp_path / ".git").mkdir()
         (tmp_path / "old.py").write_text("# TODO: ancient code\n")
@@ -411,7 +411,7 @@ class TestAnalyzeRepo:
             return {1: {"author": "OldDev", "author_time": old_time}}
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._batch_blame_file",
+            "pf.codemarkers.analyze._batch_blame_file",
             side_effect=mock_blame,
         ):
             result = await analyze_repo("test", tmp_path, days=90)
@@ -421,7 +421,7 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_summary_computed(self, tmp_path: Path) -> None:
         """Result includes summary with counts by type."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         (tmp_path / ".git").mkdir()
         (tmp_path / "mix.py").write_text("# TODO: one\n# FIXME: two\n# TODO: three\n")
@@ -433,7 +433,7 @@ class TestAnalyzeRepo:
             return {ln: {"author": "Dev", "author_time": recent} for ln in lines}
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._batch_blame_file",
+            "pf.codemarkers.analyze._batch_blame_file",
             side_effect=mock_blame,
         ):
             result = await analyze_repo("test", tmp_path, days=90)
@@ -446,7 +446,7 @@ class TestAnalyzeRepo:
     @pytest.mark.asyncio
     async def test_default_excludes_applied(self, tmp_path: Path) -> None:
         """DEFAULT_EXCLUDES filters out node_modules, dist, etc."""
-        from pennyfarthing_scripts.codemarkers.analyze import analyze_repo
+        from pf.codemarkers.analyze import analyze_repo
 
         (tmp_path / ".git").mkdir()
         nm = tmp_path / "node_modules" / "pkg"
@@ -461,7 +461,7 @@ class TestAnalyzeRepo:
             return {ln: {"author": "Dev", "author_time": recent} for ln in lines}
 
         with patch(
-            "pennyfarthing_scripts.codemarkers.analyze._batch_blame_file",
+            "pf.codemarkers.analyze._batch_blame_file",
             side_effect=mock_blame,
         ):
             result = await analyze_repo("test", tmp_path, days=90)
@@ -473,22 +473,22 @@ class TestShouldExclude:
     """_should_exclude matches file paths against glob patterns."""
 
     def test_matches_node_modules(self) -> None:
-        from pennyfarthing_scripts.codemarkers.analyze import _should_exclude
+        from pf.codemarkers.analyze import _should_exclude
 
         assert _should_exclude("node_modules/pkg/index.js", ["node_modules/*"]) is True
 
     def test_matches_lock_file(self) -> None:
-        from pennyfarthing_scripts.codemarkers.analyze import _should_exclude
+        from pf.codemarkers.analyze import _should_exclude
 
         assert _should_exclude("package-lock.json", ["package-lock.json"]) is True
 
     def test_matches_glob_extension(self) -> None:
-        from pennyfarthing_scripts.codemarkers.analyze import _should_exclude
+        from pf.codemarkers.analyze import _should_exclude
 
         assert _should_exclude("bundle.min.js", ["*.min.js"]) is True
 
     def test_no_match(self) -> None:
-        from pennyfarthing_scripts.codemarkers.analyze import _should_exclude
+        from pf.codemarkers.analyze import _should_exclude
 
         assert _should_exclude("src/app.py", ["node_modules/*", "dist/*"]) is False
 
@@ -503,15 +503,15 @@ class TestTableFormatter:
 
     def test_empty_list(self) -> None:
         """Empty marker list produces 'no markers' message."""
-        from pennyfarthing_scripts.codemarkers.formatters import format_marker_table
+        from pf.codemarkers.formatters import format_marker_table
 
         out = format_marker_table([])
         assert "no" in out.lower() or "No" in out
 
     def test_table_has_headers(self) -> None:
         """Table output includes column headers."""
-        from pennyfarthing_scripts.codemarkers.formatters import format_marker_table
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.formatters import format_marker_table
+        from pf.codemarkers.models import CodeMarker
 
         markers = [
             CodeMarker(path="a.py", line=1, marker_type="TODO", text="TODO: test",
@@ -524,8 +524,8 @@ class TestTableFormatter:
 
     def test_top_n_limits_output(self) -> None:
         """Table respects top_n limit."""
-        from pennyfarthing_scripts.codemarkers.formatters import format_marker_table
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.formatters import format_marker_table
+        from pf.codemarkers.models import CodeMarker
 
         markers = [
             CodeMarker(path=f"f{i}.py", line=i, marker_type="TODO", text=f"TODO: {i}")
@@ -541,8 +541,8 @@ class TestJsonExport:
     """export_json serializes full result to JSON."""
 
     def test_valid_json(self) -> None:
-        from pennyfarthing_scripts.codemarkers.formatters import export_json
-        from pennyfarthing_scripts.codemarkers.models import (
+        from pf.codemarkers.formatters import export_json
+        from pf.codemarkers.models import (
             CodeMarker,
             CodeMarkersResult,
             MarkerSummary,
@@ -564,8 +564,8 @@ class TestCsvExport:
     """export_csv outputs CSV with headers."""
 
     def test_csv_header_row(self) -> None:
-        from pennyfarthing_scripts.codemarkers.formatters import export_csv
-        from pennyfarthing_scripts.codemarkers.models import CodeMarker
+        from pf.codemarkers.formatters import export_csv
+        from pf.codemarkers.models import CodeMarker
 
         markers = [
             CodeMarker(path="a.py", line=1, marker_type="TODO", text="TODO: test"),
@@ -589,7 +589,7 @@ class TestCLI:
         """codemarkers group shows help."""
         from click.testing import CliRunner
 
-        from pennyfarthing_scripts.codemarkers.cli import codemarkers
+        from pf.codemarkers.cli import codemarkers
 
         runner = CliRunner()
         result = runner.invoke(codemarkers, ["--help"])
@@ -600,7 +600,7 @@ class TestCLI:
         """analyze subcommand is registered."""
         from click.testing import CliRunner
 
-        from pennyfarthing_scripts.codemarkers.cli import codemarkers
+        from pf.codemarkers.cli import codemarkers
 
         runner = CliRunner()
         result = runner.invoke(codemarkers, ["analyze", "--help"])
@@ -612,7 +612,7 @@ class TestCLI:
         """stale subcommand is registered."""
         from click.testing import CliRunner
 
-        from pennyfarthing_scripts.codemarkers.cli import codemarkers
+        from pf.codemarkers.cli import codemarkers
 
         runner = CliRunner()
         result = runner.invoke(codemarkers, ["stale", "--help"])
@@ -622,7 +622,7 @@ class TestCLI:
         """summary subcommand is registered."""
         from click.testing import CliRunner
 
-        from pennyfarthing_scripts.codemarkers.cli import codemarkers
+        from pf.codemarkers.cli import codemarkers
 
         runner = CliRunner()
         result = runner.invoke(codemarkers, ["summary", "--help"])
@@ -632,13 +632,13 @@ class TestCLI:
         """--format json produces JSON output."""
         from click.testing import CliRunner
 
-        from pennyfarthing_scripts.codemarkers.cli import codemarkers
+        from pf.codemarkers.cli import codemarkers
 
         runner = CliRunner()
         with patch(
-            "pennyfarthing_scripts.codemarkers.cli._run_analysis"
+            "pf.codemarkers.cli._run_analysis"
         ) as mock_run:
-            from pennyfarthing_scripts.codemarkers.models import CodeMarkersResult, MarkerSummary
+            from pf.codemarkers.models import CodeMarkersResult, MarkerSummary
             mock_run.return_value = CodeMarkersResult(
                 success=True, repo_name="test", repo_path="/tmp",
                 stale_threshold_days=90, markers=[],
@@ -651,7 +651,7 @@ class TestCLI:
 
 
 class TestMainModule:
-    """python -m pennyfarthing_scripts.codemarkers works."""
+    """python -m pf.codemarkers works."""
 
     def test_module_runnable(self) -> None:
         """Module can be invoked with --help."""
@@ -659,7 +659,7 @@ class TestMainModule:
         import sys
 
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.codemarkers", "--help"],
+            [sys.executable, "-m", "pf.codemarkers", "--help"],
             capture_output=True, text=True, timeout=30,
         )
         assert result.returncode == 0
@@ -675,7 +675,7 @@ class TestModuleExports:
     """__init__.py re-exports key symbols."""
 
     def test_exports_models(self) -> None:
-        from pennyfarthing_scripts.codemarkers import (
+        from pf.codemarkers import (
             CodeMarker,
             CodeMarkersResult,
         )
@@ -683,5 +683,5 @@ class TestModuleExports:
         assert CodeMarkersResult is not None
 
     def test_exports_analyze(self) -> None:
-        from pennyfarthing_scripts.codemarkers import analyze_repo
+        from pf.codemarkers import analyze_repo
         assert callable(analyze_repo)