@pennyfarthing/core 11.3.3 → 11.3.5

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

@@ -1,6 +1,6 @@
 """Tests for the fan-out CLI package structure.
 
-Story 63-9: Reorganize pennyfarthing_scripts into fan-out CLI pattern.
+Story 63-9: Reorganize pf into fan-out CLI pattern.
 
 These tests verify:
 1. Library packages exist (jira/, sprint/, story/, common/)
@@ -18,13 +18,13 @@ class TestCommonPackage:
 
     def test_common_package_exists(self) -> None:
         """common/ package should exist and be importable."""
-        from pennyfarthing_scripts import common
+        from pf import common
 
         assert common is not None
 
     def test_output_module_in_common(self) -> None:
         """output.py should be importable from common/."""
-        from pennyfarthing_scripts.common import output
+        from pf.common import output
 
         assert hasattr(output, "success")
         assert hasattr(output, "info")
@@ -34,7 +34,7 @@ class TestCommonPackage:
 
     def test_config_module_in_common(self) -> None:
         """config.py should be importable from common/."""
-        from pennyfarthing_scripts.common import config
+        from pf.common import config
 
         assert hasattr(config, "get_project_root")
         assert hasattr(config, "load_yaml_config")
@@ -42,7 +42,7 @@ class TestCommonPackage:
 
     def test_output_backwards_compatibility(self) -> None:
         """Old import path should still work for backwards compatibility."""
-        from pennyfarthing_scripts import output
+        from pf import output
 
         # Should re-export from common.output
         assert hasattr(output, "success")
@@ -50,7 +50,7 @@ class TestCommonPackage:
 
     def test_config_backwards_compatibility(self) -> None:
         """Old import path should still work for backwards compatibility."""
-        from pennyfarthing_scripts import config
+        from pf import config
 
         # Should re-export from common.config
         assert hasattr(config, "get_project_root")
@@ -61,14 +61,14 @@ class TestJiraPackage:
 
     def test_jira_package_exists(self) -> None:
         """jira/ package should exist and be importable."""
-        from pennyfarthing_scripts import jira
+        from pf import jira
 
         # Should be a package, not the old flat module
         assert hasattr(jira, "__path__")  # Packages have __path__
 
     def test_client_module_in_jira(self) -> None:
         """client.py should contain JiraClient and helper functions."""
-        from pennyfarthing_scripts.jira import client
+        from pf.jira import client
 
         assert hasattr(client, "JiraClient")
         assert hasattr(client, "get_issue")
@@ -78,7 +78,7 @@ class TestJiraPackage:
 
     def test_claim_module_in_jira(self) -> None:
         """claim.py should provide story claiming functionality."""
-        from pennyfarthing_scripts.jira import claim
+        from pf.jira import claim
 
         # Main function for claiming stories
         assert hasattr(claim, "claim_story")
@@ -86,7 +86,7 @@ class TestJiraPackage:
 
     def test_sync_module_in_jira(self) -> None:
         """sync.py should provide epic sync functionality."""
-        from pennyfarthing_scripts.jira import sync
+        from pf.jira import sync
 
         assert hasattr(sync, "sync_epic")
         assert hasattr(sync, "sync_story")
@@ -94,7 +94,7 @@ class TestJiraPackage:
 
     def test_bidirectional_module_in_jira(self) -> None:
         """bidirectional.py should provide bidirectional sync."""
-        from pennyfarthing_scripts.jira import bidirectional
+        from pf.jira import bidirectional
 
         assert hasattr(bidirectional, "generate_sync_plan")
         assert hasattr(bidirectional, "execute_sync_plan")
@@ -103,7 +103,7 @@ class TestJiraPackage:
 
     def test_epic_module_in_jira(self) -> None:
         """epic.py should provide epic creation functionality."""
-        from pennyfarthing_scripts.jira import epic
+        from pf.jira import epic
 
         assert hasattr(epic, "create_epic")
         assert hasattr(epic, "create_epic_from_yaml")
@@ -111,14 +111,14 @@ class TestJiraPackage:
 
     def test_story_module_in_jira(self) -> None:
         """story.py should provide story sync functionality."""
-        from pennyfarthing_scripts.jira import story
+        from pf.jira import story
 
         assert hasattr(story, "sync_story")
         assert hasattr(story, "get_story_from_sprint")
 
     def test_jira_package_reexports(self) -> None:
         """jira/__init__.py should re-export commonly used items."""
-        from pennyfarthing_scripts.jira import (
+        from pf.jira import (
             JiraClient,
             extract_jira_key,
         )
@@ -129,7 +129,7 @@ class TestJiraPackage:
     def test_jira_backwards_compatibility(self) -> None:
         """Old-style imports should still work."""
         # These imports should work for backwards compatibility
-        from pennyfarthing_scripts.jira import STATUS_TO_JIRA, JiraClient, get_issue
+        from pf.jira import STATUS_TO_JIRA, JiraClient, get_issue
 
         assert JiraClient is not None
         assert callable(get_issue)
@@ -141,14 +141,14 @@ class TestSprintPackage:
 
     def test_sprint_package_exists(self) -> None:
         """sprint/ package should exist and be importable."""
-        from pennyfarthing_scripts import sprint
+        from pf import sprint
 
         # Should be a package, not the old flat module
         assert hasattr(sprint, "__path__")
 
     def test_loader_module_in_sprint(self) -> None:
         """loader.py should provide sprint YAML loading."""
-        from pennyfarthing_scripts.sprint import loader
+        from pf.sprint import loader
 
         assert hasattr(loader, "load_sprint")
         assert hasattr(loader, "find_epic")
@@ -158,27 +158,27 @@ class TestSprintPackage:
 
     def test_status_module_in_sprint(self) -> None:
         """status.py should provide sprint status operations."""
-        from pennyfarthing_scripts.sprint import status
+        from pf.sprint import status
 
         assert hasattr(status, "get_sprint_status")
         assert hasattr(status, "format_status")
 
     def test_work_module_in_sprint(self) -> None:
         """work.py should provide work session management."""
-        from pennyfarthing_scripts.sprint import work
+        from pf.sprint import work
 
         assert hasattr(work, "start_work")
         assert hasattr(work, "check_story")
 
     def test_archive_module_in_sprint(self) -> None:
         """archive.py should provide story archiving."""
-        from pennyfarthing_scripts.sprint import archive
+        from pf.sprint import archive
 
         assert hasattr(archive, "archive_story")
 
     def test_sprint_package_reexports(self) -> None:
         """sprint/__init__.py should re-export commonly used items."""
-        from pennyfarthing_scripts.sprint import (
+        from pf.sprint import (
             find_epic,
             load_sprint,
         )
@@ -188,7 +188,7 @@ class TestSprintPackage:
 
     def test_sprint_backwards_compatibility(self) -> None:
         """Old-style imports should still work."""
-        from pennyfarthing_scripts.sprint import find_epic, load_current_sprint, load_sprint
+        from pf.sprint import find_epic, load_current_sprint, load_sprint
 
         assert callable(load_sprint)
         assert callable(find_epic)
@@ -200,28 +200,28 @@ class TestStoryPackage:
 
     def test_story_package_exists(self) -> None:
         """story/ package should exist and be importable."""
-        from pennyfarthing_scripts import story
+        from pf import story
 
         # Should be a package
         assert hasattr(story, "__path__")
 
     def test_size_module_in_story(self) -> None:
         """size.py should provide story sizing utilities."""
-        from pennyfarthing_scripts.story import size
+        from pf.story import size
 
         assert hasattr(size, "get_sizing_guidelines")
         assert hasattr(size, "format_size_info")
 
     def test_template_module_in_story(self) -> None:
         """template.py should provide story templates."""
-        from pennyfarthing_scripts.story import template
+        from pf.story import template
 
         assert hasattr(template, "get_template")
         assert hasattr(template, "get_all_templates")
 
     def test_create_module_in_story(self) -> None:
         """create.py should provide story creation."""
-        from pennyfarthing_scripts.story import create
+        from pf.story import create
 
         assert hasattr(create, "create_story")
         assert hasattr(create, "generate_story_yaml")
@@ -233,14 +233,14 @@ class TestJiraCLI:
     def test_jira_cli_has_main(self) -> None:
         """jira.py should have a main() entry point."""
         # Import the CLI module (not the package)
-        import pennyfarthing_scripts.jira as jira_pkg
+        import pf.jira as jira_pkg
 
         # The package's __main__.py or main module should have main()
         assert hasattr(jira_pkg, "main") or hasattr(jira_pkg, "cli")
 
     def test_jira_cli_subcommands(self) -> None:
         """jira CLI should support expected subcommands."""
-        from pennyfarthing_scripts.jira import cli
+        from pf.jira import cli
 
         # CLI should define these subcommands
         assert hasattr(cli, "view") or "view" in dir(cli)
@@ -250,11 +250,11 @@ class TestJiraCLI:
         assert hasattr(cli, "bidirectional") or "bidirectional" in dir(cli)
 
     def test_jira_cli_runnable_as_module(self) -> None:
-        """python -m pennyfarthing_scripts.jira should work."""
+        """python -m pf.jira should work."""
         import subprocess
 
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.jira", "--help"],
+            [sys.executable, "-m", "pf.jira", "--help"],
             capture_output=True,
             text=True,
         )
@@ -268,13 +268,13 @@ class TestSprintCLI:
 
     def test_sprint_cli_has_main(self) -> None:
         """sprint.py should have a main() entry point."""
-        import pennyfarthing_scripts.sprint as sprint_pkg
+        import pf.sprint as sprint_pkg
 
         assert hasattr(sprint_pkg, "main") or hasattr(sprint_pkg, "cli")
 
     def test_sprint_cli_subcommands(self) -> None:
         """sprint CLI should support expected subcommands."""
-        from pennyfarthing_scripts.sprint import cli
+        from pf.sprint import cli
 
         # CLI should define these subcommands based on skill.md
         assert hasattr(cli, "status") or "status" in dir(cli)
@@ -283,11 +283,11 @@ class TestSprintCLI:
         assert hasattr(cli, "archive") or "archive" in dir(cli)
 
     def test_sprint_cli_runnable_as_module(self) -> None:
-        """python -m pennyfarthing_scripts.sprint should work."""
+        """python -m pf.sprint should work."""
         import subprocess
 
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "--help"],
+            [sys.executable, "-m", "pf.sprint", "--help"],
             capture_output=True,
             text=True,
         )
@@ -300,13 +300,13 @@ class TestStoryCLI:
 
     def test_story_cli_has_main(self) -> None:
         """story.py should have a main() entry point."""
-        import pennyfarthing_scripts.story as story_pkg
+        import pf.story as story_pkg
 
         assert hasattr(story_pkg, "main") or hasattr(story_pkg, "cli")
 
     def test_story_cli_subcommands(self) -> None:
         """story CLI should support expected subcommands."""
-        from pennyfarthing_scripts.story import cli
+        from pf.story import cli
 
         # CLI should define these subcommands based on skill.md
         assert hasattr(cli, "size") or "size" in dir(cli)
@@ -314,11 +314,11 @@ class TestStoryCLI:
         assert hasattr(cli, "create") or "create" in dir(cli)
 
     def test_story_cli_runnable_as_module(self) -> None:
-        """python -m pennyfarthing_scripts.story should work."""
+        """python -m pf.story should work."""
         import subprocess
 
         result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.story", "--help"],
+            [sys.executable, "-m", "pf.story", "--help"],
             capture_output=True,
             text=True,
         )
@@ -331,7 +331,7 @@ class TestOldModuleCompatibility:
 
     def test_jira_sync_module_works(self) -> None:
         """jira_sync.py should still be importable and functional."""
-        from pennyfarthing_scripts import jira_sync
+        from pf import jira_sync
 
         assert hasattr(jira_sync, "sync_epic")
         assert hasattr(jira_sync, "sync_story")
@@ -339,21 +339,21 @@ class TestOldModuleCompatibility:
 
     def test_jira_bidirectional_sync_module_works(self) -> None:
         """jira_bidirectional_sync.py should still be importable."""
-        from pennyfarthing_scripts import jira_bidirectional_sync
+        from pf import jira_bidirectional_sync
 
         assert hasattr(jira_bidirectional_sync, "generate_sync_plan")
         assert hasattr(jira_bidirectional_sync, "main")
 
     def test_jira_epic_creation_module_works(self) -> None:
         """jira_epic_creation.py should still be importable."""
-        from pennyfarthing_scripts import jira_epic_creation
+        from pf import jira_epic_creation
 
         assert hasattr(jira_epic_creation, "create_epic")
         assert hasattr(jira_epic_creation, "main")
 
     def test_jira_sync_story_module_works(self) -> None:
         """jira_sync_story.py should still be importable."""
-        from pennyfarthing_scripts import jira_sync_story
+        from pf import jira_sync_story
 
         assert hasattr(jira_sync_story, "sync_story")
         assert hasattr(jira_sync_story, "main")

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

@@ -27,7 +27,7 @@ import yaml
 
 # Import will fail until module exists - this is intentional for RED state
 try:
-    from pennyfarthing_scripts.patch_mode import (
+    from pf.patch_mode import (
         PatchStack,
         PatchState,
         create_patch_branch,
@@ -73,7 +73,7 @@ class TestPatchModeModuleExists:
 
     def test_module_importable(self) -> None:
         """patch_mode module should be importable."""
-        assert IMPORT_SUCCESS, "pennyfarthing_scripts.patch_mode module does not exist"
+        assert IMPORT_SUCCESS, "pf.patch_mode module does not exist"
 
     def test_patch_state_class_exists(self) -> None:
         """PatchState class should exist."""
@@ -162,7 +162,7 @@ class TestPatchBranchCreation:
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
         # Mock git operations
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             branch_name = create_patch_branch(
                 description="fix broken script",
@@ -179,7 +179,7 @@ class TestPatchBranchCreation:
         """AC3: Branch name should follow patch/<desc>-<timestamp> format."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             branch_name = create_patch_branch(
                 description="fix broken script",
@@ -192,7 +192,7 @@ class TestPatchBranchCreation:
         """AC3: Branch name should sanitize special characters from description."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             branch_name = create_patch_branch(
                 description="fix: broken/script (urgent!)",
@@ -227,7 +227,7 @@ class TestDevOnlyWorkflow:
         """AC4: Entering patch mode should set agent to dev."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             result = enter_patch_mode(
                 description="fix broken script",
@@ -284,7 +284,7 @@ class TestMergeBack:
         """AC6: merge_patch_branch should merge to feature branch."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             merge_patch_branch(
                 patch_branch="patch/fix-script-1234567890",
@@ -300,7 +300,7 @@ class TestMergeBack:
         """AC6: merge_patch_branch should delete the patch branch after merge."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
             merge_patch_branch(
                 patch_branch="patch/fix-script-1234567890",
@@ -331,11 +331,11 @@ class TestStateRestoration:
         """AC7: restore_workflow_state should return original state."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.get_patch_stack") as mock_stack:
+        with patch("pf.patch_mode.get_patch_stack") as mock_stack:
             state = PatchState(**saved_state)
             mock_stack.return_value.peek.return_value = state
             mock_stack.return_value.pop.return_value = state
-            with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+            with patch("pf.patch_mode.subprocess.run") as mock_run:
                 mock_run.return_value = MagicMock(returncode=0)
                 result = restore_workflow_state()
                 assert result["story_id"] == "MSSCI-12345"
@@ -346,11 +346,11 @@ class TestStateRestoration:
         """AC7: restore should checkout the original feature branch."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.get_patch_stack") as mock_stack:
+        with patch("pf.patch_mode.get_patch_stack") as mock_stack:
             state = PatchState(**saved_state)
             mock_stack.return_value.peek.return_value = state
             mock_stack.return_value.pop.return_value = state
-            with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+            with patch("pf.patch_mode.subprocess.run") as mock_run:
                 mock_run.return_value = MagicMock(returncode=0)
                 restore_workflow_state(repo_path=tmp_path)
                 # Should checkout feature branch
@@ -417,7 +417,7 @@ class TestTirepumpIntegration:
         """AC9: exit_patch_mode should return handoff marker for original agent."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.get_patch_stack") as mock_stack:
+        with patch("pf.patch_mode.get_patch_stack") as mock_stack:
             mock_state = MagicMock()
             mock_state.agent = "dev"
             mock_state.story_id = "MSSCI-12345"
@@ -427,7 +427,7 @@ class TestTirepumpIntegration:
             mock_stack.return_value.peek.return_value = mock_state
             mock_stack.return_value.pop.return_value = mock_state
 
-            with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+            with patch("pf.patch_mode.subprocess.run") as mock_run:
                 mock_run.return_value = MagicMock(returncode=0)
                 result = exit_patch_mode()
 
@@ -441,7 +441,7 @@ class TestTirepumpIntegration:
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
         # Relay mode should continue after patch completes
-        with patch("pennyfarthing_scripts.patch_mode.get_patch_stack") as mock_stack:
+        with patch("pf.patch_mode.get_patch_stack") as mock_stack:
             mock_state = MagicMock()
             mock_state.agent = "dev"
             mock_state.story_id = "MSSCI-12345"
@@ -451,7 +451,7 @@ class TestTirepumpIntegration:
             mock_stack.return_value.peek.return_value = mock_state
             mock_stack.return_value.pop.return_value = mock_state
 
-            with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+            with patch("pf.patch_mode.subprocess.run") as mock_run:
                 mock_run.return_value = MagicMock(returncode=0)
                 result = exit_patch_mode()
                 # Should not disable relay mode
@@ -527,7 +527,7 @@ class TestNestedPatches:
         """AC10: Entering nested patch should preserve parent patch state."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
 
             # Enter first patch
@@ -620,7 +620,7 @@ class TestEnterPatchModeIntegration:
         """enter_patch_mode should create branch and save state atomically."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0, stdout="patch/fix-bug-123")
 
             stack_file = tmp_path / ".session" / "patch-stack.yaml"
@@ -645,7 +645,7 @@ class TestEnterPatchModeIntegration:
         """enter_patch_mode should fail gracefully if git fails."""
         if not IMPORT_SUCCESS:
             pytest.skip("Module not implemented")
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=1, stderr="git error")
 
             with pytest.raises(Exception) as exc_info:
@@ -683,7 +683,7 @@ class TestExitPatchModeIntegration:
         )
         stack.push(state)
 
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=0)
 
             result = exit_patch_mode(
@@ -731,7 +731,7 @@ class TestExitPatchModeIntegration:
             else:  # merge fails
                 return MagicMock(returncode=1, stderr="merge conflict")
 
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run", side_effect=mock_run_side_effect):
+        with patch("pf.patch_mode.subprocess.run", side_effect=mock_run_side_effect):
             with pytest.raises(RuntimeError) as exc_info:
                 exit_patch_mode(
                     patch_branch="patch/fix-bug-123",
@@ -765,7 +765,7 @@ class TestExitPatchModeIntegration:
         )
         stack.push(state)
 
-        with patch("pennyfarthing_scripts.patch_mode.subprocess.run") as mock_run:
+        with patch("pf.patch_mode.subprocess.run") as mock_run:
             mock_run.return_value = MagicMock(returncode=1, stderr="branch does not exist")
 
             with pytest.raises(RuntimeError) as exc_info: