@pennyfarthing/core 11.2.2 → 11.3.1

package/pennyfarthing_scripts/settings/cli.py

@@ -0,0 +1,55 @@
+"""
+Settings CLI group — view and manage .pennyfarthing/config.local.yaml.
+
+Usage:
+    pf settings show          # Pretty-print interesting settings
+    pf settings get <key>     # Get value by dot-path
+    pf settings set <key> <value>  # Set value by dot-path
+"""
+
+import click
+
+
+@click.group()
+def settings():
+    """View and manage .pennyfarthing/config.local.yaml settings."""
+    pass
+
+
+@settings.command()
+def show():
+    """Pretty-print all interesting settings."""
+    from pennyfarthing_scripts.settings.settings import show_settings
+
+    click.echo(show_settings())
+
+
+@settings.command()
+@click.argument("key")
+def get(key: str):
+    """Get a setting value by dot-path (e.g. workflow.relay_mode)."""
+    from pennyfarthing_scripts.settings.settings import get_setting
+
+    try:
+        value = get_setting(key)
+    except KeyError:
+        click.echo(f"Key not found: {key}", err=True)
+        raise SystemExit(1) from None
+
+    if isinstance(value, dict):
+        import yaml
+
+        click.echo(yaml.dump(value, default_flow_style=False, sort_keys=False).rstrip())
+    else:
+        click.echo(value)
+
+
+@settings.command()
+@click.argument("key")
+@click.argument("value")
+def set(key: str, value: str):
+    """Set a setting value by dot-path (e.g. workflow.bell_mode true)."""
+    from pennyfarthing_scripts.settings.settings import set_setting
+
+    set_setting(key, value)
+    click.echo(f"{key} = {value}")

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"
 
 
 # ===========================================================================