ralph-any 0.1.1__tar.gz → 0.2.0__tar.gz

{ralph_any-0.1.1 → ralph_any-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ralph-any
-Version: 0.1.1
+Version: 0.2.0
 Summary: Ralph Wiggum Loop — iterative AI dev loop via ACP (supports Claude, Gemini, and more)
 License-Expression: MIT
 License-File: LICENSE

{ralph_any-0.1.1 → ralph_any-0.2.0}/README.md

@@ -23,21 +23,65 @@ uv tool install ralph-any
 ralph "Refactor utils.py to use dataclasses"
 
 # Gemini CLI
-ralph "Fix the failing tests" --command gemini --command-args --experimental-acp
+ralph "Fix the failing tests" --command gemini --command-args="--experimental-acp"
 
 # Read task from a file
 ralph task.md -m 20
+
+# Auto-detect: just place a ralph.md in your project and run
+ralph
+```
+
+## Config File (`ralph.yml`)
+
+Place a `ralph.yml` (or `ralph.yaml`) in your project root to avoid repeating CLI args:
+
+```yaml
+# ralph.yml
+command: gemini
+command_args: --experimental-acp
+max_iterations: 20
+timeout: 3600
+promise: Done!
+```
+
+Then just run:
+
+```bash
+ralph "your task"
+
+# CLI args override the config file
+ralph "your task" -m 5
+```
+
+**Priority**: CLI args > `ralph.yml` > defaults
+
+## Auto-Detect Prompt
+
+If no prompt argument is given, Ralph looks for these files in the working directory (in order):
+
+1. `ralph.md`
+2. `TASK.md`
+3. `ralph.txt`
+4. `TASK.txt`
+
+```bash
+# Create a prompt file in your project
+echo "Refactor all utils to use dataclasses" > ralph.md
+
+# Run with zero arguments
+ralph
 ```
 
 ## CLI Usage
 
 ```
-ralph <prompt> [options]
+ralph [prompt] [options]
 ```
 
 | Option | Short | Default | Description |
 |--------|-------|---------|-------------|
-| `prompt` | | *(required)* | Task description, or path to `.md`/`.txt` file |
+| `prompt` | | *(auto-detect)* | Task description, path to `.md`/`.txt` file, or auto-detected |
 | `--max-iterations` | `-m` | `10` | Maximum loop iterations |
 | `--timeout` | `-t` | `1800` | Maximum runtime in seconds (30 min) |
 | `--promise` | | `任務完成！🥇` | Completion phrase the AI must output |
@@ -134,13 +178,14 @@ Environment variables are automatically inherited by the child process — no ex
 
 ## Architecture
 
-6 core files, ported from [copilot-ralph](https://github.com/yazelin/copilot-ralph) (19+ TS files):
+7 core files, ported from [copilot-ralph](https://github.com/yazelin/copilot-ralph) (19+ TS files):
 
 ```
 src/ralph/
 ├── __init__.py    # Version + exports
 ├── __main__.py    # python -m ralph entry
-├── cli.py         # argparse CLI (8 options)
+├── cli.py         # argparse CLI + auto-detect
+├── config.py      # ralph.yml loader
 ├── engine.py      # Ralph Loop engine (AcpClient)
 ├── prompt.py      # System prompt template
 └── detect.py      # Promise detection (~5 lines)

{ralph_any-0.1.1 → ralph_any-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ralph-any"
-version = "0.1.1"
+version = "0.2.0"
 description = "Ralph Wiggum Loop — iterative AI dev loop via ACP (supports Claude, Gemini, and more)"
 requires-python = ">=3.10"
 license = "MIT"

{ralph_any-0.1.1 → ralph_any-0.2.0}/src/ralph/__init__.py

@@ -1,12 +1,14 @@
 """Ralph Any — iterative AI dev loop via ACP."""
 
-__version__ = "0.1.1"
+__version__ = "0.2.0"
 
+from ralph.config import load_config_file
 from ralph.detect import detect_promise
 from ralph.engine import LoopConfig, LoopResult, RalphEngine
 
 __all__ = [
     "__version__",
+    "load_config_file",
     "detect_promise",
     "LoopConfig",
     "LoopResult",

{ralph_any-0.1.1 → ralph_any-0.2.0}/src/ralph/cli.py

@@ -7,7 +7,9 @@ import asyncio
 import shlex
 import sys
 from pathlib import Path
+from typing import Any
 
+from ralph.config import load_config_file
 from ralph.engine import LoopConfig, RalphEngine
 
 EXIT_SUCCESS = 0
@@ -24,6 +26,9 @@ _STATE_TO_EXIT = {
     "max_iterations": EXIT_MAX_ITERATIONS,
 }
 
+# Auto-detected prompt files, checked in order.
+_AUTO_PROMPT_FILES = ("ralph.md", "TASK.md", "ralph.txt", "TASK.txt")
+
 
 def _build_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(
@@ -32,38 +37,40 @@ def _build_parser() -> argparse.ArgumentParser:
     )
     p.add_argument(
         "prompt",
-        help="Task description, or path to a .md/.txt file",
+        nargs="?",
+        default=None,
+        help="Task description, or path to a .md/.txt file (auto-detects ralph.md / TASK.md)",
     )
     p.add_argument(
         "-m", "--max-iterations",
         type=int,
-        default=10,
+        default=None,
         help="Maximum loop iterations (default: 10)",
     )
     p.add_argument(
         "-t", "--timeout",
         type=int,
-        default=1800,
+        default=None,
         help="Maximum runtime in seconds (default: 1800 = 30m)",
     )
     p.add_argument(
         "--promise",
-        default="任務完成！🥇",
+        default=None,
         help="Completion promise phrase (default: 任務完成！🥇)",
     )
     p.add_argument(
         "-c", "--command",
-        default="claude-code-acp",
+        default=None,
         help="ACP CLI command (default: claude-code-acp)",
     )
     p.add_argument(
         "--command-args",
-        default="",
+        default=None,
         help="Extra arguments for the ACP CLI (e.g. '--experimental-acp')",
     )
     p.add_argument(
         "-d", "--working-dir",
-        default=".",
+        default=None,
         help="Working directory (default: .)",
     )
     p.add_argument(
@@ -82,6 +89,17 @@ def _resolve_prompt(raw: str) -> str:
     return raw
 
 
+def _auto_detect_prompt(working_dir: str) -> str | None:
+    """Look for a default prompt file in the working directory."""
+    base = Path(working_dir)
+    for name in _AUTO_PROMPT_FILES:
+        p = base / name
+        if p.is_file():
+            print(f"📄 Auto-detected prompt file: {p}", flush=True)
+            return p.read_text(encoding="utf-8")
+    return None
+
+
 def _run(config: LoopConfig) -> int:
     engine = RalphEngine(config)
     try:
@@ -100,18 +118,49 @@ def main(argv: list[str] | None = None) -> None:
     parser = _build_parser()
     args = parser.parse_args(argv)
 
-    prompt_text = _resolve_prompt(args.prompt)
-
-    config = LoopConfig(
-        prompt=prompt_text,
-        promise_phrase=args.promise,
-        command=args.command,
-        command_args=shlex.split(args.command_args) if args.command_args else [],
-        working_dir=args.working_dir,
-        max_iterations=args.max_iterations,
-        timeout_seconds=args.timeout,
-        dry_run=args.dry_run,
-    )
+    # Layer 1: defaults
+    cfg: dict[str, Any] = {
+        "prompt": None,
+        "promise_phrase": "任務完成！🥇",
+        "command": "claude-code-acp",
+        "command_args": [],
+        "working_dir": ".",
+        "max_iterations": 10,
+        "timeout_seconds": 1800,
+        "dry_run": False,
+    }
+
+    # Layer 2: ralph.yml (overrides defaults)
+    file_cfg = load_config_file(args.working_dir or ".")
+    if file_cfg:
+        cfg.update({k: v for k, v in file_cfg.items() if v is not None})
+
+    # Layer 3: CLI args (overrides config file)
+    if args.prompt is not None:
+        cfg["prompt"] = _resolve_prompt(args.prompt)
+    if args.max_iterations is not None:
+        cfg["max_iterations"] = args.max_iterations
+    if args.timeout is not None:
+        cfg["timeout_seconds"] = args.timeout
+    if args.promise is not None:
+        cfg["promise_phrase"] = args.promise
+    if args.command is not None:
+        cfg["command"] = args.command
+    if args.command_args is not None:
+        cfg["command_args"] = shlex.split(args.command_args)
+    if args.working_dir is not None:
+        cfg["working_dir"] = args.working_dir
+    if args.dry_run:
+        cfg["dry_run"] = True
+
+    # Auto-detect prompt file if no prompt given
+    if cfg["prompt"] is None:
+        cfg["prompt"] = _auto_detect_prompt(cfg["working_dir"])
+
+    if cfg["prompt"] is None:
+        parser.error("prompt is required (provide as argument or create ralph.md / TASK.md)")
+
+    config = LoopConfig(**cfg)
 
     if config.dry_run:
         print("Dry-run config:")

ralph_any-0.2.0/src/ralph/config.py

@@ -0,0 +1,55 @@
+"""Load ralph.yml config file."""
+
+from __future__ import annotations
+
+import shlex
+from pathlib import Path
+from typing import Any
+
+
+def load_config_file(working_dir: str) -> dict[str, Any] | None:
+    """Load ralph.yml / ralph.yaml from *working_dir*. Returns None if absent."""
+    base = Path(working_dir)
+    for name in ("ralph.yml", "ralph.yaml"):
+        path = base / name
+        if path.is_file():
+            return _parse(path)
+    return None
+
+
+def _parse(path: Path) -> dict[str, Any]:
+    """Parse a ralph config file (simple YAML subset, no dependency needed)."""
+    raw: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if ":" not in line:
+            continue
+        key, _, value = line.partition(":")
+        raw[key.strip()] = value.strip()
+
+    cfg: dict[str, Any] = {}
+
+    _map = {
+        "command": "command",
+        "command_args": "command_args",
+        "promise": "promise_phrase",
+        "max_iterations": "max_iterations",
+        "timeout": "timeout_seconds",
+        "working_dir": "working_dir",
+        "prompt": "prompt",
+    }
+
+    for yaml_key, cfg_key in _map.items():
+        if yaml_key not in raw:
+            continue
+        val = raw[yaml_key]
+        if cfg_key in ("max_iterations", "timeout_seconds"):
+            cfg[cfg_key] = int(val)
+        elif cfg_key == "command_args":
+            cfg[cfg_key] = shlex.split(val)
+        else:
+            cfg[cfg_key] = val
+
+    return cfg

ralph_any-0.2.0/tests/test_cli.py

@@ -0,0 +1,48 @@
+"""Tests for CLI prompt resolution and auto-detection."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from ralph.cli import _auto_detect_prompt, _resolve_prompt
+
+
+def test_resolve_prompt_plain_text():
+    assert _resolve_prompt("do something") == "do something"
+
+
+def test_resolve_prompt_reads_md_file(tmp_path: Path):
+    f = tmp_path / "task.md"
+    f.write_text("# Task\nDo this.")
+    assert _resolve_prompt(str(f)) == "# Task\nDo this."
+
+
+def test_resolve_prompt_reads_txt_file(tmp_path: Path):
+    f = tmp_path / "task.txt"
+    f.write_text("hello")
+    assert _resolve_prompt(str(f)) == "hello"
+
+
+def test_auto_detect_ralph_md(tmp_path: Path):
+    (tmp_path / "ralph.md").write_text("auto task")
+    result = _auto_detect_prompt(str(tmp_path))
+    assert result == "auto task"
+
+
+def test_auto_detect_task_md(tmp_path: Path):
+    (tmp_path / "TASK.md").write_text("task file")
+    result = _auto_detect_prompt(str(tmp_path))
+    assert result == "task file"
+
+
+def test_auto_detect_priority(tmp_path: Path):
+    (tmp_path / "ralph.md").write_text("ralph wins")
+    (tmp_path / "TASK.md").write_text("task loses")
+    result = _auto_detect_prompt(str(tmp_path))
+    assert result == "ralph wins"
+
+
+def test_auto_detect_none(tmp_path: Path):
+    result = _auto_detect_prompt(str(tmp_path))
+    assert result is None

ralph_any-0.2.0/tests/test_config.py

@@ -0,0 +1,51 @@
+"""Tests for ralph.yml config loading."""
+
+from pathlib import Path
+
+from ralph.config import load_config_file
+
+
+def test_load_full_config(tmp_path: Path):
+    (tmp_path / "ralph.yml").write_text(
+        "command: gemini\n"
+        "command_args: --experimental-acp\n"
+        "max_iterations: 20\n"
+        "timeout: 3600\n"
+        "promise: done!\n"
+    )
+    cfg = load_config_file(str(tmp_path))
+    assert cfg is not None
+    assert cfg["command"] == "gemini"
+    assert cfg["command_args"] == ["--experimental-acp"]
+    assert cfg["max_iterations"] == 20
+    assert cfg["timeout_seconds"] == 3600
+    assert cfg["promise_phrase"] == "done!"
+
+
+def test_load_yaml_extension(tmp_path: Path):
+    (tmp_path / "ralph.yaml").write_text("command: gemini\n")
+    cfg = load_config_file(str(tmp_path))
+    assert cfg is not None
+    assert cfg["command"] == "gemini"
+
+
+def test_missing_config_returns_none(tmp_path: Path):
+    cfg = load_config_file(str(tmp_path))
+    assert cfg is None
+
+
+def test_comments_and_blanks(tmp_path: Path):
+    (tmp_path / "ralph.yml").write_text(
+        "# Ralph config\n"
+        "\n"
+        "command: gemini\n"
+        "# max_iterations: 5\n"
+    )
+    cfg = load_config_file(str(tmp_path))
+    assert cfg == {"command": "gemini"}
+
+
+def test_partial_config(tmp_path: Path):
+    (tmp_path / "ralph.yml").write_text("max_iterations: 50\n")
+    cfg = load_config_file(str(tmp_path))
+    assert cfg == {"max_iterations": 50}