lemming-cli 0.1.0__py3-none-any.whl

lemming/api/main_test.py

@@ -0,0 +1,30 @@
+def test_read_index(client):
+    """Test that the root endpoint returns the index.html content."""
+    response = client.get("/")
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+    # Verify some content from the index.html file
+    assert "Lemming" in response.text
+
+
+def test_static_files(client):
+    """Test that static files are accessible."""
+    # Try to access a common static file like mancha.js or index.js
+    response = client.get("/static/mancha.js")
+    assert response.status_code == 200
+    assert "text/javascript" in response.headers["content-type"]
+
+
+def test_filtered_static_files(client):
+    """Test that web test files are filtered out from static assets."""
+    # Test file that should be hidden
+    response = client.get("/static/dashboard.spec.js")
+    assert response.status_code == 404
+
+    # Test file that should be hidden
+    response = client.get("/static/dashboard.test.js")
+    assert response.status_code == 404
+
+    # Normal file should still be accessible
+    response = client.get("/static/index.js")
+    assert response.status_code == 200

lemming/api/tasks.py

@@ -0,0 +1,170 @@
+"""API routes for creating, updating, and inspecting tasks."""
+
+import fastapi
+import pydantic
+
+from .. import paths, tasks
+from . import context, loop
+
+router = fastapi.APIRouter()
+
+
+@router.get("/api/data", response_model=tasks.ProjectData)
+def get_data(request: fastapi.Request, project: str | None = None):
+    """Get the full project data: context, config, tasks, and status."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    data = tasks.get_project_data(tasks_file)
+    data.cwd = str(context.resolve_project_dir(request.app.state, project))
+    return data
+
+
+class AddTaskRequest(pydantic.BaseModel):
+    """Request body for adding a new task to the roadmap."""
+
+    description: str
+    runner: str | None = None
+    index: int = -1
+    parent: str | None = None
+    parent_tasks_file: str | None = None
+
+
+@router.post("/api/tasks")
+def add_task(
+    request: fastapi.Request, task: AddTaskRequest, project: str | None = None
+):
+    """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,
+    )
+    loop.start_loop_if_needed(
+        request.app.state,
+        tasks_file,
+        cwd=context.resolve_project_dir(request.app.state, project),
+    )
+    return new_task
+
+
+@router.get("/api/tasks/{task_id}", response_model=tasks.Task)
+def get_task(
+    request: fastapi.Request, task_id: str, project: str | None = None
+):
+    """Get a single task by ID (or unique ID prefix)."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    data = tasks.load_tasks(tasks_file)
+    target = next((t for t in data.tasks if t.id.startswith(task_id)), None)
+    if not target:
+        raise fastapi.HTTPException(404, "Task not found")
+    return target
+
+
+@router.post("/api/tasks/{task_id}/update")
+def update_task(
+    request: fastapi.Request,
+    task_id: str,
+    update: dict,
+    project: str | None = None,
+):
+    """Update a task's description, runner, position, status, or parent."""
+    tasks_file = context.resolve_tasks_file(request.app.state, project)
+    status = update.get("status")
+
+    # Validation: require progress if completing or failing from the UI,
+    # but not if we are just marking a finished task as pending (uncomplete).
+    require_progress = False
+    if status in (
+        tasks.TaskStatus.COMPLETED,
+        tasks.TaskStatus.FAILED,
+        tasks.TaskStatus.PENDING,
+    ):
+        data = tasks.load_tasks(tasks_file)
+        target = next((t for t in data.tasks if t.id.startswith(task_id)), None)
+        if target and target.status not in (
+            tasks.TaskStatus.COMPLETED,
+            tasks.TaskStatus.FAILED,
+            tasks.TaskStatus.CANCELLED,
+        ):
+            require_progress = True
+
+    try:
+        updated_task = tasks.update_task(
+            tasks_file,
+            task_id,
+            description=update.get("description"),
+            runner=update.get("runner"),
+            index=update.get("index"),
+            status=status,
+            require_progress=require_progress,
+            parent=update.get("parent"),
+        )
+        return updated_task
+    except ValueError as e:
+        if "not found" in str(e):
+            raise fastapi.HTTPException(404, str(e))
+        raise fastapi.HTTPException(400, str(e))
+
+
+@router.post("/api/tasks/delete-completed")
+def delete_completed_tasks(
+    request: fastapi.Request, project: str | None = None
+):
+    """Delete all completed tasks from the roadmap."""
+    tasks.delete_tasks(
+        context.resolve_tasks_file(request.app.state, project),
+        completed_only=True,
+    )
+    return {"status": "ok"}
+
+
+@router.post("/api/tasks/{task_id}/delete")
+def delete_task(
+    request: fastapi.Request, task_id: str, project: str | None = None
+):
+    """Delete a single task by ID."""
+    tasks.delete_tasks(
+        context.resolve_tasks_file(request.app.state, project), task_id=task_id
+    )
+    return {"status": "ok"}
+
+
+@router.post("/api/tasks/{task_id}/cancel")
+def cancel_task_endpoint(
+    request: fastapi.Request, task_id: str, project: str | None = None
+):
+    """Cancel a running or pending task."""
+    if tasks.cancel_task(
+        context.resolve_tasks_file(request.app.state, project), task_id
+    ):
+        return {"status": "ok"}
+    raise fastapi.HTTPException(404, "Task not found")
+
+
+@router.post("/api/tasks/{task_id}/clear")
+def clear_task_endpoint(
+    request: fastapi.Request, task_id: str, project: str | None = None
+):
+    """Reset a task to pending, clearing its attempts and progress."""
+    try:
+        tasks_file = context.resolve_tasks_file(request.app.state, project)
+        tasks.reset_task(tasks_file, task_id)
+        return {"status": "ok"}
+    except ValueError as e:
+        raise fastapi.HTTPException(404, str(e))
+
+
+@router.get("/api/tasks/{task_id}/log")
+def get_task_log(
+    request: fastapi.Request, task_id: str, project: str | None = None
+):
+    """Get the runner log output for a task, or empty if none exists."""
+    log_file = paths.get_log_file(
+        context.resolve_tasks_file(request.app.state, project), task_id
+    )
+    if not log_file.exists():
+        return {"log": ""}
+    return {"log": log_file.read_text(encoding="utf-8")}

lemming/api/tasks_test.py

@@ -0,0 +1,426 @@
+from unittest.mock import patch
+
+from lemming import api, paths, tasks
+
+
+def test_get_data(client, test_tasks):
+    response = client.get("/api/data")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["context"] == "Initial context"
+    assert len(data["tasks"]) == 3
+    # Check that task1 is in the list
+    task1 = next(t for t in data["tasks"] if t["id"] == "task1")
+    assert task1["status"] == tasks.TaskStatus.COMPLETED
+    assert data["loop_running"] is True
+
+
+def test_add_task(client, test_tasks):
+    response = client.post(
+        "/api/tasks", json={"description": "New task from test"}
+    )
+    assert response.status_code == 200
+    data = response.json()
+    assert data["description"] == "New task from test"
+    assert data["id"]  # id should be auto-generated
+    assert data["status"] == tasks.TaskStatus.PENDING
+
+    # Verify task was persisted
+    roadmap = tasks.load_tasks(test_tasks)
+    assert any(t.description == "New task from test" for t in roadmap.tasks)
+
+
+def test_add_task_with_runner(client, test_tasks):
+    response = client.post(
+        "/api/tasks", json={"description": "Runner task", "runner": "claude"}
+    )
+    assert response.status_code == 200
+    assert response.json()["runner"] == "claude"
+
+
+def test_delete_completed_tasks(client, test_tasks):
+    response = client.post("/api/tasks/delete-completed")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    # Verify tasks in file
+    data = tasks.load_tasks(test_tasks)
+    task_ids = [t.id for t in data.tasks]
+    assert "task1" not in task_ids
+    assert "task2" in task_ids
+    assert "task3" in task_ids
+    assert len(data.tasks) == 2
+
+
+def test_delete_completed_tasks_includes_failed(client, test_tasks):
+    # Setup data with a failed task
+    with tasks.lock_tasks(test_tasks):
+        data = tasks.load_tasks(test_tasks)
+        data.tasks.append(
+            tasks.Task(
+                id="failed_task",
+                description="Failed Task",
+                status=tasks.TaskStatus.FAILED,
+                attempts=1,
+                progress=["Error"],
+                completed_at=123456789.0,
+            )
+        )
+        tasks.save_tasks(test_tasks, data)
+
+    response = client.post("/api/tasks/delete-completed")
+    assert response.status_code == 200
+
+    # Verify tasks in file
+    data = tasks.load_tasks(test_tasks)
+    task_ids = [t.id for t in data.tasks]
+    assert "task1" not in task_ids  # task1 is completed
+    assert "failed_task" not in task_ids  # failed_task should be deleted
+    assert "task2" in task_ids
+    assert "task3" in task_ids
+    assert len(data.tasks) == 2
+
+
+def test_delete_specific_task(client, test_tasks):
+    response = client.post("/api/tasks/task2/delete")
+    assert response.status_code == 200
+
+    data = tasks.load_tasks(test_tasks)
+    task_ids = [t.id for t in data.tasks]
+    assert "task2" not in task_ids
+    assert len(data.tasks) == 2
+
+
+def test_update_task_description(client, test_tasks):
+    response = client.post(
+        "/api/tasks/task2/update", json={"description": "Updated Pending Task"}
+    )
+    assert response.status_code == 200
+    assert response.json()["description"] == "Updated Pending Task"
+
+    data = tasks.load_tasks(test_tasks)
+    task2 = next(t for t in data.tasks if t.id == "task2")
+    assert task2.description == "Updated Pending Task"
+
+
+def test_update_completed_task_description_fails(client, test_tasks):
+    response = client.post(
+        "/api/tasks/task1/update",
+        json={"description": "Attempt to update completed task"},
+    )
+    assert response.status_code == 400
+    assert (
+        "Cannot edit description of a completed task"
+        in response.json()["detail"]
+    )
+
+
+def test_mark_task_failed_via_api(client, test_tasks):
+    # task2 is pending with no progress
+    # 1. Try to fail without progress -> should fail
+    response = client.post(
+        "/api/tasks/task2/update", json={"status": tasks.TaskStatus.FAILED}
+    )
+    assert response.status_code == 400
+    assert "has no recorded progress" in response.json()["detail"]
+
+    # 2. Add progress and try again
+    with tasks.lock_tasks(test_tasks):
+        data = tasks.load_tasks(test_tasks)
+        task2 = next(t for t in data.tasks if t.id == "task2")
+        task2.progress = ["Failed attempt"]
+        tasks.save_tasks(test_tasks, data)
+
+    response = client.post(
+        "/api/tasks/task2/update", json={"status": tasks.TaskStatus.FAILED}
+    )
+    assert response.status_code == 200
+    assert response.json()["status"] == tasks.TaskStatus.FAILED
+
+    data = tasks.load_tasks(test_tasks)
+    task2 = next(t for t in data.tasks if t.id == "task2")
+    assert task2.status == tasks.TaskStatus.FAILED
+
+
+def test_uncomplete_task_via_api(client, test_tasks):
+    # Updating status of a completed task should still be allowed
+    response = client.post(
+        "/api/tasks/task1/update", json={"status": tasks.TaskStatus.PENDING}
+    )
+    assert response.status_code == 200
+    assert response.json()["status"] == tasks.TaskStatus.PENDING
+    assert response.json()["attempts"] == 0
+
+    data = tasks.load_tasks(test_tasks)
+    task1 = next(t for t in data.tasks if t.id == "task1")
+    assert task1.status == tasks.TaskStatus.PENDING
+    assert task1.attempts == 0
+
+
+def test_reopen_cancelled_task_via_api(client, test_tasks):
+    # First cancel task2 (pending), then reopen it
+    response = client.post(
+        "/api/tasks/task2/update", json={"status": tasks.TaskStatus.CANCELLED}
+    )
+    assert response.status_code == 200
+    assert response.json()["status"] == tasks.TaskStatus.CANCELLED
+
+    # Now reopen the cancelled task back to pending
+    response = client.post(
+        "/api/tasks/task2/update", json={"status": tasks.TaskStatus.PENDING}
+    )
+    assert response.status_code == 200
+    assert response.json()["status"] == tasks.TaskStatus.PENDING
+    assert response.json()["attempts"] == 0
+
+
+def test_has_log_population(client, test_tasks):
+    # Initially no logs
+    response = client.get("/api/data")
+    assert response.status_code == 200
+    data = response.json()
+    for task in data["tasks"]:
+        assert task["has_runner_log"] is False
+
+    # Create a runner log for task1
+    log_file = paths.get_log_file(api.app.state.tasks_file, "task1")
+    log_file.write_text("Some logs")
+
+    response = client.get("/api/data")
+    assert response.status_code == 200
+    data = response.json()
+    task1 = next(t for t in data["tasks"] if t["id"] == "task1")
+    assert task1["has_runner_log"] is True
+
+    task2 = next(t for t in data["tasks"] if t["id"] == "task2")
+    assert task2["has_runner_log"] is False
+
+
+def test_get_single_task(client, test_tasks):
+    # task1 exists in test_tasks fixture
+    resp = client.get("/api/tasks/task1")
+    assert resp.status_code == 200
+    assert resp.json()["id"] == "task1"
+    assert resp.json()["description"] == "Completed Task"
+
+
+def test_get_nonexistent_task(client, test_tasks):
+    resp = client.get("/api/tasks/nonexistent")
+    assert resp.status_code == 404
+
+
+def test_api_log(client, test_tasks):
+    test_tasks_file = test_tasks
+    task_id = "testlogid"
+    log_file = paths.get_log_file(test_tasks_file, task_id)
+    log_file.write_text("API log content")
+
+    response = client.get(f"/api/tasks/{task_id}/log")
+    assert response.status_code == 200
+    assert response.json() == {"log": "API log content"}
+
+    # Test non-existent log
+    response = client.get("/api/tasks/missing/log")
+    assert response.status_code == 200
+    assert response.json() == {"log": ""}
+
+
+def test_api_delete_log_cleanup(client, test_tasks):
+    test_tasks_file = test_tasks
+    # 1. Add a task
+    data = tasks.load_tasks(test_tasks_file)
+    task_id = "api_delete_test"
+    data.tasks.append(
+        tasks.Task(
+            id=task_id,
+            description="api delete test",
+            status=tasks.TaskStatus.PENDING,
+            attempts=0,
+            progress=[],
+        )
+    )
+    tasks.save_tasks(test_tasks_file, data)
+
+    # 2. Create log manually
+    log_file = paths.get_log_file(test_tasks_file, task_id)
+    log_file.write_text("API delete log")
+    assert log_file.exists()
+
+    # 3. Delete via API
+    response = client.post(f"/api/tasks/{task_id}/delete")
+    assert response.status_code == 200
+    assert not log_file.exists()
+
+
+def test_project_param_get_data(client, test_tasks):
+    """GET /api/data?project=subdir returns data for that project."""
+    root = api.app.state.root
+    subdir = root / "myproject"
+    subdir.mkdir(exist_ok=True)
+
+    # Add a task via the project param
+    response = client.post(
+        "/api/tasks",
+        json={"description": "Sub-project task"},
+        params={"project": "myproject"},
+    )
+    assert response.status_code == 200
+
+    # Fetch data for the sub-project
+    response = client.get("/api/data", params={"project": "myproject"})
+    assert response.status_code == 200
+    data = response.json()
+    assert any(t["description"] == "Sub-project task" for t in data["tasks"])
+
+    # Default project should not have this task
+    response = client.get("/api/data")
+    assert response.status_code == 200
+    data = response.json()
+    assert not any(
+        t["description"] == "Sub-project task" for t in data["tasks"]
+    )
+
+
+def test_project_delete_completed_isolation(client, test_tasks):
+    """Deleting completed tasks in root does not affect sub-projects."""
+    root = api.app.state.root
+    subdir = root / "isolated"
+    subdir.mkdir(exist_ok=True)
+
+    # Add and complete a task in the sub-project
+    res = client.post(
+        "/api/tasks",
+        json={"description": "Sub task"},
+        params={"project": "isolated"},
+    )
+    assert res.status_code == 200
+    task_id = res.json()["id"]
+    # Mark it completed (requires progress, so use update_task directly)
+    tasks.update_task(
+        paths.get_tasks_file_for_dir(subdir),
+        task_id,
+        status=tasks.TaskStatus.COMPLETED,
+        require_progress=False,
+    )
+
+    # Delete completed in ROOT
+    response = client.post("/api/tasks/delete-completed")
+    assert response.status_code == 200
+
+    # Sub-project's completed task should still exist
+    res = client.get("/api/data", params={"project": "isolated"})
+    assert res.status_code == 200
+    assert any(t["id"] == task_id for t in res.json()["tasks"])
+
+
+def test_add_task_auto_starts_loop(client, test_tasks):
+    with patch("subprocess.Popen") as mock_popen:
+        # Mock is_loop_running to return False
+        with patch("lemming.tasks.is_loop_running", return_value=False):
+            # Set auto-start to True for this test
+            api.app.state.disable_auto_start = False
+            try:
+                response = client.post(
+                    "/api/tasks", json={"description": "New task"}
+                )
+                assert response.status_code == 200
+
+                # Verify Popen was called to start the loop
+                mock_popen.assert_called_once()
+                args, kwargs = mock_popen.call_args
+                cmd = args[0]
+                assert "run" in cmd
+                assert str(test_tasks) in cmd
+            finally:
+                api.app.state.disable_auto_start = True
+
+
+def test_add_task_does_not_restart_if_running(client, test_tasks):
+    with patch("subprocess.Popen") as mock_popen:
+        # Mock is_loop_running to return True
+        with patch("lemming.tasks.is_loop_running", return_value=True):
+            response = client.post(
+                "/api/tasks", json={"description": "New task"}
+            )
+            assert response.status_code == 200
+
+            # Verify Popen was NOT called
+            mock_popen.assert_not_called()
+
+
+def test_update_task_to_pending_does_not_start_loop(client, test_tasks):
+    # Add a completed task
+    task = tasks.add_task(test_tasks, "Completed task")
+    tasks.add_progress(test_tasks, task.id, "Done")
+    tasks.update_task(test_tasks, task.id, status=tasks.TaskStatus.COMPLETED)
+
+    with patch("subprocess.Popen") as mock_popen:
+        # Mock is_loop_running to return False
+        with patch("lemming.tasks.is_loop_running", return_value=False):
+            # Update to pending
+            response = client.post(
+                f"/api/tasks/{task.id}/update",
+                json={"status": tasks.TaskStatus.PENDING},
+            )
+            assert response.status_code == 200
+
+            # Verify Popen was NOT called
+            mock_popen.assert_not_called()
+
+
+def test_clear_task_does_not_start_loop(client, test_tasks):
+    # Add a completed task
+    task = tasks.add_task(test_tasks, "Completed task")
+    tasks.add_progress(test_tasks, task.id, "Done")
+    tasks.update_task(test_tasks, task.id, status=tasks.TaskStatus.COMPLETED)
+
+    with patch("subprocess.Popen") as mock_popen:
+        # Mock is_loop_running to return False
+        with patch("lemming.tasks.is_loop_running", return_value=False):
+            # Clear task
+            response = client.post(f"/api/tasks/{task.id}/clear")
+            assert response.status_code == 200
+
+            # Verify Popen was NOT called
+            mock_popen.assert_not_called()
+
+
+def test_add_task_respects_disable_auto_start(client, test_tasks):
+    api.app.state.disable_auto_start = True
+    with patch("subprocess.Popen") as mock_popen:
+        with patch("lemming.tasks.is_loop_running", return_value=False):
+            response = client.post(
+                "/api/tasks", json={"description": "No auto-start task"}
+            )
+            assert response.status_code == 200
+
+            # Verify Popen was NOT called
+            mock_popen.assert_not_called()
+
+
+def test_add_task_starts_loop_with_cwd(test_workspace, client):
+    root_dir, subproject_dir = test_workspace
+
+    with patch("subprocess.Popen") as mock_popen:
+        # Adding a task should trigger auto-start of the loop
+        response = client.post(
+            "/api/tasks",
+            json={"description": "New task in subproject"},
+            params={"project": "my-subproject"},
+        )
+        assert response.status_code == 200
+
+        # Verify Popen was called with the correct cwd for the auto-started loop
+        _, kwargs = mock_popen.call_args
+        assert str(kwargs["cwd"]) == str(subproject_dir)
+
+
+def test_cancel_task_endpoint(client, test_tasks):
+    with patch("lemming.tasks.cancel_task", return_value=True):
+        response = client.post("/api/tasks/task3/cancel")
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
+
+    with patch("lemming.tasks.cancel_task", return_value=False):
+        response = client.post("/api/tasks/nonexistent/cancel")
+        assert response.status_code == 404

lemming/api.py

@@ -0,0 +1,5 @@
+"""Backward-compatible entry point re-exporting the FastAPI app."""
+
+from .api.main import QuietPollFilter, app
+
+__all__ = ["app", "QuietPollFilter"]

lemming/api_test.py

@@ -0,0 +1,7 @@
+from lemming import api
+
+
+def test_api_proxy():
+    # Verify that the proxy re-exports work
+    assert hasattr(api, "app")
+    assert hasattr(api, "QuietPollFilter")

lemming/cli/__init__.py

@@ -0,0 +1,12 @@
+"""Lemming CLI package; importing the submodules registers all commands."""
+
+from . import config as _config_cmds  # noqa: F401
+from . import context as _context_cmds  # noqa: F401
+from . import hooks as _hooks_cmds  # noqa: F401
+from . import operations as _ops_cmds  # noqa: F401
+from . import progress as _progress_cmds  # noqa: F401
+from . import readability_cli as _readability_cmds  # noqa: F401
+from . import tasks as _tasks_cmds  # noqa: F401
+from .main import cli
+
+__all__ = ["cli"]