lemming-cli 0.1.4__tar.gz → 0.2.0__tar.gz

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lemming-cli
-Version: 0.1.4
+Version: 0.2.0
 Summary: An autonomous, iterative task runner for AI coding agents.
 Project-URL: Homepage, https://github.com/owahltinez/lemming
 Project-URL: Repository, https://github.com/owahltinez/lemming
@@ -15,7 +15,7 @@ Requires-Dist: fastapi>=0.124.4
 Requires-Dist: markdownify>=0.14.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: readability-cli>=0.4.0
+Requires-Dist: readability-cli>=0.5.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: uvicorn>=0.33.0
 Description-Content-Type: text/markdown

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lemming-cli"
-version = "0.1.4"
+version = "0.2.0"
 description = "An autonomous, iterative task runner for AI coding agents."
 readme = "README.md"
 authors = [
@@ -20,7 +20,7 @@ dependencies = [
     "markdownify>=0.14.1",
     "pydantic>=2.12.5",
     "pyyaml>=6.0.3",
-    "readability-cli>=0.4.0",
+    "readability-cli>=0.5.0",
     "requests>=2.32.3",
     "uvicorn>=0.33.0",
 ]

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/api/tasks.py

@@ -34,14 +34,17 @@ def add_task(
 ):
     """Add a new task and start the orchestrator loop if needed."""
     tasks_file = context.resolve_tasks_file(request.app.state, project)
-    new_task = tasks.add_task(
-        tasks_file,
-        task.description,
-        task.runner,
-        index=task.index,
-        parent=task.parent,
-        parent_tasks_file=task.parent_tasks_file,
-    )
+    try:
+        new_task = tasks.add_task(
+            tasks_file,
+            task.description,
+            task.runner,
+            index=task.index,
+            parent=task.parent,
+            parent_tasks_file=task.parent_tasks_file,
+        )
+    except ValueError as e:
+        raise fastapi.HTTPException(400, str(e))
     loop.start_loop_if_needed(
         request.app.state,
         tasks_file,

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/goal.py

@@ -18,13 +18,7 @@ from .main import cli
 )
 @click.pass_context
 def goal(ctx: click.Context, goal_text: str | None, file: pathlib.Path | None):
-    """Sets or displays the long-term goal shared across all tasks.
-
-    Args:
-        ctx: The click context holding shared CLI state.
-        goal_text: The goal string to set (optional).
-        file: A file path to read the goal from (optional).
-    """
+    """Sets or displays the long-term goal shared across all tasks."""
     tasks_file = ctx.obj["TASKS_FILE"]
 
     if file:

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/main_test.py

@@ -16,6 +16,14 @@ class TestCLIMain(unittest.TestCase):
             "Lemming: An autonomous, iterative task runner", result.output
         )
 
+    def test_command_help_hides_internal_docstrings(self):
+        for command_name in cli.commands:
+            with self.subTest(command=command_name):
+                result = self.cli_runner.invoke(cli, [command_name, "--help"])
+                self.assertEqual(result.exit_code, 0)
+                self.assertNotIn("Args:", result.output)
+                self.assertNotIn("ctx: The click context", result.output)
+
 
 if __name__ == "__main__":
     unittest.main()

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/operations.py

@@ -21,9 +21,7 @@ from .main import cli
 @click.option(
     "--retry-delay",
     default=10,
-    help=(
-        "Seconds to wait before retrying a failed task (to handle rate limits)."
-    ),
+    help="Seconds to wait before retrying an incomplete task.",
 )
 @click.option(
     "--yolo/--no-yolo",
@@ -50,16 +48,7 @@ def run(
     no_defaults: bool,
     runner_args: tuple,
 ) -> None:
-    """Starts the orchestrator loop to autonomously execute pending tasks.
-
-    Args:
-        ctx: The click context.
-        retry_delay: Delay between retries.
-        yolo: If True, skip runner confirmations.
-        env: Environment variables to inject.
-        no_defaults: Skip default flag injection.
-        runner_args: Raw arguments passed directly to the runner.
-    """
+    """Starts the orchestrator loop to autonomously execute pending tasks."""
     tasks_file = ctx.obj["TASKS_FILE"]
     verbose = ctx.obj["VERBOSE"]
 
@@ -78,9 +67,14 @@ def run(
     if env_overrides:
         os.environ.update(env_overrides)
 
-    tasks.acquire_loop_lock(tasks_file)
+    completed = False
+    try:
+        tasks.acquire_loop_lock(tasks_file)
+    except tasks.LoopAlreadyRunningError as e:
+        click.echo(f"Error: {e}")
+        ctx.exit(1)
     try:
-        run_loop(
+        completed = run_loop(
             tasks_file,
             verbose,
             retry_delay,
@@ -91,6 +85,8 @@ def run(
         )
     finally:
         tasks.release_loop_lock(tasks_file)
+    if not completed:
+        ctx.exit(1)
 
 
 @cli.command(short_help="Launch the web interface")

lemming_cli-0.2.0/src/lemming/cli/operations_test.py

@@ -0,0 +1,93 @@
+import pathlib
+import shutil
+import tempfile
+import time
+import unittest
+from unittest import mock
+
+import click.testing
+
+from lemming import cli, tasks
+
+
+class TestCLIOperations(unittest.TestCase):
+    def setUp(self):
+        self.cli_runner = click.testing.CliRunner()
+        self.test_dir = tempfile.mkdtemp()
+        self.test_tasks_file = pathlib.Path(self.test_dir) / "tasks_test.yml"
+        self.base_args = [
+            "--verbose",
+            "--tasks-file",
+            str(self.test_tasks_file),
+        ]
+
+        # Scaffold a valid file
+        data = tasks.Roadmap(
+            goal="Initial goal",
+            tasks=[],
+        )
+        tasks.save_tasks(self.test_tasks_file, data)
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+
+    def test_run_help(self):
+        result = self.cli_runner.invoke(cli.cli, ["run", "--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Starts the orchestrator loop", result.output)
+
+    def test_run_empty_queue_reports_completion(self):
+        result = self.cli_runner.invoke(cli.cli, self.base_args + ["run"])
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("All tasks completed!", result.output)
+
+    def test_run_blocked_queue_exits_nonzero(self):
+        tasks.save_tasks(
+            self.test_tasks_file,
+            tasks.Roadmap(
+                tasks=[
+                    tasks.Task(
+                        id="active123",
+                        description="Active task",
+                        status=tasks.TaskStatus.IN_PROGRESS,
+                        pid=1234,
+                        last_heartbeat=time.time(),
+                    ),
+                    tasks.Task(
+                        id="pending456",
+                        description="Pending task",
+                        status=tasks.TaskStatus.PENDING,
+                    ),
+                ]
+            ),
+        )
+
+        with mock.patch(
+            "lemming.tasks.lifecycle.is_pid_alive", return_value=True
+        ):
+            result = self.cli_runner.invoke(cli.cli, self.base_args + ["run"])
+
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Queue blocked by active task active123", result.output)
+        self.assertIn("1 pending task remains", result.output)
+        self.assertNotIn("All tasks completed!", result.output)
+
+    def test_run_rejects_live_loop_owner(self):
+        tasks.acquire_loop_lock(self.test_tasks_file)
+        try:
+            result = self.cli_runner.invoke(cli.cli, self.base_args + ["run"])
+        finally:
+            tasks.release_loop_lock(self.test_tasks_file)
+
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Another loop is already running", result.output)
+
+    def test_serve_help(self):
+        result = self.cli_runner.invoke(cli.cli, ["serve", "--help"])
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Launches the local web dashboard", result.output)
+
+
+if __name__ == "__main__":
+    unittest.main()

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/progress.py

@@ -24,14 +24,7 @@ def progress(
     text: typing.Optional[str],
     file: typing.Optional[typing.TextIO],
 ):
-    """Records a progress entry or finding for a specific task.
-
-    Args:
-        ctx: The click context holding shared CLI state.
-        task_id: The ID of the task.
-        text: The progress to record (optional if --file is used).
-        file: An optional file to read the progress from.
-    """
+    """Records a progress entry or finding for a specific task."""
     tasks_file = ctx.obj["TASKS_FILE"]
 
     if file:

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/tasks.py

@@ -20,7 +20,7 @@ from .main import cli
 @click.option(
     "--index",
     default=-1,
-    help="Index to insert the task at (defaults to -1, the end).",
+    help="Zero-based displayed queue position (-1 appends).",
 )
 @click.option(
     "--runner",
@@ -47,18 +47,7 @@ def add(
     parent: str | None,
     parent_tasks_file: str | None,
 ):
-    """Adds a new task to the roadmap queue.
-
-    Args:
-        ctx: The click context.
-        description: A text description of the task to perform (optional if
-            --file is used).
-        file: An optional file to read the description from.
-        index: The position in the roadmap to insert the task.
-        runner_name: An optional custom runner to use for this specific task.
-        parent: Optional parent task ID.
-        parent_tasks_file: Optional parent tasks file path.
-    """
+    """Adds a new task to the roadmap queue."""
     tasks_file = ctx.obj["TASKS_FILE"]
     verbose = ctx.obj["VERBOSE"]
 
@@ -74,14 +63,18 @@ def add(
         click.echo("Error: Must provide either description or --file.")
         ctx.exit(1)
 
-    new_task = tasks.add_task(
-        tasks_file,
-        description,
-        runner_name,
-        index=index,
-        parent=parent,
-        parent_tasks_file=parent_tasks_file,
-    )
+    try:
+        new_task = tasks.add_task(
+            tasks_file,
+            description,
+            runner_name,
+            index=index,
+            parent=parent,
+            parent_tasks_file=parent_tasks_file,
+        )
+    except ValueError as e:
+        click.echo(f"Error: {e}")
+        ctx.exit(1)
     task_id = new_task.id
 
     if verbose:
@@ -100,7 +93,11 @@ def add(
     help="Read new description from a file (or - for stdin).",
 )
 @click.option("--runner", "runner_name", help="New custom runner for the task.")
-@click.option("--index", type=int, help="New index in the task queue.")
+@click.option(
+    "--index",
+    type=int,
+    help="New zero-based position in the displayed task queue.",
+)
 @click.option(
     "--parent",
     help="New parent task ID (use empty string to remove).",
@@ -120,18 +117,7 @@ def edit(
     parent: str | None,
     parent_tasks_file: str | None,
 ):
-    """Edits an existing task's description, runner, position, or parent.
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to update.
-        description: The new description (optional).
-        file: An optional file to read the new description from.
-        runner_name: The new preferred runner (optional).
-        index: The new position in the roadmap (optional).
-        parent: The new parent task ID (optional).
-        parent_tasks_file: The new parent tasks file path (optional).
-    """
+    """Edits an existing task's description, runner, position, or parent."""
     if file:
         if description:
             click.echo("Error: Cannot provide both description and --file.")
@@ -184,14 +170,7 @@ def edit(
 def delete_task(
     ctx: click.Context, task_id: str | None, delete_all: bool, completed: bool
 ):
-    """Deletes one or more tasks from the roadmap.
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the specific task to delete.
-        delete_all: If set, clears the entire roadmap and long-term goal.
-        completed: If set, deletes all tasks marked as 'completed'.
-    """
+    """Deletes one or more tasks from the roadmap."""
     tasks_file = ctx.obj["TASKS_FILE"]
 
     # Validate argument combinations
@@ -205,12 +184,16 @@ def delete_task(
         click.echo("Error: Provide a task ID, or use --all or --completed.")
         ctx.exit(1)
 
-    removed = tasks.delete_tasks(
-        tasks_file,
-        task_id=task_id,
-        all_tasks=delete_all,
-        completed_only=completed,
-    )
+    try:
+        removed = tasks.delete_tasks(
+            tasks_file,
+            task_id=task_id,
+            all_tasks=delete_all,
+            completed_only=completed,
+        )
+    except ValueError as e:
+        click.echo(f"Error: {e}")
+        ctx.exit(1)
 
     if delete_all:
         click.echo(
@@ -229,12 +212,7 @@ def delete_task(
 @click.argument("task_id", required=False)
 @click.pass_context
 def status(ctx: click.Context, task_id: str | None):
-    """Displays the roadmap status or details for a specific task.
-
-    Args:
-        ctx: The click context.
-        task_id: Optional ID of the task to inspect in detail.
-    """
+    """Displays the roadmap status or details for a specific task."""
     tasks_file = ctx.obj["TASKS_FILE"]
     verbose = ctx.obj["VERBOSE"]
     project_data = tasks.get_project_data(tasks_file)
@@ -422,24 +400,47 @@ def logs(ctx: click.Context, task_id: str | None):
 
 @cli.command(short_help="<taskid> Mark a task as completed")
 @click.argument("task_id")
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Finalize an in-progress task immediately, without running hooks.",
+)
 @click.pass_context
-def complete(ctx: click.Context, task_id: str):
-    """Marks a task as completed (requires at least one progress entry).
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to mark as completed.
-    """
+def complete(ctx: click.Context, task_id: str, force: bool):
+    """Marks a task as completed (requires at least one progress entry)."""
     tasks_file = ctx.obj["TASKS_FILE"]
 
     try:
+        data = tasks.load_tasks(tasks_file)
+        current_task = tasks.resolve_task(data.tasks, task_id)
+        task_is_active = tasks.is_task_active(current_task, time.time())
+        if (
+            current_task.status == tasks.TaskStatus.IN_PROGRESS
+            and current_task.progress
+            and not force
+            and not task_is_active
+            and not tasks.is_loop_running(tasks_file)
+        ):
+            raise ValueError(
+                f"Task {current_task.id} is in progress, but no active runner "
+                "or loop can finalize it. Use --force to complete it without "
+                "running hooks, or reset it to retry."
+            )
+
         target_task = tasks.update_task(
             tasks_file,
             task_id,
             status=tasks.TaskStatus.COMPLETED,
             require_progress=True,
+            force=force,
         )
-        click.echo(f"Task {target_task.id} marked as completed.")
+        if target_task.requested_status == tasks.TaskStatus.COMPLETED:
+            click.echo(
+                f"Task {target_task.id} completion requested; "
+                "finalization hooks are pending."
+            )
+        else:
+            click.echo(f"Task {target_task.id} marked as completed.")
     except ValueError as e:
         click.echo(f"Error: {e}")
         ctx.exit(1)
@@ -449,12 +450,7 @@ def complete(ctx: click.Context, task_id: str):
 @click.argument("task_id")
 @click.pass_context
 def uncomplete(ctx: click.Context, task_id: str):
-    """Unmarks a completed task, moving it back to 'pending' status.
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to uncomplete.
-    """
+    """Unmarks a completed task, moving it back to 'pending' status."""
     tasks_file = ctx.obj["TASKS_FILE"]
     try:
         target_task = tasks.update_task(
@@ -470,12 +466,7 @@ def uncomplete(ctx: click.Context, task_id: str):
 @click.argument("task_id")
 @click.pass_context
 def fail(ctx: click.Context, task_id: str):
-    """Marks a task as failed (requires at least one recorded progress entry).
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to mark as failed.
-    """
+    """Marks a task as failed (requires recorded progress)."""
     tasks_file = ctx.obj["TASKS_FILE"]
     try:
         target_task = tasks.update_task(
@@ -494,12 +485,7 @@ def fail(ctx: click.Context, task_id: str):
 @click.argument("task_id")
 @click.pass_context
 def cancel(ctx: click.Context, task_id: str):
-    """Kills the runner for an in-progress task and marks it as cancelled.
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to cancel.
-    """
+    """Kills the runner and cancels an in-progress task."""
     tasks_file = ctx.obj["TASKS_FILE"]
     if tasks.cancel_task(tasks_file, task_id):
         click.echo(f"Task {task_id} cancelled.")
@@ -512,12 +498,7 @@ def cancel(ctx: click.Context, task_id: str):
 @click.argument("task_id")
 @click.pass_context
 def reset(ctx: click.Context, task_id: str):
-    """Clears all history (attempts, progress, and logs) for a specific task.
-
-    Args:
-        ctx: The click context.
-        task_id: The ID of the task to reset.
-    """
+    """Clears a task's attempts, progress, and logs."""
     tasks_file = ctx.obj["TASKS_FILE"]
     try:
         target_task = tasks.reset_task(tasks_file, task_id)

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/cli/tasks_test.py

@@ -1,6 +1,7 @@
 import pathlib
 import shutil
 import tempfile
+import time
 import unittest
 from unittest import mock
 
@@ -115,6 +116,70 @@ class TestCLITasks(unittest.TestCase):
         data = tasks.load_tasks(self.test_tasks_file)
         self.assertEqual(data.tasks[0].status, tasks.TaskStatus.COMPLETED)
 
+    def test_active_task_completion_runs_hooks(self):
+        with tasks.lock_tasks(self.test_tasks_file):
+            data = tasks.load_tasks(self.test_tasks_file)
+            data.tasks[0].status = tasks.TaskStatus.IN_PROGRESS
+            data.tasks[0].progress = ["Done"]
+            data.tasks[0].pid = 1234
+            data.tasks[0].last_heartbeat = time.time()
+            tasks.save_tasks(self.test_tasks_file, data)
+
+        with mock.patch(
+            "lemming.tasks.lifecycle.is_pid_alive", return_value=True
+        ):
+            result = self.cli_runner.invoke(
+                cli.cli, self.base_args + ["complete", "12345678"]
+            )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("completion requested", result.output)
+        data = tasks.load_tasks(self.test_tasks_file)
+        self.assertEqual(data.tasks[0].status, tasks.TaskStatus.IN_PROGRESS)
+        self.assertEqual(
+            data.tasks[0].requested_status, tasks.TaskStatus.COMPLETED
+        )
+
+    def test_stale_task_completion_requires_force(self):
+        with tasks.lock_tasks(self.test_tasks_file):
+            data = tasks.load_tasks(self.test_tasks_file)
+            data.tasks[0].status = tasks.TaskStatus.IN_PROGRESS
+            data.tasks[0].progress = ["Done"]
+            data.tasks[0].pid = 999999
+            data.tasks[0].last_heartbeat = 0
+            tasks.save_tasks(self.test_tasks_file, data)
+
+        result = self.cli_runner.invoke(
+            cli.cli, self.base_args + ["complete", "12345678"]
+        )
+
+        self.assertNotEqual(result.exit_code, 0)
+        self.assertIn("Use --force", result.output)
+        data = tasks.load_tasks(self.test_tasks_file)
+        self.assertEqual(data.tasks[0].status, tasks.TaskStatus.IN_PROGRESS)
+        self.assertIsNone(data.tasks[0].requested_status)
+
+    def test_force_completes_stale_task(self):
+        with tasks.lock_tasks(self.test_tasks_file):
+            data = tasks.load_tasks(self.test_tasks_file)
+            data.tasks[0].status = tasks.TaskStatus.IN_PROGRESS
+            data.tasks[0].progress = ["Done"]
+            data.tasks[0].pid = 999999
+            data.tasks[0].last_heartbeat = 0
+            tasks.save_tasks(self.test_tasks_file, data)
+
+        result = self.cli_runner.invoke(
+            cli.cli, self.base_args + ["complete", "--force", "12345678"]
+        )
+
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("marked as completed", result.output)
+        data = tasks.load_tasks(self.test_tasks_file)
+        self.assertEqual(data.tasks[0].status, tasks.TaskStatus.COMPLETED)
+        self.assertIsNone(data.tasks[0].requested_status)
+        self.assertIsNone(data.tasks[0].pid)
+        self.assertIsNone(data.tasks[0].last_heartbeat)
+
     def test_task_uncomplete(self):
         # First complete it
         self.cli_runner.invoke(

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/integration_test.py

@@ -185,15 +185,15 @@ class TestIntegration(unittest.TestCase):
                 "marked COMPLETED",
             )
 
-    def test_orchestrator_retries_on_runner_crash(self):
-        """Verify the orchestrator retries if the runner exits non-zero."""
+    def test_orchestrator_stops_on_runner_crash(self):
+        """Verify a non-zero runner exit stops without consuming an attempt."""
         with unittest.mock.patch("time.sleep", return_value=None):
             data = tasks.load_tasks(self.test_tasks_file)
             data.config.retries = 3
             data.config.runner = "false"  # 'false' command exits with 1
             tasks.save_tasks(self.test_tasks_file, data)
 
-            orchestrator.run_loop(
+            completed = orchestrator.run_loop(
                 self.test_tasks_file,
                 verbose=False,
                 retry_delay=0,
@@ -203,9 +203,9 @@ class TestIntegration(unittest.TestCase):
             )
 
             data = tasks.load_tasks(self.test_tasks_file)
-            # It should have attempted 3 times and then failed
-            self.assertEqual(data.tasks[0].attempts, 3)
-            self.assertEqual(data.tasks[0].status, models.TaskStatus.FAILED)
+            self.assertFalse(completed)
+            self.assertEqual(data.tasks[0].attempts, 0)
+            self.assertEqual(data.tasks[0].status, models.TaskStatus.PENDING)
 
     def test_orchestrator_stops_on_cancellation(self):
         """Verify the orchestrator stops if the runner exits with SIGTERM."""

{lemming_cli-0.1.4 → lemming_cli-0.2.0}/src/lemming/models.py

@@ -28,6 +28,10 @@ class TaskNotFoundError(ValueError):
     """Raised when a task ID cannot be found in the roadmap."""
 
 
+class AmbiguousTaskIdError(ValueError):
+    """Raised when a task ID prefix matches more than one task."""
+
+
 class TaskStatus(enum.StrEnum):
     """Enumeration of possible task statuses."""