@pennyfarthing/core 9.2.0 → 9.3.0

package/pennyfarthing_scripts/tests/test_workflow_check.py

@@ -1,341 +0,0 @@
-"""Tests for pf workflow check command.
-
-Story: MSSCI-12657 - Implement pf workflow check command
-Epic: epic-67 (Pennyfarthing Python CLI)
-
-Acceptance Criteria:
-- [AC1] pf workflow check returns workflow state
-- [AC2] --json flag outputs JSON format
-- [AC3] Exit code 0 for all states (including empty)
-
-These tests verify the `pf workflow check` CLI command behavior.
-Tests should fail until the implementation is complete.
-"""
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-from typing import Any
-from unittest.mock import patch
-
-import pytest
-
-from click.testing import CliRunner
-
-from pennyfarthing_scripts.cli import cli
-from pennyfarthing_scripts.workflow import get_workflow_state
-
-# Mock path: since cli.py does `from pennyfarthing_scripts.workflow import get_workflow_state`
-# inside the command function, we mock at the source module
-MOCK_PATH = "pennyfarthing_scripts.workflow.get_workflow_state"
-
-
-class TestWorkflowCheckCLI:
-    """Tests for the CLI entry point (AC1, AC2, AC3)."""
-
-    @pytest.fixture
-    def runner(self) -> CliRunner:
-        """Create a CLI test runner."""
-        return CliRunner()
-
-    def test_workflow_check_command_exists(self, runner: CliRunner) -> None:
-        """AC1: workflow check command should exist and be invokable."""
-        result = runner.invoke(cli, ["workflow", "check", "--help"])
-        assert result.exit_code == 0
-        assert "workflow state" in result.output.lower()
-
-    def test_workflow_check_returns_state_field(self, runner: CliRunner) -> None:
-        """AC1: workflow check should return state in output."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "IN_PROGRESS_STATE"}
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-            assert "State:" in result.output or "state" in result.output.lower()
-
-    def test_workflow_check_shows_story_id_when_present(
-        self, runner: CliRunner
-    ) -> None:
-        """AC1: workflow check should show story_id when in progress."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "red",
-            }
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-            assert "MSSCI-12657" in result.output
-
-    def test_workflow_check_shows_workflow_type(self, runner: CliRunner) -> None:
-        """AC1: workflow check should show workflow type when in progress."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "red",
-            }
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-            assert "tdd" in result.output.lower()
-
-    def test_workflow_check_shows_phase(self, runner: CliRunner) -> None:
-        """AC1: workflow check should show phase when in progress."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "red",
-            }
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-            assert "red" in result.output.lower()
-
-
-class TestWorkflowCheckJSONOutput:
-    """Tests for JSON output format (AC2)."""
-
-    @pytest.fixture
-    def runner(self) -> CliRunner:
-        """Create a CLI test runner."""
-        return CliRunner()
-
-    def test_json_flag_produces_valid_json(self, runner: CliRunner) -> None:
-        """AC2: --json flag should output valid JSON."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "EMPTY_BACKLOG_STATE"}
-            result = runner.invoke(cli, ["workflow", "check", "--json"])
-            assert result.exit_code == 0
-            # Should be valid JSON
-            parsed = json.loads(result.output)
-            assert isinstance(parsed, dict)
-
-    def test_json_output_contains_state_field(self, runner: CliRunner) -> None:
-        """AC2: JSON output should contain state field."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "NEW_WORK_STATE"}
-            result = runner.invoke(cli, ["workflow", "check", "--json"])
-            parsed = json.loads(result.output)
-            assert "state" in parsed
-            assert parsed["state"] == "NEW_WORK_STATE"
-
-    def test_json_output_contains_all_fields_when_in_progress(
-        self, runner: CliRunner
-    ) -> None:
-        """AC2: JSON output should contain all fields for in-progress state."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "implement",
-            }
-            result = runner.invoke(cli, ["workflow", "check", "--json"])
-            parsed = json.loads(result.output)
-            assert parsed["state"] == "IN_PROGRESS_STATE"
-            assert parsed["story_id"] == "MSSCI-12657"
-            assert parsed["workflow"] == "tdd"
-            assert parsed["phase"] == "implement"
-
-    def test_json_output_is_properly_formatted(self, runner: CliRunner) -> None:
-        """AC2: JSON output should be formatted with indentation."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "TEST-123",
-            }
-            result = runner.invoke(cli, ["workflow", "check", "--json"])
-            # Should have newlines (indented JSON, not compact)
-            assert "\n" in result.output
-
-
-class TestWorkflowCheckExitCodes:
-    """Tests for exit codes (AC3)."""
-
-    @pytest.fixture
-    def runner(self) -> CliRunner:
-        """Create a CLI test runner."""
-        return CliRunner()
-
-    def test_exit_code_zero_for_empty_backlog(self, runner: CliRunner) -> None:
-        """AC3: Exit code 0 for EMPTY_BACKLOG_STATE."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "EMPTY_BACKLOG_STATE"}
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-
-    def test_exit_code_zero_for_new_work(self, runner: CliRunner) -> None:
-        """AC3: Exit code 0 for NEW_WORK_STATE."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "NEW_WORK_STATE"}
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-
-    def test_exit_code_zero_for_in_progress(self, runner: CliRunner) -> None:
-        """AC3: Exit code 0 for IN_PROGRESS_STATE."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "IN_PROGRESS_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "red",
-            }
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-
-    def test_exit_code_zero_for_finish_state(self, runner: CliRunner) -> None:
-        """AC3: Exit code 0 for FINISH_STATE."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {
-                "state": "FINISH_STATE",
-                "story_id": "MSSCI-12657",
-                "workflow": "tdd",
-                "phase": "approved",
-            }
-            result = runner.invoke(cli, ["workflow", "check"])
-            assert result.exit_code == 0
-
-    def test_exit_code_zero_for_json_mode(self, runner: CliRunner) -> None:
-        """AC3: Exit code 0 with --json flag."""
-        with patch(MOCK_PATH) as mock_state:
-            mock_state.return_value = {"state": "EMPTY_BACKLOG_STATE"}
-            result = runner.invoke(cli, ["workflow", "check", "--json"])
-            assert result.exit_code == 0
-
-
-class TestGetWorkflowState:
-    """Tests for the underlying get_workflow_state function."""
-
-    def test_returns_dict(self) -> None:
-        """get_workflow_state should return a dictionary."""
-        result = get_workflow_state()
-        assert isinstance(result, dict)
-
-    def test_always_has_state_field(self) -> None:
-        """get_workflow_state should always return a state field."""
-        result = get_workflow_state()
-        assert "state" in result
-
-    def test_state_is_valid_value(self) -> None:
-        """get_workflow_state should return a valid state value."""
-        result = get_workflow_state()
-        valid_states = {
-            "EMPTY_BACKLOG_STATE",
-            "NEW_WORK_STATE",
-            "IN_PROGRESS_STATE",
-            "FINISH_STATE",
-        }
-        assert result["state"] in valid_states
-
-    def test_empty_backlog_when_no_session_dir(self, tmp_path: Path) -> None:
-        """get_workflow_state should return EMPTY_BACKLOG_STATE when no .session dir."""
-        import os
-
-        original_dir = os.getcwd()
-        try:
-            os.chdir(tmp_path)
-            result = get_workflow_state()
-            # Without .session directory, should indicate empty or new work
-            assert result["state"] in {"EMPTY_BACKLOG_STATE", "NEW_WORK_STATE"}
-        finally:
-            os.chdir(original_dir)
-
-    def test_new_work_when_empty_session_dir(self, tmp_path: Path) -> None:
-        """get_workflow_state should return NEW_WORK_STATE when .session is empty."""
-        import os
-
-        session_dir = tmp_path / ".session"
-        session_dir.mkdir()
-
-        original_dir = os.getcwd()
-        try:
-            os.chdir(tmp_path)
-            result = get_workflow_state()
-            assert result["state"] == "NEW_WORK_STATE"
-        finally:
-            os.chdir(original_dir)
-
-    def test_in_progress_with_session_file(self, tmp_path: Path) -> None:
-        """get_workflow_state should return IN_PROGRESS_STATE with active session."""
-        import os
-
-        session_dir = tmp_path / ".session"
-        session_dir.mkdir()
-
-        session_file = session_dir / "MSSCI-12657-session.md"
-        session_file.write_text(
-            """# Story Session: MSSCI-12657
-
-## Story Details
-- **Jira:** MSSCI-12657
-- **Workflow:** tdd
-- **Phase:** red
-"""
-        )
-
-        original_dir = os.getcwd()
-        try:
-            os.chdir(tmp_path)
-            result = get_workflow_state()
-            assert result["state"] == "IN_PROGRESS_STATE"
-            assert result.get("story_id") == "MSSCI-12657"
-            assert result.get("workflow") == "tdd"
-            assert result.get("phase") == "red"
-        finally:
-            os.chdir(original_dir)
-
-
-class TestSubprocessExecution:
-    """Tests verifying the CLI works as a subprocess (integration)."""
-
-    def test_module_runnable(self) -> None:
-        """CLI should be runnable as python -m pennyfarthing_scripts.cli."""
-        result = subprocess.run(
-            [sys.executable, "-m", "pennyfarthing_scripts.cli", "workflow", "check"],
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        # Should not crash - exit 0 for any valid state
-        assert result.returncode == 0
-
-    def test_module_with_json_flag(self) -> None:
-        """CLI should accept --json flag when run as subprocess."""
-        result = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pennyfarthing_scripts.cli",
-                "workflow",
-                "check",
-                "--json",
-            ],
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        assert result.returncode == 0
-        # Output should be valid JSON
-        parsed = json.loads(result.stdout)
-        assert "state" in parsed
-
-    def test_help_flag(self) -> None:
-        """CLI should show help with --help flag."""
-        result = subprocess.run(
-            [
-                sys.executable,
-                "-m",
-                "pennyfarthing_scripts.cli",
-                "workflow",
-                "check",
-                "--help",
-            ],
-            capture_output=True,
-            text=True,
-            timeout=30,
-        )
-        assert result.returncode == 0
-        assert "workflow state" in result.stdout.lower()

package/pennyfarthing_scripts/welcome_hook.py

@@ -1,157 +0,0 @@
-#!/usr/bin/env python3
-"""
-Welcome Hook (Python)
-
-Display a friendly welcome message on session start.
-
-For CLI: Displays ASCII art of a penny-farthing bicycle
-For Cyclist: Sends WebSocket message to display logo and welcome
-
-Called by Claude Code SessionStart hook.
-
-Story: MSSCI-12409 - Hook consistency and WheelHub consolidation
-"""
-
-import json
-import os
-import sys
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from hooks import (
-    find_project_root,
-    send_to_cyclist,
-    load_settings,
-    is_cyclist_running,
-)
-
-
-# Once-per-session guard
-_welcome_shown_file: Path | None = None
-
-
-def get_welcome_lock_path(project_root: Path) -> Path:
-    """Get path to welcome shown lock file."""
-    session_id = os.environ.get("CLAUDE_SESSION_ID", str(os.getpid()))
-    session_dir = project_root / ".session"
-    session_dir.mkdir(parents=True, exist_ok=True)
-    return session_dir / f".welcome-shown-{session_id}"
-
-
-def was_welcome_shown(project_root: Path) -> bool:
-    """Check if welcome was already shown for this session."""
-    lock_path = get_welcome_lock_path(project_root)
-    return lock_path.exists()
-
-
-def mark_welcome_shown(project_root: Path) -> None:
-    """Mark welcome as shown for this session."""
-    lock_path = get_welcome_lock_path(project_root)
-    lock_path.touch()
-
-
-def get_project_name(project_root: Path) -> str:
-    """Get project name from package.json or directory name."""
-    package_json = project_root / "package.json"
-    if package_json.exists():
-        try:
-            with open(package_json) as f:
-                data = json.load(f)
-                name = data.get("name")
-                if name:
-                    return name
-        except (json.JSONDecodeError, OSError):
-            pass
-
-    return project_root.name
-
-
-def get_theme(project_root: Path) -> str | None:
-    """Get current theme from settings."""
-    settings = load_settings(project_root)
-    return settings.theme
-
-
-def display_cli_welcome(project_name: str, theme: str | None) -> None:
-    """Display ASCII art welcome for CLI mode."""
-    print("""
-       ___
-      /   \\
-     |     |     Welcome to
-     |     |    ╔═══════════════════════════════════╗
-      \\___/     ║   ╔═╗╔═╗╔╗╔╔╗╔╦═╗╔═╗╔═╗╔═╗╦╔═╗   ║
-        ║       ║   ╠═╝║╣ ║║║║║║ ╠╣ ╠═╣╠╦╝ ║ ╠═╣   ║
-        ║       ║   ╩  ╚═╝╝╚╝╝╚╝╩  ╩ ╩╩╚═ ╩ ╩ ╩   ║
-      ╔═╩═╗     ╚═══════════════════════════════════╝
-     /     \\
-    │   O   │   Agent-powered development with style
-     \\     /
-      ╚═══╝
-""")
-
-    if project_name:
-        print(f"    Project: {project_name}")
-    if theme:
-        print(f"    Theme:   {theme}")
-    print()
-
-
-def send_cyclist_welcome(project_root: Path, project_name: str, theme: str | None) -> None:
-    """Send welcome message to Cyclist via WebSocket API."""
-    try:
-        send_to_cyclist(
-            endpoint="/api/welcome",
-            data={
-                "project": project_name or "",
-                "theme": theme or "",
-            },
-            project_root=project_root,
-            timeout=5,
-        )
-    except Exception:
-        # Ignore errors - don't block hook
-        pass
-
-
-def main() -> None:
-    """Main entry point for SessionStart welcome hook."""
-    try:
-        # Read and discard stdin (required by hook protocol)
-        sys.stdin.read()
-
-        # Find project root
-        project_root = find_project_root()
-        if not project_root:
-            sys.exit(0)
-
-        # Check if welcome was already shown for this session
-        if was_welcome_shown(project_root):
-            sys.exit(0)
-
-        # Mark welcome as shown
-        mark_welcome_shown(project_root)
-
-        # Get project info
-        project_name = get_project_name(project_root)
-        theme = get_theme(project_root)
-
-        # Check if running in Cyclist
-        if is_cyclist_running(project_root):
-            # Send welcome via WebSocket API
-            send_cyclist_welcome(project_root, project_name, theme)
-        else:
-            # CLI mode - display ASCII art
-            display_cli_welcome(project_name, theme)
-
-        sys.exit(0)
-
-    except Exception as e:
-        # On error, exit silently
-        print(f"[welcome-hook] Error: {e}", file=sys.stderr)
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()