Make loopforge run accept a directory, like lint

Dogfooding found that 'loopforge lint .' accepts a directory (auto-finds loop.toml) but
'loopforge run .' crashed with 'Is a directory' — run read the path as a file and computed the
loop root from it. A new resolve_loop_file() resolves a directory to its single loop.toml (clear
error if zero or more than one), shared by parse_loop and run, so run and lint take the same paths.

Author: yingchen-coding

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.5.2
+
+- **`run` accepts a directory** like `lint` does — `loopforge run mydir/` resolves the single
+  `loop.toml` inside instead of crashing with "Is a directory". Found by dogfooding (lint a dir,
+  then run it). Multiple loops in one dir → a clear "name the one to run" error.
+
 ## 0.5.1
 
 - **`eval` gate fix** — `--min-accuracy` no longer fails when no predictions are resolved yet.

loopforge/models.py

@@ -118,9 +118,27 @@ def parse_text(text: str, path: Path | None = None) -> Loop:
     return loop
 
 
-def parse_loop(path: str | Path) -> Loop:
-    """Read and parse a loop.toml file. Raises LoopError naming the file on any failure."""
+def resolve_loop_file(path: str | Path) -> Path:
+    """Resolve a path to a single loop file. A file is taken as-is; a directory is searched for
+    `loop.toml` / `*.loop.toml` so `run <dir>` works like `lint <dir>`. Raises LoopError if nothing
+    is found, or if a directory holds more than one loop (ambiguous — name the file)."""
     p = Path(path)
+    if p.is_file():
+        return p
+    if p.is_dir():
+        found = sorted({*p.rglob("loop.toml"), *p.rglob("*.loop.toml")}, key=str)
+        if not found:
+            raise LoopError(f"no loop definitions (loop.toml / *.loop.toml) found under {p}")
+        if len(found) > 1:
+            names = ", ".join(str(f.relative_to(p)) for f in found)
+            raise LoopError(f"{p} holds multiple loops ({names}) — name the one to run")
+        return found[0]
+    raise LoopError(f"no such loop file: {p}")
+
+
+def parse_loop(path: str | Path) -> Loop:
+    """Read and parse a loop file, or the single loop under a directory. Raises LoopError on failure."""
+    p = resolve_loop_file(path)
     try:
         text = p.read_text(encoding="utf-8")
     except FileNotFoundError as exc:

loopforge/runner.py

@@ -18,7 +18,7 @@
 from pathlib import Path
 
 from .linter import lint_text
-from .models import Loop, LoopError, Severity, parse_loop
+from .models import Loop, LoopError, Severity, parse_loop, resolve_loop_file
 
 
 @dataclass
@@ -179,7 +179,7 @@ def run(
     max_iterations: int | None = None,
 ) -> RunResult:
     """Execute a loop. Refuses to start a loop with a CRITICAL completeness finding (no brake)."""
-    path = Path(source)
+    path = resolve_loop_file(source)  # a directory resolves to its single loop.toml, like `lint`
     loop = parse_loop(path)
     root = path.parent
 

tests/test_runner.py

@@ -33,6 +33,21 @@ def test_dry_run_does_not_execute(tmp_path):
     assert result.iterations == 0
 
 
+def test_run_accepts_a_directory_like_lint(tmp_path):
+    # `loopforge run <dir>` must work like `lint <dir>` — resolve the single loop.toml inside.
+    make_loop(tmp_path, act="echo hi")          # writes <tmp>/runme/loop.toml
+    result = run(tmp_path / "runme", dry_run=True)
+    assert result.loop == "runme" and result.outcome == "dry-run"
+
+
+def test_run_directory_with_multiple_loops_is_ambiguous(tmp_path):
+    make_loop(tmp_path, act="echo a")           # <tmp>/runme/loop.toml
+    (tmp_path / "other.loop.toml").write_text(
+        (tmp_path / "runme" / "loop.toml").read_text(), encoding="utf-8")
+    with pytest.raises(LoopError, match="multiple loops"):
+        run(tmp_path, dry_run=True)
+
+
 def test_plan_lists_all_blocks(tmp_path):
     p = make_loop(tmp_path, act="echo hi")
     text = plan(parse_loop(p))