@pennyfarthing/core 11.2.2 → 11.3.2

package/pennyfarthing_scripts/settings/settings.py

@@ -0,0 +1,98 @@
+"""
+Settings logic for reading and writing .pennyfarthing/config.local.yaml.
+
+Provides dot-path traversal for get/set operations with type coercion.
+"""
+
+from typing import Any
+
+import yaml
+
+from pennyfarthing_scripts.common.config import get_project_root, load_pennyfarthing_config
+
+# Top-level keys to show in `pf settings show` (skip layout/panel blobs)
+SHOW_KEYS = ("theme", "workflow", "display", "split", "last_panel")
+
+
+def _coerce_value(value: str) -> Any:
+    """Coerce a string value to bool, int, or leave as str."""
+    lower = value.lower()
+    if lower == "true":
+        return True
+    if lower == "false":
+        return False
+    try:
+        return int(value)
+    except ValueError:
+        return value
+
+
+def _get_by_path(data: dict, key: str) -> Any:
+    """Traverse a dict by dot-separated path.
+
+    Returns the value at the path, or raises KeyError if not found.
+    """
+    parts = key.split(".")
+    current: Any = data
+    for part in parts:
+        if not isinstance(current, dict) or part not in current:
+            raise KeyError(key)
+        current = current[part]
+    return current
+
+
+def _set_by_path(data: dict, key: str, value: Any) -> None:
+    """Set a value in a dict by dot-separated path, creating intermediates."""
+    parts = key.split(".")
+    current = data
+    for part in parts[:-1]:
+        if part not in current or not isinstance(current[part], dict):
+            current[part] = {}
+        current = current[part]
+    current[parts[-1]] = value
+
+
+def get_setting(key: str) -> Any:
+    """Get a setting value by dot-path."""
+    config = load_pennyfarthing_config()
+    return _get_by_path(config, key)
+
+
+def set_setting(key: str, value: str) -> dict:
+    """Set a setting value by dot-path. Returns the updated config."""
+    root = get_project_root()
+    config_path = root / ".pennyfarthing" / "config.local.yaml"
+
+    config = load_pennyfarthing_config(root)
+    coerced = _coerce_value(value)
+    _set_by_path(config, key, coerced)
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(config_path, "w") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+    return config
+
+
+def show_settings() -> str:
+    """Format interesting top-level settings for display."""
+    config = load_pennyfarthing_config()
+    lines: list[str] = []
+
+    for key in SHOW_KEYS:
+        if key not in config:
+            continue
+        val = config[key]
+        if isinstance(val, dict):
+            lines.append(f"{key}:")
+            for k, v in val.items():
+                if isinstance(v, dict):
+                    nested = yaml.dump({k: v}, default_flow_style=False, sort_keys=False)
+                    for line in nested.rstrip().split("\n"):
+                        lines.append(f"  {line}")
+                else:
+                    lines.append(f"  {k}: {v}")
+        else:
+            lines.append(f"{key}: {val}")
+
+    return "\n".join(lines) if lines else "(no settings found)"

package/pennyfarthing_scripts/tests/test_confidence_sm_gate.py

@@ -1,16 +1,18 @@
-"""Tests for SM confidence gate file — Story 90-2.
+"""Tests for confidence gate file — Story 90-2 (generalized).
 
 Epic: 90 (Confidence Circuit Breaker via Gate)
-Story: 90-2 — Implement SM confidence gate file
+Story: 90-2 — Implement confidence gate file
 
-Tests the confidence-sm gate file that checks whether an instruction to the
-SM agent is ambiguous. If ambiguous, <fail> returns clarifying options. If
+Tests the confidence gate file that checks whether an instruction to any
+agent is ambiguous. If ambiguous, <fail> returns clarifying options. If
 unambiguous, <pass> lets the agent proceed.
 
+Originally SM-specific (confidence-sm), generalized to agent-agnostic (confidence).
+
 Acceptance Criteria:
 - [AC1] Gate file exists in pennyfarthing-dist/gates/ following Gate PRD schema
 - [AC2] Gate has <gate>, <purpose>, <pass>, <fail> blocks
-- [AC3] Gate checks whether SM instruction is ambiguous
+- [AC3] Gate checks whether instruction is ambiguous
 - [AC4] <fail> block returns clarifying options when ambiguous
 - [AC5] <pass> block lets the agent proceed when unambiguous
 - [AC6] Gate uses model="haiku"
@@ -30,7 +32,7 @@ from pennyfarthing_scripts.handoff.gate_runner import parse_gate_file
 # Fixtures
 # ---------------------------------------------------------------------------
 
-GATE_NAME = "confidence-sm"
+GATE_NAME = "confidence"
 
 # The gate file lives in pennyfarthing-dist/gates/ relative to the framework root
 # In the dogfooding context, the project root is the orchestrator, so we need
@@ -43,7 +45,7 @@ _GATE_FILE = _FRAMEWORK_ROOT / "pennyfarthing-dist" / "gates" / f"{GATE_NAME}.md
 
 @pytest.fixture
 def gate_path() -> Path:
-    """Return the expected path to the confidence-sm gate file."""
+    """Return the expected path to the confidence gate file."""
     return _GATE_FILE
 
 
@@ -69,7 +71,7 @@ class TestGateFileExists:
     """AC1: Gate file exists at the expected location."""
 
     def test_gate_file_exists(self, gate_path: Path) -> None:
-        """AC1: confidence-sm.md exists in pennyfarthing-dist/gates/."""
+        """AC1: confidence.md exists in pennyfarthing-dist/gates/."""
         assert gate_path.is_file(), f"Gate file not found: {gate_path}"
 
     def test_gate_file_not_empty(self, gate_path: Path) -> None:
@@ -138,11 +140,10 @@ class TestGateSchemaStructure:
 
 
 class TestGateAmbiguityDetection:
-    """AC3: Gate content describes checking for ambiguous SM instructions."""
+    """AC3: Gate content describes checking for ambiguous instructions."""
 
     def test_purpose_mentions_ambiguity(self, gate_content: str) -> None:
         """AC3: Purpose section references ambiguity or unclear instructions."""
-        # Extract purpose content between tags
         import re
 
         purpose_match = re.search(
@@ -155,17 +156,17 @@ class TestGateAmbiguityDetection:
             for term in ["ambig", "unclear", "vague", "confidence", "clarif"]
         ), f"Purpose doesn't reference ambiguity: {purpose}"
 
-    def test_gate_name_is_confidence_sm(self, parsed_gate: dict) -> None:
-        """AC3: Gate name is 'confidence-sm'."""
+    def test_gate_name_is_confidence(self, parsed_gate: dict) -> None:
+        """AC3: Gate name is 'confidence'."""
         assert parsed_gate["name"] == GATE_NAME
 
-    def test_content_references_sm_agent(self, gate_content: str) -> None:
-        """AC3: Gate content references the SM agent or scrum master role."""
+    def test_content_is_agent_agnostic(self, gate_content: str) -> None:
+        """AC3: Gate content is agent-agnostic (not SM-specific)."""
         content_lower = gate_content.lower()
         assert any(
             term in content_lower
-            for term in ["sm agent", "scrum master", "sm ", "story management"]
-        ), "Gate doesn't reference SM agent"
+            for term in ["current agent", "the agent", "any agent"]
+        ), "Gate should be agent-agnostic"
 
 
 # ===========================================================================

package/pennyfarthing_scripts/tests/test_resolve_gate_file_field.py

@@ -6,7 +6,7 @@ Story: 106-3 — Workflow YAML gate.file integration
 Tests the gate.file field support in resolve_gate():
 - Schema extension: gate.file extracted from workflow YAML
 - Backward compatibility: gate.type-only workflows unchanged
-- TDD workflow migration: green phase has file: gates/tests-pass
+- TDD workflow migration: all phases now have gate.file fields
 
 Acceptance Criteria:
 - [AC1] resolve-gate.py reads gate.file field from workflow YAML phases
@@ -15,9 +15,9 @@ Acceptance Criteria:
 - [AC2] Workflows with only gate.type continue to work unchanged
 - [AC2] Existing gate type logic remains functional
 - [AC2] No breaking changes to resolve-gate API
-- [AC3] Green phase in tdd.yaml has file: gates/tests-pass and type: tests_pass
-- [AC3] Other phases remain unchanged (backward compat period)
-- [AC3] File path is relative: gates/tests-pass (not absolute)
+- [AC3] Green phase in tdd.yaml has file: gates/dev-exit and type: dev_exit
+- [AC3] All phases have gate.file fields (full migration complete)
+- [AC3] File paths are relative (not absolute)
 """
 
 from __future__ import annotations
@@ -202,21 +202,19 @@ class TestResolveGateFileOnly:
         )
         assert result["gate_type"] is None
 
-    def test_status_skip_when_no_type_and_file_only(
+    def test_status_ready_when_no_type_and_file_only(
         self, project: Path
     ) -> None:
-        """AC1: gate with file-only and no type → status depends on gate_type logic.
+        """AC1: gate with file-only and no type → status is 'ready'.
 
-        Current resolve_gate checks gate_type for skip logic:
-        - gate_type == 'manual' → skip
-        - gate_type is None → skip
-        So file-only gates (no type) currently get 'skip' status.
-        This is expected during migration — consumers check gate_file separately.
+        File-only gates (no type) are resolvable — the gate runner uses
+        gate_file to locate and execute the gate. Status is 'ready' when
+        an assessment exists.
         """
         result = resolve_gate(
             "106-3", "file-only", "green", project_root=project
         )
-        assert result["status"] == "skip"
+        assert result["status"] == "ready"
 
 
 # ===========================================================================
@@ -315,11 +313,10 @@ class TestResolveGateBackwardCompat:
 
 
 class TestTddWorkflowMigration:
-    """AC3: TDD workflow green phase has file: gates/tests-pass.
+    """AC3: TDD workflow phases have gate.file fields after full migration.
 
     These tests read the ACTUAL tdd.yaml from the project to verify
-    the migration has been applied. They will FAIL until the Dev
-    updates tdd.yaml.
+    the migration has been applied.
     """
 
     @pytest.fixture
@@ -342,54 +339,55 @@ class TestTddWorkflowMigration:
         raise ValueError(f"Phase '{name}' not found")
 
     def test_green_phase_has_gate_file(self, tdd_yaml: dict) -> None:
-        """AC3: Green phase should have gate.file = 'gates/tests-pass'."""
+        """AC3: Green phase should have gate.file = 'gates/dev-exit'."""
         green = self._get_phase(tdd_yaml, "green")
         gate = green.get("gate", {})
-        assert gate.get("file") == "gates/tests-pass", (
-            f"Expected gate.file='gates/tests-pass', got gate={gate}"
+        assert gate.get("file") == "gates/dev-exit", (
+            f"Expected gate.file='gates/dev-exit', got gate={gate}"
         )
 
-    def test_green_phase_keeps_legacy_type(self, tdd_yaml: dict) -> None:
-        """AC3: Green phase should keep gate.type = 'tests_pass' for backward compat."""
+    def test_green_phase_has_dev_exit_type(self, tdd_yaml: dict) -> None:
+        """AC3: Green phase should have gate.type = 'dev_exit'."""
         green = self._get_phase(tdd_yaml, "green")
         gate = green.get("gate", {})
-        assert gate.get("type") == "tests_pass", (
-            f"Expected gate.type='tests_pass', got gate={gate}"
+        assert gate.get("type") == "dev_exit", (
+            f"Expected gate.type='dev_exit', got gate={gate}"
         )
 
     def test_green_phase_file_is_relative(self, tdd_yaml: dict) -> None:
-        """AC3: File path should be relative (gates/tests-pass), not absolute."""
+        """AC3: File path should be relative (gates/dev-exit), not absolute."""
         green = self._get_phase(tdd_yaml, "green")
         gate = green.get("gate", {})
         file_path = gate.get("file", "")
         assert not file_path.startswith("/"), (
             f"gate.file should be relative, got: {file_path}"
         )
-        assert file_path == "gates/tests-pass", (
-            f"Expected 'gates/tests-pass', got: {file_path}"
+        assert file_path == "gates/dev-exit", (
+            f"Expected 'gates/dev-exit', got: {file_path}"
         )
 
-    def test_red_phase_unchanged(self, tdd_yaml: dict) -> None:
-        """AC3: Red phase should NOT have gate.file (backward compat period)."""
+    def test_red_phase_has_gate_file(self, tdd_yaml: dict) -> None:
+        """AC3: Red phase should have gate.file = 'gates/tests-fail'."""
         red = self._get_phase(tdd_yaml, "red")
         gate = red.get("gate", {})
-        assert "file" not in gate, (
-            f"Red phase should not have gate.file yet, got gate={gate}"
+        assert gate.get("file") == "gates/tests-fail", (
+            f"Expected gate.file='gates/tests-fail', got gate={gate}"
         )
 
-    def test_review_phase_unchanged(self, tdd_yaml: dict) -> None:
-        """AC3: Review phase should NOT have gate.file (backward compat period)."""
+    def test_review_phase_has_gate_file(self, tdd_yaml: dict) -> None:
+        """AC3: Review phase should have gate.file = 'gates/approval'."""
         review = self._get_phase(tdd_yaml, "review")
         gate = review.get("gate", {})
-        assert "file" not in gate, (
-            f"Review phase should not have gate.file yet, got gate={gate}"
+        assert gate.get("file") == "gates/approval", (
+            f"Expected gate.file='gates/approval', got gate={gate}"
         )
 
-    def test_setup_phase_unchanged(self, tdd_yaml: dict) -> None:
-        """AC3: Setup phase should remain gateless."""
+    def test_setup_phase_has_gate(self, tdd_yaml: dict) -> None:
+        """AC3: Setup phase should have gate.file = 'gates/sm-setup-exit'."""
         setup = self._get_phase(tdd_yaml, "setup")
-        assert "gate" not in setup, (
-            f"Setup phase should not have a gate, got: {setup}"
+        gate = setup.get("gate", {})
+        assert gate.get("file") == "gates/sm-setup-exit", (
+            f"Expected gate.file='gates/sm-setup-exit', got gate={gate}"
         )
 
     def test_finish_phase_unchanged(self, tdd_yaml: dict) -> None:
@@ -435,30 +433,30 @@ class TestResolveGateWithRealTddYaml:
     def test_green_phase_returns_gate_file(
         self, real_project: Path
     ) -> None:
-        """AC3: resolve_gate for tdd/green should return gate_file='gates/tests-pass'."""
+        """AC3: resolve_gate for tdd/green should return gate_file='gates/dev-exit'."""
         result = resolve_gate(
             "106-3", "tdd", "green", project_root=real_project
         )
-        assert result["gate_file"] == "gates/tests-pass", (
-            f"Expected gate_file='gates/tests-pass', got: {result}"
+        assert result["gate_file"] == "gates/dev-exit", (
+            f"Expected gate_file='gates/dev-exit', got: {result}"
         )
 
-    def test_green_phase_still_returns_gate_type(
+    def test_green_phase_returns_dev_exit_type(
         self, real_project: Path
     ) -> None:
-        """AC3: resolve_gate for tdd/green should still return gate_type='tests_pass'."""
+        """AC3: resolve_gate for tdd/green should return gate_type='dev_exit'."""
         result = resolve_gate(
             "106-3", "tdd", "green", project_root=real_project
         )
-        assert result["gate_type"] == "tests_pass", (
-            f"Expected gate_type='tests_pass', got: {result}"
+        assert result["gate_type"] == "dev_exit", (
+            f"Expected gate_type='dev_exit', got: {result}"
         )
 
-    def test_red_phase_gate_file_is_none(
+    def test_red_phase_gate_file_is_tests_fail(
         self, real_project: Path
     ) -> None:
-        """AC3: resolve_gate for tdd/red should have gate_file=None (not migrated yet)."""
+        """AC3: resolve_gate for tdd/red should have gate_file='gates/tests-fail'."""
         result = resolve_gate(
             "106-3", "tdd", "red", project_root=real_project
         )
-        assert result["gate_file"] is None
+        assert result["gate_file"] == "gates/tests-fail"

package/pennyfarthing_scripts/tests/test_workflow_list_team.py

@@ -17,11 +17,7 @@ workflow list team indicator are implemented.
 
 from __future__ import annotations
 
-from pathlib import Path
-from unittest.mock import patch
-
 import pytest
-import yaml
 from click.testing import CliRunner
 
 from pennyfarthing_scripts.cli import cli