lemming-cli 0.1.0__py3-none-any.whl

lemming/cli/operations_test.py

@@ -0,0 +1,44 @@
+import pathlib
+import shutil
+import tempfile
+import unittest
+
+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(
+            context="Initial context",
+            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_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/progress.py

@@ -0,0 +1,54 @@
+"""CLI command for recording task progress entries."""
+
+import typing
+
+import click
+
+from .. import tasks
+from .main import cli
+
+
+@cli.command(short_help="<taskid> [text] Add a progress entry")
+@click.argument("task_id")
+@click.argument("text", required=False)
+@click.option(
+    "--file",
+    "-f",
+    type=click.File("r"),
+    help="Read progress text from a file (or - for stdin).",
+)
+@click.pass_context
+def progress(
+    ctx: click.Context,
+    task_id: str,
+    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.
+    """
+    tasks_file = ctx.obj["TASKS_FILE"]
+
+    if file:
+        if text:
+            click.echo("Error: Cannot provide both progress text and --file.")
+            ctx.exit(1)
+        text = file.read().strip()
+    elif text:
+        text = text.strip()
+
+    if not text:
+        click.echo("Error: Must provide either progress text or --file.")
+        ctx.exit(1)
+
+    try:
+        target_task = tasks.add_progress(tasks_file, task_id, text)
+        click.echo(f"Progress added to task {target_task.id}.")
+    except ValueError as e:
+        click.echo(f"Error: {e}")
+        ctx.exit(1)

lemming/cli/progress_test.py

@@ -0,0 +1,40 @@
+import pytest
+from click.testing import CliRunner
+
+from lemming import tasks
+from lemming.cli import main as cli
+
+
+@pytest.fixture
+def setup_env(tmp_path):
+    tasks_file = tmp_path / "tasks_test.yml"
+    base_args = ["--tasks-file", str(tasks_file)]
+    runner = CliRunner()
+
+    data = tasks.Roadmap(
+        context="Initial context",
+        tasks=[
+            tasks.Task(
+                id="12345678",
+                description="Test task",
+                status=tasks.TaskStatus.PENDING,
+            )
+        ],
+    )
+    tasks.save_tasks(tasks_file, data)
+
+    return runner, base_args, tasks_file
+
+
+def test_progress(setup_env):
+    runner, base_args, tasks_file = setup_env
+
+    result = runner.invoke(
+        cli.cli, base_args + ["progress", "12345678", "Observed behavior X"]
+    )
+
+    assert result.exit_code == 0
+    assert "Progress added to task" in result.output
+
+    data = tasks.load_tasks(tasks_file)
+    assert "Observed behavior X" in data.tasks[0].progress

lemming/cli/readability_cli.py

@@ -0,0 +1,28 @@
+"""CLI group wrapping the standalone readability code-quality tool."""
+
+import logging
+
+import click
+import readability
+
+from .main import cli
+
+
+@cli.group(name="readability")
+@click.pass_context
+def readability_group(ctx: click.Context):
+    """Run the readability tool for code quality checks.
+
+    This wraps the standalone 'readability' package, ensuring it is always
+    available to coding agents running within Lemming.
+    """
+    # Sync verbose flag from lemming's top-level option
+    if ctx.obj.get("VERBOSE"):
+        logging.getLogger("readability").setLevel(logging.DEBUG)
+
+
+# Merge the commands from the readability package directly into our group.
+# This allows 'lemming readability check ...' instead of
+# 'lemming readability cli check ...'
+for name, command in readability.cli.commands.items():
+    readability_group.add_command(command, name=name)

lemming/cli/readability_cli_test.py

@@ -0,0 +1,57 @@
+import logging
+
+from click.testing import CliRunner
+
+from lemming.cli.main import cli
+
+
+def test_readability_group_help():
+    runner = CliRunner()
+    result = runner.invoke(cli, ["readability", "--help"])
+    assert result.exit_code == 0
+    assert "Run the readability tool for code quality checks" in result.output
+
+
+def test_readability_check_help():
+    runner = CliRunner()
+    result = runner.invoke(cli, ["readability", "check", "--help"])
+    assert result.exit_code == 0
+    assert "check" in result.output.lower()
+
+
+def test_readability_guide_help():
+    runner = CliRunner()
+    result = runner.invoke(cli, ["readability", "guide", "--help"])
+    assert result.exit_code == 0
+    assert "guide" in result.output.lower()
+
+
+def test_readability_languages():
+    runner = CliRunner()
+    result = runner.invoke(cli, ["readability", "languages"])
+    assert result.exit_code == 0
+    assert "Supported languages" in result.output
+
+
+def test_readability_verbose_sync():
+    runner = CliRunner()
+    # This just ensures the command runs with -v,
+    # we can't easily check the logger level of a sub-process or if it was
+    # modified in-process
+    # without more complex mocking, but we can verify it doesn't crash.
+    result = runner.invoke(cli, ["-v", "readability", "languages"])
+    assert result.exit_code == 0
+    assert "Supported languages" in result.output
+
+    # Check that the logger level was actually set in this process
+    logger = logging.getLogger("readability")
+    assert logger.level == logging.DEBUG
+
+
+def test_readability_check_ignored_file():
+    runner = CliRunner()
+    # src/lemming/web/mancha.js is ignored in biome.json
+    result = runner.invoke(
+        cli, ["readability", "check", "src/lemming/web/mancha.js"]
+    )
+    assert result.exit_code == 0