lemming-cli 0.1.0__py3-none-any.whl

lemming/tasks/queries_test.py

@@ -0,0 +1,233 @@
+import time
+from unittest import mock
+
+from lemming import paths
+
+from .. import models, persistence
+from . import queries
+
+
+def test_get_project_data_deduplication(tmp_path):
+    tasks_file = tmp_path / "tasks.yml"
+
+    # Create a corrupted roadmap with duplicate task IDs
+    data = models.Roadmap(
+        context="test",
+        tasks=[
+            models.Task(
+                id="1", description="Task 1", status=models.TaskStatus.PENDING
+            ),
+            models.Task(
+                id="1",
+                description="Task 1 Duplicate",
+                status=models.TaskStatus.PENDING,
+            ),
+            models.Task(
+                id="2", description="Task 2", status=models.TaskStatus.PENDING
+            ),
+        ],
+    )
+    persistence.save_tasks(tasks_file, data)
+
+    project_data = queries.get_project_data(tasks_file)
+
+    # Should only have two unique tasks, oldest first (chronological)
+    assert len(project_data.tasks) == 2
+    assert project_data.tasks[0].description == "Task 1"
+    assert project_data.tasks[1].description == "Task 2"
+
+
+def test_get_project_data_enriches_metadata(tmp_path):
+    tasks_file = tmp_path / "tasks.yml"
+    data = models.Roadmap(
+        tasks=[
+            models.Task(
+                id="1", description="Task 1", status=models.TaskStatus.PENDING
+            ),
+            models.Task(
+                id="2", description="Task 2", status=models.TaskStatus.PENDING
+            ),
+        ]
+    )
+    persistence.save_tasks(tasks_file, data)
+
+    # Create a dummy log file for Task 2
+    log_file = paths.get_log_file(tasks_file, "2")
+    log_file.parent.mkdir(parents=True, exist_ok=True)
+    log_file.write_text("dummy log")
+
+    project_data = queries.get_project_data(tasks_file)
+
+    # Check index and has_runner_log
+    t2 = next(t for t in project_data.tasks if t.id == "2")
+    t1 = next(t for t in project_data.tasks if t.id == "1")
+
+    assert t1.index == 0
+    assert t1.has_runner_log is False
+
+    assert t2.index == 1
+    assert t2.has_runner_log is True
+
+
+def test_completed_tasks_sorting_newest_first(tmp_path):
+    tasks_file = tmp_path / "tasks.yml"
+    data = models.Roadmap(
+        tasks=[
+            models.Task(
+                id="1",
+                description="Task 1",
+                status=models.TaskStatus.COMPLETED,
+                completed_at=100.0,
+            ),
+            models.Task(
+                id="2",
+                description="Task 2",
+                status=models.TaskStatus.COMPLETED,
+                completed_at=200.0,
+            ),
+            models.Task(
+                id="3",
+                description="Task 3",
+                status=models.TaskStatus.COMPLETED,
+                completed_at=300.0,
+            ),
+        ]
+    )
+    persistence.save_tasks(tasks_file, data)
+
+    project_data = queries.get_project_data(tasks_file)
+    completed_tasks = [
+        t for t in project_data.tasks if t.status == models.TaskStatus.COMPLETED
+    ]
+
+    # Should be newest first
+    assert completed_tasks[0].description == "Task 3"
+    assert completed_tasks[1].description == "Task 2"
+    assert completed_tasks[2].description == "Task 1"
+
+
+def test_uncompleted_tasks_sorting_prioritizes_in_progress(tmp_path):
+    tasks_file = tmp_path / "tasks.yml"
+    data = models.Roadmap(
+        tasks=[
+            models.Task(
+                id="1",
+                description="Task 1",
+                status=models.TaskStatus.PENDING,
+                created_at=1.0,
+            ),
+            models.Task(
+                id="2",
+                description="Task 2",
+                status=models.TaskStatus.IN_PROGRESS,
+                created_at=2.0,
+            ),
+            models.Task(
+                id="3",
+                description="Task 3",
+                status=models.TaskStatus.PENDING,
+                created_at=3.0,
+            ),
+        ]
+    )
+    persistence.save_tasks(tasks_file, data)
+
+    project_data = queries.get_project_data(tasks_file)
+    uncompleted_tasks = [
+        t
+        for t in project_data.tasks
+        if t.status
+        not in (models.TaskStatus.COMPLETED, models.TaskStatus.FAILED)
+    ]
+
+    # Should prioritize in_progress first, then chronological index
+    # Task 2 (in_progress), Task 1 (index 0), Task 3 (index 2)
+    assert uncompleted_tasks[0].description == "Task 2"
+    assert uncompleted_tasks[1].description == "Task 1"
+    assert uncompleted_tasks[2].description == "Task 3"
+
+
+def test_failed_tasks_sorting_grouped_with_completed(tmp_path):
+    tasks_file = tmp_path / "tasks.yml"
+    now = time.time()
+    data = models.Roadmap(
+        tasks=[
+            models.Task(
+                id="1",
+                description="Pending",
+                status=models.TaskStatus.PENDING,
+                created_at=now,
+            ),
+            models.Task(
+                id="2",
+                description="In Progress",
+                status=models.TaskStatus.IN_PROGRESS,
+                created_at=now + 1,
+            ),
+            models.Task(
+                id="3",
+                description="Failed",
+                status=models.TaskStatus.FAILED,
+                created_at=now + 2,
+            ),
+            models.Task(
+                id="4",
+                description="Completed",
+                status=models.TaskStatus.COMPLETED,
+                completed_at=now + 1000.0,
+                created_at=now + 3,
+            ),
+        ]
+    )
+    persistence.save_tasks(tasks_file, data)
+
+    project_data = queries.get_project_data(tasks_file)
+
+    # Order should be:
+    # 1. In Progress (uncompleted, prioritized)
+    # 2. Pending (uncompleted, index 0)
+    # 3. Completed (completed/failed, newest)
+    # 4. Failed (completed/failed, older)
+
+    assert project_data.tasks[0].description == "In Progress"
+    assert project_data.tasks[1].description == "Pending"
+    assert project_data.tasks[2].description == "Completed"
+    assert project_data.tasks[3].description == "Failed"
+
+
+def test_get_pending_task(tmp_path):
+    data = models.Roadmap(
+        tasks=[
+            models.Task(
+                id="1",
+                description="Task 1",
+                status=models.TaskStatus.PENDING,
+                created_at=1.0,
+            ),
+            models.Task(
+                id="2",
+                description="Task 2",
+                status=models.TaskStatus.PENDING,
+                created_at=2.0,
+            ),
+        ]
+    )
+    pending = queries.get_pending_task(data)
+    assert pending.id == "1"
+
+
+def test_get_pending_task_none_if_in_progress(tmp_path):
+    with mock.patch("lemming.tasks.lifecycle.is_pid_alive", return_value=True):
+        data = models.Roadmap(
+            tasks=[
+                models.Task(
+                    id="1",
+                    description="Task 1",
+                    status=models.TaskStatus.IN_PROGRESS,
+                    last_heartbeat=time.time(),
+                    pid=12345,
+                )
+            ]
+        )
+        pending = queries.get_pending_task(data)
+        assert pending is None

lemming/web/dashboard.spec.js

@@ -0,0 +1,350 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { expect, test } from '@playwright/test';
+
+const indexHtmlPath = path.resolve(process.cwd(), 'src/lemming/web/index.html');
+
+test.describe('Dashboard E2E', () => {
+  test.beforeEach(async ({ page, context }) => {
+    // Serve the HTML file and static assets over mocked URLs
+    await context.route('**/*', async (route) => {
+      const url = route.request().url();
+      if (
+        url === 'http://localhost:8000/' ||
+        url.startsWith('http://localhost:8000/?')
+      ) {
+        await route.fulfill({
+          contentType: 'text/html',
+          body: fs.readFileSync(indexHtmlPath, 'utf8'),
+        });
+      } else if (url.endsWith('/static/mancha.js')) {
+        await route.fulfill({
+          contentType: 'application/javascript',
+          body: fs.readFileSync(
+            path.resolve(process.cwd(), 'src/lemming/web/mancha.js'),
+            'utf8',
+          ),
+        });
+      } else if (url.endsWith('/static/favicon.js')) {
+        await route.fulfill({
+          contentType: 'application/javascript',
+          body: fs.readFileSync(
+            path.resolve(process.cwd(), 'src/lemming/web/favicon.js'),
+            'utf8',
+          ),
+        });
+      } else if (url.endsWith('/static/index.js')) {
+        await route.fulfill({
+          contentType: 'application/javascript',
+          body: fs.readFileSync(
+            path.resolve(process.cwd(), 'src/lemming/web/index.js'),
+            'utf8',
+          ),
+          headers: { 'Access-Control-Allow-Origin': '*' },
+        });
+      } else if (url.includes('/api/data')) {
+        await route.fulfill({
+          contentType: 'application/json',
+          json: {
+            cwd: '/mock/cwd',
+            loop_running: false,
+            tasks: [],
+            context: 'Mock context',
+          },
+        });
+      } else if (url.includes('/api/runners')) {
+        await route.fulfill({
+          contentType: 'application/json',
+          json: ['agy', 'aider'],
+        });
+      } else if (url.includes('/api/hooks')) {
+        await route.fulfill({
+          contentType: 'application/json',
+          json: ['roadmap'],
+        });
+      } else if (
+        url.includes('/api/directories') &&
+        route.request().method() === 'POST'
+      ) {
+        await route.fulfill({
+          contentType: 'application/json',
+          json: { name: 'new-folder', path: '/mock/cwd/new-folder' },
+        });
+      } else if (url.includes('/api/directories')) {
+        await route.fulfill({
+          contentType: 'application/json',
+          json: {
+            status: 'success',
+            path: '/mock/cwd',
+            directories: [{ name: 'subdir', path: '/mock/cwd/subdir' }],
+          },
+        });
+      } else {
+        await route.continue();
+      }
+    });
+  });
+
+  async function gotoAndAwaitMancha(page) {
+    await page.goto('http://localhost:8000/');
+    await page.evaluate(async () => {
+      while (!window.ManchaApp) await new Promise((r) => setTimeout(r, 50));
+      await window.ManchaApp;
+    });
+  }
+
+  // --- Environment Overrides Tests ---
+
+  test('adds an environment override, stores it in localStorage, and sends it on run', async ({
+    page,
+  }) => {
+    let runRequestPayload = null;
+    await page.route('**/api/run', async (route) => {
+      runRequestPayload = route.request().postDataJSON();
+      await route.fulfill({
+        contentType: 'application/json',
+        json: { status: 'started' },
+      });
+    });
+
+    await gotoAndAwaitMancha(page);
+    await page.waitForLoadState('networkidle');
+
+    await page.evaluate(() => localStorage.clear());
+    await gotoAndAwaitMancha(page);
+
+    const addButton = page.getByRole('button', { name: 'Add override' });
+    await expect(addButton).toBeVisible();
+    await addButton.click();
+
+    const keyInput = page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)');
+    const valueInput = page.getByPlaceholder('VALUE');
+
+    await expect(keyInput).toBeVisible();
+    await keyInput.fill('MY_MOCK_KEY');
+    await valueInput.fill('MY_MOCK_VALUE');
+
+    await page.waitForTimeout(600);
+
+    const localStorageData = await page.evaluate(() =>
+      localStorage.getItem('lemming[]_env_overrides'),
+    );
+    expect(localStorageData).toContain('MY_MOCK_KEY');
+    expect(localStorageData).toContain('MY_MOCK_VALUE');
+
+    const runResponsePromise = page.waitForResponse('**/api/run');
+    await page.getByRole('button', { name: 'Execute Tasks' }).click();
+    await runResponsePromise;
+
+    expect(runRequestPayload).not.toBeNull();
+    expect(runRequestPayload.env).toEqual({
+      MY_MOCK_KEY: 'MY_MOCK_VALUE',
+    });
+  });
+
+  test('different projects store different environment overrides', async ({
+    page,
+  }) => {
+    // Project A
+    await page.goto('http://localhost:8000/?project=ProjectA');
+    await page.evaluate(async () => {
+      while (!window.ManchaApp) await new Promise((r) => setTimeout(r, 50));
+      await window.ManchaApp;
+    });
+    await page.waitForLoadState('networkidle');
+
+    await page.getByRole('button', { name: 'Add override' }).click();
+    await page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)').fill('KEY_A');
+    await page.getByPlaceholder('VALUE').fill('VAL_A');
+    await page.waitForTimeout(600); // debounce
+
+    // Project B
+    await page.goto('http://localhost:8000/?project=ProjectB');
+    await page.evaluate(async () => {
+      while (!window.ManchaApp) await new Promise((r) => setTimeout(r, 50));
+      await window.ManchaApp;
+    });
+    await page.waitForLoadState('networkidle');
+
+    await page.getByRole('button', { name: 'Add override' }).click();
+    await page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)').fill('KEY_B');
+    await page.getByPlaceholder('VALUE').fill('VAL_B');
+    await page.waitForTimeout(600); // debounce
+
+    // Verify Project B only has KEY_B
+    const inputsB = page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)');
+    await expect(inputsB).toHaveCount(1);
+    await expect(inputsB).toHaveValue('KEY_B');
+
+    // Go back to Project A
+    await page.goto('http://localhost:8000/?project=ProjectA');
+    await page.evaluate(async () => {
+      while (!window.ManchaApp) await new Promise((r) => setTimeout(r, 50));
+      await window.ManchaApp;
+    });
+    await page.waitForLoadState('networkidle');
+
+    // Verify Project A still has KEY_A
+    const inputsA = page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)');
+    await expect(inputsA).toHaveCount(1);
+    await expect(inputsA).toHaveValue('KEY_A');
+
+    // Check localStorage keys directly
+    const keys = await page.evaluate(() => Object.keys(localStorage));
+    expect(keys).toContain('lemming[ProjectA]_env_overrides');
+    expect(keys).toContain('lemming[ProjectB]_env_overrides');
+  });
+
+  test('removes an environment override', async ({ page }) => {
+    await gotoAndAwaitMancha(page);
+    await page.evaluate(() => localStorage.clear());
+    await gotoAndAwaitMancha(page);
+
+    const keyInputs = page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)');
+
+    await page.getByRole('button', { name: 'Add override' }).click();
+    await expect(keyInputs).toHaveCount(1);
+
+    await page.getByRole('button', { name: 'Add override' }).click();
+    await expect(keyInputs).toHaveCount(2);
+
+    await keyInputs.nth(0).fill('KEY1');
+    await keyInputs.nth(1).fill('KEY2');
+
+    await page.waitForTimeout(500);
+
+    const removeButtons = page.getByRole('button', { name: 'Remove override' });
+    await removeButtons.nth(0).click();
+
+    await expect(keyInputs).toHaveCount(1);
+    await expect(keyInputs.nth(0)).toHaveValue('KEY2');
+
+    await page.waitForTimeout(600);
+
+    const localStorageData = await page.evaluate(() =>
+      localStorage.getItem('lemming[]_env_overrides'),
+    );
+    expect(localStorageData).toContain('KEY2');
+    expect(localStorageData).not.toContain('KEY1');
+  });
+
+  test('ignores empty keys when sending payload', async ({ page }) => {
+    let runRequestPayload = null;
+    await page.route('**/api/run', async (route) => {
+      runRequestPayload = route.request().postDataJSON();
+      await route.fulfill({
+        contentType: 'application/json',
+        json: { status: 'started' },
+      });
+    });
+
+    await gotoAndAwaitMancha(page);
+    await page.evaluate(() => localStorage.clear());
+    await gotoAndAwaitMancha(page);
+
+    await page.getByRole('button', { name: 'Add override' }).click();
+    const keyInputs = page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)');
+    await expect(keyInputs).toHaveCount(1);
+
+    await page.waitForTimeout(600);
+
+    const runResponsePromise = page.waitForResponse('**/api/run');
+    await page.getByRole('button', { name: 'Execute Tasks' }).click();
+    await runResponsePromise;
+
+    expect(runRequestPayload).not.toBeNull();
+    expect(runRequestPayload.env).toBeUndefined();
+  });
+
+  test('persists overrides across page reloads', async ({ page }) => {
+    await gotoAndAwaitMancha(page);
+    await page.evaluate(() => localStorage.clear());
+    await gotoAndAwaitMancha(page);
+
+    // Add override
+    await page.getByRole('button', { name: 'Add override' }).click();
+    await page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)').fill('TEST_KEY');
+    await page.getByPlaceholder('VALUE').fill('TEST_VAL');
+
+    // Wait for save debounce
+    await page.waitForTimeout(600);
+
+    // Reload page
+    await page.reload();
+    await page.waitForLoadState('networkidle');
+
+    // Check that we're dealing with Mancha actually being ready
+    await expect(
+      page.getByRole('heading', { name: 'Lemming Task Runner' }),
+    ).toBeVisible();
+
+    // Give render time
+    await page.waitForTimeout(500);
+
+    // Verify values restored
+    await expect(
+      page.getByPlaceholder('KEY (e.g. OPENAI_API_KEY)'),
+    ).toHaveValue('TEST_KEY');
+    await expect(page.getByPlaceholder('VALUE')).toHaveValue('TEST_VAL');
+  });
+
+  // --- Folder Picker Tests ---
+
+  test('selecting a folder opens it in a new tab', async ({
+    page,
+    context,
+  }) => {
+    await gotoAndAwaitMancha(page);
+    await page.waitForLoadState('networkidle');
+
+    // Open folder picker
+    await page.click('button[title="Switch project"]');
+    await page.waitForSelector('#folder-picker-modal[open]');
+
+    // Select a folder and wait for the popup (new tab)
+    const [popup] = await Promise.all([
+      page.waitForEvent('popup'),
+      page.click('button:has-text("Select This Folder")'),
+    ]);
+
+    // Verify the popup URL contains the project parameter
+    expect(popup.url()).toContain('project=%2Fmock%2Fcwd');
+
+    // Verify modal is closed in the original page
+    await expect(page.locator('#folder-picker-modal')).not.toHaveAttribute(
+      'open',
+    );
+  });
+
+  test('creating a new folder', async ({ page }) => {
+    await gotoAndAwaitMancha(page);
+    await page.waitForLoadState('networkidle');
+
+    // Open folder picker
+    await page.click('button[title="Switch project"]');
+    await page.waitForSelector('#folder-picker-modal[open]');
+
+    // Wait for the button and ensure it's visible
+    const newFolderBtn = page.locator('button[title="Create new folder"]');
+    await expect(newFolderBtn).toBeVisible();
+
+    // Click "New Folder" button
+    await newFolderBtn.click();
+
+    // Fill the folder name
+    await page.fill('input[placeholder="Folder name"]', 'new-folder');
+
+    // Click "Create" button
+    await page.click('button:has-text("Create")');
+
+    // Verify toast notification (mocked behavior)
+    await expect(page.locator('div[role="alert"]')).toContainText(
+      'Folder created!',
+    );
+
+    // The form should be hidden again
+    await expect(
+      page.locator('input[placeholder="Folder name"]'),
+    ).not.toBeVisible();
+  });
+});