lemming-cli 0.1.0__py3-none-any.whl

lemming/orchestrator_test.py

@@ -0,0 +1,468 @@
+import time
+from unittest import mock
+
+import pytest
+
+from lemming import tasks
+from lemming.orchestrator import (
+    _handle_runner_exit,
+    _process_exhausted_retries,
+    _process_finalizing_task,
+    format_duration,
+    parse_timeout,
+    run_loop,
+)
+from lemming.runner import RETURNCODE_TIMEOUT
+
+
+@pytest.fixture
+def setup_env(tmp_path):
+    test_tasks_file = tmp_path / "tasks_test.yml"
+
+    # Scaffold a valid file with one task
+    initial_data = tasks.Roadmap(
+        context="Initial context",
+        tasks=[
+            tasks.Task(
+                id="task1",
+                description="Task 1",
+                status=tasks.TaskStatus.PENDING,
+                attempts=0,
+                progress=[],
+            )
+        ],
+        config=tasks.RoadmapConfig(retries=3, runner="agy"),
+    )
+    tasks.save_tasks(test_tasks_file, initial_data)
+    return test_tasks_file, initial_data
+
+
+def test_parse_timeout():
+    assert parse_timeout("0") == 0.0
+    assert parse_timeout("-1h") == 0.0
+    assert parse_timeout("8h") == 8 * 3600.0
+    assert parse_timeout("30m") == 30 * 60.0
+    assert parse_timeout("90s") == 90.0
+    assert parse_timeout("invalid") == 0.0
+
+
+def test_format_duration():
+    assert format_duration(0) == "none"
+    assert format_duration(-1) == "none"
+    assert format_duration(30) == "30m"
+    assert format_duration(60) == "1h"
+    assert format_duration(90) == "90m"
+    assert format_duration(120) == "2h"
+
+
+@mock.patch("subprocess.Popen")
+def test_run_loop_success(mock_popen, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # Simulate runner reporting success
+    mock_process = mock.MagicMock()
+    mock_process.pid = 12345
+    mock_process.poll.side_effect = [None, 0]
+    mock_process.returncode = 0
+    mock_process.stdout = iter(["stdout\n"])
+    mock_process.communicate.return_value = ("stdout", "stderr")
+
+    def wait_side_effect():
+        with tasks.lock_tasks(test_tasks_file):
+            data = tasks.load_tasks(test_tasks_file)
+            data.tasks[0].status = tasks.TaskStatus.COMPLETED
+            data.tasks[0].completed_at = time.time()
+            tasks.save_tasks(test_tasks_file, data)
+        return 0
+
+    mock_process.wait.side_effect = wait_side_effect
+    mock_popen.return_value = mock_process
+
+    run_loop(
+        test_tasks_file,
+        verbose=True,
+        retry_delay=0,
+        yolo=True,
+        no_defaults=False,
+        runner_args=(),
+    )
+
+    data = tasks.load_tasks(test_tasks_file)
+    assert data.tasks[0].status == tasks.TaskStatus.COMPLETED
+
+
+@mock.patch("subprocess.Popen")
+@mock.patch("time.sleep", return_value=None)
+def test_run_loop_retry_and_fail(mock_sleep, mock_popen, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # Runner finishes but doesn't report completion
+    mock_process = mock.MagicMock()
+    mock_process.pid = 12345
+    mock_process.poll.return_value = 0
+    mock_process.returncode = 0
+    mock_process.stdout = iter(["stdout\n"])
+    mock_process.communicate.return_value = ("stdout", "stderr")
+    mock_popen.return_value = mock_process
+
+    # Configure 2 retries
+    data = tasks.load_tasks(test_tasks_file)
+    data.config.retries = 2
+    tasks.save_tasks(test_tasks_file, data)
+
+    run_loop(
+        test_tasks_file,
+        verbose=True,
+        retry_delay=0,
+        yolo=True,
+        no_defaults=False,
+        runner_args=(),
+    )
+
+    data = tasks.load_tasks(test_tasks_file)
+    assert data.tasks[0].attempts == 2
+    assert data.tasks[0].status == tasks.TaskStatus.FAILED
+
+
+def test_synchronous_hooks_execution_timing(setup_env):
+    """Verifies a new task starts only AFTER previous hooks finished."""
+    test_tasks_file, initial_data = setup_env
+    # 1. Setup two pending tasks.
+    now = time.time()
+    with tasks.lock_tasks(test_tasks_file):
+        data = tasks.load_tasks(test_tasks_file)
+        data.tasks = [
+            tasks.Task(
+                id="task2",
+                description="Task 2",
+                status=tasks.TaskStatus.PENDING,
+                created_at=now,
+            ),
+            tasks.Task(
+                id="task1",
+                description="Task 1",
+                status=tasks.TaskStatus.PENDING,
+                created_at=now + 10,
+            ),
+        ]
+        data.config.retries = 1
+        data.config.runner = "true"
+        tasks.save_tasks(test_tasks_file, data)
+
+    task_starts = {}
+    hook_ends = {}
+
+    def mocked_run_with_heartbeat(
+        cmd, t_file, t_id, verbose, echo_fn, header=None, cwd=None, time_limit=0
+    ):
+        if header and header.startswith("Hook:"):
+            time.sleep(0.1)
+            hook_ends[t_id] = time.time()
+            return 0, "hook stdout", ""
+        else:
+            task_starts[t_id] = time.time()
+            return 0, "task stdout", ""
+
+    def mocked_finish_task_attempt(t_file, t_id):
+        with tasks.lock_tasks(t_file):
+            data = tasks.load_tasks(t_file)
+            task = next(t for t in data.tasks if t.id == t_id)
+            task.requested_status = tasks.TaskStatus.COMPLETED
+            task.status = tasks.TaskStatus.IN_PROGRESS
+            tasks.save_tasks(t_file, data)
+            return task
+
+    with (
+        mock.patch(
+            "lemming.runner.run_with_heartbeat",
+            side_effect=mocked_run_with_heartbeat,
+        ),
+        mock.patch(
+            "lemming.tasks.finish_task_attempt",
+            side_effect=mocked_finish_task_attempt,
+        ),
+        mock.patch("lemming.prompts.list_hooks", return_value=["test_hook"]),
+        mock.patch(
+            "lemming.prompts.prepare_hook_prompt", return_value="Dummy hook"
+        ),
+    ):
+        run_loop(
+            test_tasks_file,
+            verbose=True,
+            retry_delay=0,
+            yolo=True,
+            no_defaults=False,
+            runner_args=(),
+        )
+
+    assert "task1" in task_starts
+    assert "task2" in task_starts
+    assert "task2" in hook_ends
+
+    assert task_starts["task1"] >= hook_ends["task2"], (
+        "Task 1 should start after Task 2 hooks finish"
+    )
+
+
+@mock.patch("lemming.runner.run_with_heartbeat")
+def test_run_loop_calls_runner_with_header(mock_run, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # Setup runner mock
+    mock_run.return_value = (0, "output", "")
+
+    # Mock finish_task_attempt to return a completed task to end loop
+    mock_task = initial_data.tasks[0]
+    mock_task.status = tasks.TaskStatus.COMPLETED
+    with mock.patch(
+        "lemming.tasks.finish_task_attempt", return_value=mock_task
+    ):
+        run_loop(
+            test_tasks_file,
+            verbose=False,
+            retry_delay=0,
+            yolo=True,
+            no_defaults=False,
+            runner_args=(),
+        )
+
+    # Verify run_with_heartbeat was called with header="Task Runner"
+    args, kwargs = mock_run.call_args
+    assert kwargs.get("header") == "Task Runner"
+
+
+@mock.patch("lemming.runner.run_with_heartbeat")
+@mock.patch("time.sleep", return_value=None)
+def test_run_loop_cancelled(mock_sleep, mock_run, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # Simulate a task being cancelled (exit code -15)
+    mock_run.return_value = (-15, "cancelled", "error")
+
+    # Configure retries to ensure it DOES NOT retry
+    data = tasks.load_tasks(test_tasks_file)
+    data.config.retries = 3
+    tasks.save_tasks(test_tasks_file, data)
+
+    run_loop(
+        test_tasks_file,
+        verbose=True,
+        retry_delay=1,
+        yolo=True,
+        no_defaults=False,
+        runner_args=(),
+    )
+
+    # It should only have 1 attempt
+    data = tasks.load_tasks(test_tasks_file)
+    assert data.tasks[0].attempts == 1
+
+    # Verify that sleep was NOT called with the retry_delay (1)
+    # It might be called with other values if I didn't mock enough,
+    # but here it should not be called at all after the break.
+    for call in mock_sleep.call_args_list:
+        assert call[0][0] != 1, (
+            "Should not sleep with retry_delay on cancellation"
+        )
+
+
+@mock.patch("lemming.runner.run_with_heartbeat")
+@mock.patch("time.sleep", return_value=None)
+def test_run_loop_timeout_retries(mock_sleep, mock_run, setup_env):
+    """Verifies that a timed-out task is retried without running hooks."""
+    test_tasks_file, initial_data = setup_env
+    # First call: timeout. Second call: timeout again. Exhausts retries.
+    mock_run.return_value = (RETURNCODE_TIMEOUT, "output", "")
+
+    data = tasks.load_tasks(test_tasks_file)
+    data.config.retries = 2
+    data.config.time_limit = 60
+    tasks.save_tasks(test_tasks_file, data)
+
+    run_loop(
+        test_tasks_file,
+        verbose=False,
+        retry_delay=0,
+        yolo=True,
+        no_defaults=False,
+        runner_args=(),
+    )
+
+    data = tasks.load_tasks(test_tasks_file)
+    assert data.tasks[0].attempts == 2
+    assert data.tasks[0].status == tasks.TaskStatus.FAILED
+
+
+@mock.patch("lemming.runner.run_with_heartbeat")
+@mock.patch("time.sleep", return_value=None)
+def test_run_loop_passes_time_limit(mock_sleep, mock_run, setup_env):
+    """Verifies that time_limit from config is passed to the runner."""
+    test_tasks_file, initial_data = setup_env
+    mock_run.return_value = (0, "output", "")
+
+    data = tasks.load_tasks(test_tasks_file)
+    data.config.time_limit = 30
+    tasks.save_tasks(test_tasks_file, data)
+
+    mock_task = initial_data.tasks[0]
+    mock_task.status = tasks.TaskStatus.COMPLETED
+    with mock.patch(
+        "lemming.tasks.finish_task_attempt", return_value=mock_task
+    ):
+        run_loop(
+            test_tasks_file,
+            verbose=False,
+            retry_delay=0,
+            yolo=True,
+            no_defaults=False,
+            runner_args=(),
+        )
+
+    _, kwargs = mock_run.call_args
+    assert kwargs.get("time_limit") == 30
+
+
+@mock.patch("lemming.orchestrator.run_hooks")
+def test_process_exhausted_retries_aborts(mock_run_hooks, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # 1. Setup task that has exhausted retries and won't be healed
+    data = tasks.load_tasks(test_tasks_file)
+    task = data.tasks[0]
+    task.attempts = 3
+    tasks.save_tasks(test_tasks_file, data)
+
+    should_abort = _process_exhausted_retries(
+        test_tasks_file,
+        task.id,
+        retries=3,
+        runner_name="agy",
+        yolo=True,
+        runner_args=(),
+        no_defaults=False,
+        verbose=False,
+        active_hooks=["roadmap"],
+        working_dir=None,
+        time_limit=1,
+    )
+    assert should_abort
+    mock_run_hooks.assert_called_once()
+    assert (
+        mock_run_hooks.call_args[1]["final_status"] == tasks.TaskStatus.FAILED
+    )
+
+
+@mock.patch("lemming.orchestrator.run_hooks")
+def test_process_exhausted_retries_healed(mock_run_hooks, setup_env):
+    test_tasks_file, initial_data = setup_env
+
+    # Setup task but simulate a hook healing it by resetting attempts
+    def fake_run_hooks(*args, **kwargs):
+        data = tasks.load_tasks(test_tasks_file)
+        data.tasks[0].attempts = 0  # Healed!
+        tasks.save_tasks(test_tasks_file, data)
+
+    mock_run_hooks.side_effect = fake_run_hooks
+
+    data = tasks.load_tasks(test_tasks_file)
+    task = data.tasks[0]
+    task.attempts = 3
+    tasks.save_tasks(test_tasks_file, data)
+
+    should_abort = _process_exhausted_retries(
+        test_tasks_file,
+        task.id,
+        retries=3,
+        runner_name="agy",
+        yolo=True,
+        runner_args=(),
+        no_defaults=False,
+        verbose=False,
+        active_hooks=["roadmap"],
+        working_dir=None,
+        time_limit=1,
+    )
+    assert not should_abort
+    mock_run_hooks.assert_called_once()
+
+
+@mock.patch("lemming.orchestrator.run_hooks")
+def test_process_finalizing_task(mock_run_hooks, setup_env):
+    test_tasks_file, initial_data = setup_env
+    _process_finalizing_task(
+        test_tasks_file,
+        "task1",
+        requested_status=tasks.TaskStatus.COMPLETED,
+        runner_name="agy",
+        yolo=True,
+        runner_args=(),
+        no_defaults=False,
+        verbose=False,
+        active_hooks=["readability"],
+        working_dir=None,
+        time_limit=1,
+    )
+    mock_run_hooks.assert_called_once()
+    assert (
+        mock_run_hooks.call_args[1]["final_status"]
+        == tasks.TaskStatus.COMPLETED
+    )
+
+
+@mock.patch("lemming.orchestrator.run_hooks")
+@mock.patch("time.sleep", return_value=None)
+def test_handle_runner_exit_completes(mock_sleep, mock_run_hooks, setup_env):
+    test_tasks_file, initial_data = setup_env
+    # A task requesting completion runs hooks and doesn't abort loop
+    data = tasks.load_tasks(test_tasks_file)
+    task = data.tasks[0]
+    task.status = tasks.TaskStatus.IN_PROGRESS
+    tasks.save_tasks(test_tasks_file, data)
+
+    # Simulate agent calling `lemming complete` (finish_task_attempt
+    # checks requested_status)
+    tasks.update_task(
+        test_tasks_file, task.id, status=tasks.TaskStatus.COMPLETED
+    )
+
+    should_abort = _handle_runner_exit(
+        test_tasks_file,
+        task.id,
+        returncode=0,
+        stdout="done",
+        stderr="",
+        retries=3,
+        retry_delay=5,
+        runner_name="agy",
+        yolo=True,
+        runner_args=(),
+        no_defaults=False,
+        verbose=False,
+        active_hooks=[],
+        working_dir=None,
+        time_limit=1,
+    )
+    assert not should_abort
+
+
+@mock.patch("lemming.orchestrator.run_hooks")
+def test_handle_runner_exit_cancelled(mock_run_hooks, setup_env):
+    test_tasks_file, initial_data = setup_env
+    data = tasks.load_tasks(test_tasks_file)
+    task = data.tasks[0]
+    task.status = tasks.TaskStatus.IN_PROGRESS
+    tasks.save_tasks(test_tasks_file, data)
+
+    should_abort = _handle_runner_exit(
+        test_tasks_file,
+        task.id,
+        returncode=-15,
+        stdout="",
+        stderr="",
+        retries=3,
+        retry_delay=5,
+        runner_name="agy",
+        yolo=True,
+        runner_args=(),
+        no_defaults=False,
+        verbose=False,
+        active_hooks=[],
+        working_dir=None,
+        time_limit=1,
+    )
+    assert should_abort, "Cancellation (-15) should abort the loop"

lemming/paths.py

@@ -0,0 +1,245 @@
+"""Path resolution, .env loading, and git helpers for Lemming."""
+
+import functools
+import hashlib
+import logging
+import os
+import pathlib
+import stat
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+def _parse_dotenv(path: pathlib.Path) -> dict[str, str]:
+    """Parse a .env file into a dict, skipping comments and blank lines."""
+    result: dict[str, str] = {}
+    try:
+        for lineno, raw_line in enumerate(path.read_text().splitlines(), 1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            # Optional "export " prefix
+            if line.startswith("export "):
+                line = line[7:].strip()
+            if "=" not in line:
+                logger.warning(
+                    "%s:%d: skipping malformed line (no '=')", path, lineno
+                )
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip()
+            # Strip surrounding quotes from value
+            value = value.strip()
+            if (
+                len(value) >= 2
+                and value[0] == value[-1]
+                and value[0] in ('"', "'")
+            ):
+                value = value[1:-1]
+            result[key] = value
+    except FileNotFoundError:
+        pass
+    except Exception as exc:
+        logger.warning("Failed to read %s: %s", path, exc)
+    return result
+
+
+def _check_permissions(path: pathlib.Path) -> None:
+    """Warn if the .env file is readable by group or others."""
+    try:
+        mode = path.stat().st_mode
+        if mode & (stat.S_IRGRP | stat.S_IROTH):
+            logger.warning(
+                "%s has overly permissive permissions (%o). "
+                "Consider restricting to 600.",
+                path,
+                stat.S_IMODE(mode),
+            )
+    except OSError:
+        pass
+
+
+def load_dotenv(project_dir: pathlib.Path | None = None) -> None:
+    """Load environment variables from .env files.
+
+    Precedence (later wins, but real env vars always take priority):
+      1. ~/.local/lemming/.env  (global defaults)
+      2. <project_dir>/.env     (project overrides)
+
+    Existing environment variables are never overwritten.
+    """
+    env_files: list[pathlib.Path] = []
+
+    global_env = get_lemming_home() / ".env"
+    if global_env.is_file():
+        env_files.append(global_env)
+
+    if project_dir is not None:
+        project_env = project_dir / ".env"
+        if project_env.is_file() and project_env != global_env:
+            env_files.append(project_env)
+
+    merged: dict[str, str] = {}
+    for env_file in env_files:
+        _check_permissions(env_file)
+        merged.update(_parse_dotenv(env_file))
+
+    # Only set vars that aren't already in the environment
+    for key, value in merged.items():
+        if key not in os.environ:
+            os.environ[key] = value
+
+
+def get_lemming_home() -> pathlib.Path:
+    """Determines the Lemming home directory from the environment or default.
+
+    Returns:
+        A pathlib.Path representing the Lemming home directory.
+    """
+    home_override = os.environ.get("LEMMING_HOME")
+    if home_override:
+        return pathlib.Path(home_override)
+    return pathlib.Path.home() / ".local" / "lemming"
+
+
+def get_global_hooks_dir() -> pathlib.Path:
+    """Returns the global hooks directory in Lemming home."""
+    return get_lemming_home() / "hooks"
+
+
+def get_project_dir(tasks_file: pathlib.Path) -> pathlib.Path:
+    """Determines the isolated project directory for a given tasks file.
+
+    Args:
+        tasks_file: Path to the tasks YAML file.
+
+    Returns:
+        A pathlib.Path to the isolated directory where project logs and state
+        should be stored.
+    """
+    tasks_file_abs = tasks_file.resolve()
+    lemming_home = get_lemming_home()
+
+    # If the tasks file is already inside lemming home, its parent IS the
+    # project dir.
+    if tasks_file_abs.parent.parent == lemming_home:
+        return tasks_file_abs.parent
+
+    # Otherwise, hash the absolute path of the tasks file to get a unique
+    # project dir.
+    path_hash = hashlib.sha256(str(tasks_file_abs).encode()).hexdigest()[:12]
+    return lemming_home / path_hash
+
+
+def get_tasks_file_for_dir(directory: pathlib.Path) -> pathlib.Path:
+    """Returns the tasks file location for a given project directory.
+
+    Checks for a local `tasks.yml` first, then falls back to an isolated
+    project tasks file in the Lemming home directory.
+
+    Args:
+        directory: The resolved absolute path to the project directory.
+
+    Returns:
+        A pathlib.Path to the tasks file for that directory.
+    """
+    local_tasks = directory / "tasks.yml"
+    if local_tasks.exists():
+        return local_tasks
+
+    path_hash = hashlib.sha256(str(directory).encode()).hexdigest()[:12]
+    return get_lemming_home() / path_hash / "tasks.yml"
+
+
+def get_default_tasks_file() -> pathlib.Path:
+    """Returns the default tasks file location based on the current directory.
+
+    Returns:
+        A pathlib.Path to the default tasks file.
+    """
+    return get_tasks_file_for_dir(pathlib.Path.cwd().resolve())
+
+
+def get_working_dir(tasks_file: pathlib.Path) -> pathlib.Path:
+    """Returns the intended working directory for a tasks file.
+
+    If the tasks file is NOT in the lemming home directory, its parent
+    is assumed to be the working directory.
+
+    If it IS in the lemming home directory, we return the current
+    working directory as a fallback.
+    """
+    tasks_file_abs = tasks_file.resolve()
+    lemming_home = get_lemming_home()
+
+    if lemming_home in tasks_file_abs.parents:
+        # It's an isolated tasks file. We don't know the original source dir
+        # unless it was passed to us or stored in the file.
+        # For now, return CWD.
+        return pathlib.Path.cwd().resolve()
+
+    # It's a local tasks.yml file. Its parent is the project root.
+    return tasks_file_abs.parent
+
+
+def get_log_file(tasks_file: pathlib.Path, task_id: str) -> pathlib.Path:
+    """Returns the log file path for a specific task.
+
+    Args:
+        tasks_file: Path to the tasks YAML file associated with the task.
+        task_id: The unique task ID.
+
+    Returns:
+        A pathlib.Path to the log file for the given task.
+    """
+    project_dir = get_project_dir(tasks_file)
+    project_dir.mkdir(parents=True, exist_ok=True)
+    return project_dir / f"{task_id}-runner.log"
+
+
+@functools.cache
+def in_git_repo() -> bool:
+    """Check if the current directory is inside a git repository.
+
+    The result is cached after the first call; use
+    `in_git_repo.cache_clear()` to reset it.
+
+    Returns:
+        True if inside a git repository, False otherwise.
+    """
+    try:
+        return (
+            subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                capture_output=True,
+                check=False,
+            ).returncode
+            == 0
+        )
+    except Exception:
+        return False
+
+
+def is_ignored(path: pathlib.Path) -> bool:
+    """Check if a given path is ignored by git.
+
+    Args:
+        path: The path to check for git-ignore status.
+
+    Returns:
+        True if the path is ignored by git, False otherwise.
+    """
+    if not in_git_repo():
+        return False
+    try:
+        return (
+            subprocess.run(
+                ["git", "check-ignore", "-q", str(path)],
+                capture_output=True,
+                check=False,
+            ).returncode
+            == 0
+        )
+    except Exception:
+        return False