fix: reject unknown ralph names instead of silently treating them as inline prompts

Previously `ralph run nonexistent` would pass the literal string "nonexistent"
to the agent as an inline prompt. Now the positional argument must be a named
ralph from .ralphify/ralphs/ or omitted entirely (falls back to ralph.toml).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

src/ralphify/cli.py

@@ -224,7 +224,7 @@ def status() -> None:
 
 @app.command()
 def run(
-    prompt: str | None = typer.Argument(None, help="Ralph name, file path, or inline prompt text."),
+    prompt: str | None = typer.Argument(None, help="Named ralph from .ralphify/ralphs/."),
     n: int | None = typer.Option(None, "-n", help="Max number of iterations. Infinite if not set."),
     stop_on_error: bool = typer.Option(False, "--stop-on-error", "-s", help="Stop if the agent exits with non-zero."),
     delay: float = typer.Option(0, "--delay", "-d", help="Seconds to wait between iterations."),
@@ -244,15 +244,15 @@ def run(
     args = agent.get("args", [])
 
     try:
-        ralph_file_path, resolved_ralph_name, prompt_text = resolve_ralph_source(
+        ralph_file_path, resolved_ralph_name = resolve_ralph_source(
             prompt=prompt,
             toml_ralph=agent.get("ralph", "RALPH.md"),
         )
     except ValueError as e:
         rprint(f"[red]{e}[/red]")
         raise typer.Exit(1)
 
-    if not prompt_text and not Path(ralph_file_path).exists():
+    if not Path(ralph_file_path).exists():
         rprint(f"[red]Prompt file '{ralph_file_path}' not found.[/red]")
         raise typer.Exit(1)
 
@@ -263,7 +263,6 @@ def run(
         command=command,
         args=args,
         ralph_file=ralph_file_path,
-        prompt_text=prompt_text,
         ralph_name=resolved_ralph_name,
         max_iterations=n,
         delay=delay,

src/ralphify/ralphs.py

@@ -91,43 +91,28 @@ def resolve_ralph_source(
     *,
     prompt: str | None,
     toml_ralph: str,
-) -> tuple[str, str | None, str | None]:
-    """Resolve the positional prompt argument into a file path, ralph name, or inline text.
+) -> tuple[str, str | None]:
+    """Resolve the positional argument into a ralph file path and optional name.
 
-    Returns ``(ralph_file_path, ralph_name, prompt_text)`` — exactly one of
-    ``ralph_name`` or ``prompt_text`` will be set, or both ``None`` when
-    falling back to the toml/root prompt file.
+    Returns ``(ralph_file_path, ralph_name)``.
 
-    Resolution order for the positional *prompt* argument:
+    Resolution:
 
     1. ``None`` → fall back to ``ralph.toml`` ``agent.ralph``
-    2. Matches a named ralph in ``.ralphify/ralphs/`` → use that ralph
-    3. Existing file path → use as prompt file
-    4. Otherwise → treat as inline prompt text
+    2. Otherwise → must match a named ralph in ``.ralphify/ralphs/``
 
-    Raises ``ValueError`` if a named ralph lookup fails (only when using
-    the toml fallback with a name-like value).
+    Raises ``ValueError`` if a named ralph lookup fails.
     """
     if prompt is None:
         # Fall back to ralph.toml agent.ralph — could be a name or a path
         if is_ralph_name(toml_ralph):
             try:
                 found = resolve_ralph_name(toml_ralph)
-                return str(found.path / RALPH_MARKER), found.name, None
+                return str(found.path / RALPH_MARKER), found.name
             except ValueError:
-                return toml_ralph, None, None
-        return toml_ralph, None, None
-
-    # Try as a named ralph first
-    try:
-        found = resolve_ralph_name(prompt)
-        return str(found.path / RALPH_MARKER), found.name, None
-    except ValueError:
-        pass
-
-    # Try as a file path
-    if Path(prompt).exists():
-        return prompt, None, None
-
-    # Treat as inline prompt text
-    return toml_ralph, None, prompt
+                return toml_ralph, None
+        return toml_ralph, None
+
+    # Must be a named ralph
+    found = resolve_ralph_name(prompt)
+    return str(found.path / RALPH_MARKER), found.name

tests/test_cli.py

@@ -269,46 +269,15 @@ def test_no_delay_with_single_iteration(self, mock_run, mock_sleep, tmp_path, mo
         mock_sleep.assert_not_called()
 
 
-class TestRunAdHocPrompt:
-    @patch("ralphify._agent.subprocess.run", side_effect=_ok)
-    def test_uses_provided_prompt_text(self, mock_run, tmp_path, monkeypatch):
+class TestRunRejectsInlinePrompt:
+    def test_unknown_name_errors(self, tmp_path, monkeypatch):
+        """A value that doesn't match a named ralph produces an error."""
         monkeypatch.chdir(tmp_path)
         (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
 
         result = runner.invoke(app, ["run", "do something", "-n", "1"])
-        assert result.exit_code == 0
-        assert mock_run.call_args.kwargs["input"] == "do something"
-
-    @patch("ralphify._agent.subprocess.run", side_effect=_ok)
-    def test_skips_ralph_file_check(self, mock_run, tmp_path, monkeypatch):
-        """Works without RALPH.md when inline text is provided."""
-        monkeypatch.chdir(tmp_path)
-        (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
-        # No RALPH.md created
-
-        result = runner.invoke(app, ["run", "ad-hoc prompt", "-n", "1"])
-        assert result.exit_code == 0
-        assert mock_run.call_count == 1
-
-    @patch("ralphify._agent.subprocess.run", side_effect=_ok)
-    def test_file_path_used_as_prompt(self, mock_run, tmp_path, monkeypatch):
-        """An existing file path is used as the prompt file."""
-        monkeypatch.chdir(tmp_path)
-        (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
-        (tmp_path / "alt.md").write_text("alternate prompt")
-
-        result = runner.invoke(app, ["run", "alt.md", "-n", "1"])
-        assert result.exit_code == 0
-        assert mock_run.call_args.kwargs["input"] == "alternate prompt"
-
-    def test_nonexistent_file_treated_as_inline(self, tmp_path, monkeypatch):
-        """A non-existent path-like string is treated as inline text."""
-        monkeypatch.chdir(tmp_path)
-        (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
-
-        # "nonexistent.md" doesn't exist as a file, and doesn't match a ralph name,
-        # so it's treated as inline text
-        result = runner.invoke(app, ["run", "nonexistent.md", "-n", "1"])
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()
 
 
 class TestRunLogging:
@@ -909,15 +878,14 @@ def test_run_with_ralph_name(self, mock_run, tmp_path, monkeypatch):
         assert result.exit_code == 0
         assert mock_run.call_args.kwargs["input"] == "Fix the docs."
 
-    @patch("ralphify._agent.subprocess.run", side_effect=_ok)
-    def test_nonexistent_name_treated_as_inline_text(self, mock_run, tmp_path, monkeypatch):
-        """A value that doesn't match a ralph or file is treated as inline text."""
+    def test_nonexistent_name_errors(self, tmp_path, monkeypatch):
+        """A value that doesn't match a named ralph produces an error."""
         monkeypatch.chdir(tmp_path)
         (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
 
         result = runner.invoke(app, ["run", "nonexistent", "-n", "1"])
-        assert result.exit_code == 0
-        assert mock_run.call_args.kwargs["input"] == "nonexistent"
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()
 
     @patch("ralphify._agent.subprocess.run", side_effect=_ok)
     def test_run_without_name_falls_back_to_toml(self, mock_run, tmp_path, monkeypatch):
@@ -941,11 +909,11 @@ def test_toml_ralph_as_name(self, mock_run, tmp_path, monkeypatch):
         assert result.exit_code == 0
         assert mock_run.call_args.kwargs["input"] == "Fix the docs."
 
-    @patch("ralphify._agent.subprocess.run", side_effect=_ok)
-    def test_inline_prompt_used_when_not_ralph_or_file(self, mock_run, tmp_path, monkeypatch):
+    def test_inline_text_rejected(self, tmp_path, monkeypatch):
+        """Inline text that isn't a ralph name produces an error."""
         monkeypatch.chdir(tmp_path)
         (tmp_path / CONFIG_FILENAME).write_text(RALPH_TOML_TEMPLATE)
 
         result = runner.invoke(app, ["run", "inline text", "-n", "1"])
-        assert result.exit_code == 0
-        assert mock_run.call_args.kwargs["input"] == "inline text"
+        assert result.exit_code == 1
+        assert "not found" in result.output.lower()