feat: markdown import support

Author: s0b0lev

src/gitdo/cli.py

@@ -1,10 +1,13 @@
 """CLI interface for GitDo."""
 
+from pathlib import Path
+
 import click
 from rich.console import Console
 from rich.table import Table
 
 from . import __version__
+from .markdown_parser import parse_markdown_file
 from .storage import Storage
 
 console = Console()
@@ -111,6 +114,80 @@ def remove(task_id: str):
         raise click.Abort()
 
 
+@cli.command("import-md")
+@click.argument("file_path", type=click.Path(exists=True, path_type=Path))
+@click.option(
+    "--skip-duplicates",
+    is_flag=True,
+    help="Skip tasks with duplicate titles",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Preview tasks without importing",
+)
+def import_md(
+    file_path: Path,
+    *,
+    skip_duplicates: bool,
+    dry_run: bool,
+) -> None:
+    """
+    Import tasks from a markdown file.
+
+    Scans for checkbox items in the format:
+    - [ ] Task title (pending)
+    - [x] Task title (completed)
+    """
+    storage = Storage()
+    if not storage.is_initialized():
+        console.print("[red]Error:[/red] GitDo is not initialized. Run 'gitdo init' first.")
+        raise click.Abort()
+
+    try:
+        tasks = parse_markdown_file(file_path)
+    except FileNotFoundError:
+        console.print(f"[red]Error:[/red] File not found: {file_path}")
+        raise click.Abort() from None
+    except PermissionError:
+        console.print(f"[red]Error:[/red] Cannot read file: {file_path}")
+        raise click.Abort() from None
+
+    if not tasks:
+        console.print(f"[yellow]No checkbox items found in {file_path}[/yellow]")
+        return
+
+    # Display preview table
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Task", style="")
+    table.add_column("Status", width=12)
+
+    for task in tasks:
+        status_color = "green" if task.status.value == "completed" else "yellow"
+        table.add_row(
+            task.title,
+            f"[{status_color}]{task.status.value}[/{status_color}]",
+        )
+
+    console.print(f"\n[bold]Found {len(tasks)} task(s) in {file_path}:[/bold]")
+    console.print(table)
+
+    if dry_run:
+        console.print("\n[dim]Dry run - no tasks were imported[/dim]")
+        return
+
+    # Import tasks
+    imported_count, skipped_count = storage.import_tasks(
+        tasks,
+        skip_duplicates=skip_duplicates,
+    )
+
+    # Display results
+    console.print(f"\n[green]✓[/green] Imported {imported_count} task(s)")
+    if skipped_count > 0:
+        console.print(f"[yellow]⚠[/yellow] Skipped {skipped_count} duplicate(s)")
+
+
 def main():
     """Entry point for the CLI."""
     cli()

src/gitdo/markdown_parser.py

@@ -0,0 +1,70 @@
+"""Markdown file parser for extracting tasks."""
+
+import re
+from pathlib import Path
+from uuid import uuid4
+
+from .models import Task, TaskStatus
+
+
+def extract_checkbox_items(content: str) -> list[tuple[str, bool]]:
+    """Extract checkbox items from markdown content.
+
+    Args:
+        content: Markdown file content
+
+    Returns:
+        List of (title, is_completed) tuples
+    """
+    # Pattern matches: - [ ] or - [x] or - [X] followed by task title
+    # Supports various indentation levels
+    pattern = r"^\s*-\s+\[([ xX])\]\s+(.+)$"
+    items = []
+
+    for line in content.splitlines():
+        match = re.match(pattern, line)
+        if match:
+            checkbox_state = match.group(1)
+            title = match.group(2).strip()
+            is_completed = checkbox_state.lower() == "x"
+            items.append((title, is_completed))
+
+    return items
+
+
+def parse_markdown_file(file_path: Path) -> list[Task]:
+    """Parse markdown file and extract tasks.
+
+    Args:
+        file_path: Path to markdown file
+
+    Returns:
+        List of Task objects extracted from checkbox items
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        PermissionError: If file cannot be read
+    """
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    try:
+        content = file_path.read_text()
+    except PermissionError as e:
+        raise PermissionError(f"Cannot read file: {file_path}") from e
+
+    checkbox_items = extract_checkbox_items(content)
+    tasks = []
+
+    for title, is_completed in checkbox_items:
+        task = Task(
+            id=str(uuid4()),
+            title=title,
+            status=TaskStatus.COMPLETED if is_completed else TaskStatus.PENDING,
+        )
+        if is_completed:
+            task.complete()
+
+        tasks.append(task)
+
+    return tasks

src/gitdo/storage.py

@@ -26,13 +26,15 @@ def __init__(self, base_path: Path | None = None):
 
     @staticmethod
     def _find_gitdo_root(start_path: Path | None = None) -> Path | None:
-        """Find .gitdo/ folder by walking up directory tree.
+        """
+        Find .gitdo/ folder by walking up directory tree.
 
         Args:
             start_path: Starting directory. Defaults to current directory.
 
         Returns:
             Path containing .gitdo/ folder, or None if not found.
+
         """
         current = start_path or Path.cwd()
         current = current.resolve()
@@ -136,6 +138,39 @@ def remove_task(self, task_id: str) -> bool:
                 return True
         return False
 
+    def import_tasks(
+        self,
+        tasks: list[Task],
+        *,
+        skip_duplicates: bool = False,
+    ) -> tuple[int, int]:
+        """Import multiple tasks at once.
+
+        Args:
+            tasks: List of tasks to import
+            skip_duplicates: If True, skip tasks with duplicate titles
+
+        Returns:
+            Tuple of (imported_count, skipped_count)
+        """
+        existing_tasks = self.load_tasks()
+        existing_titles = {task.title for task in existing_tasks} if skip_duplicates else set()
+
+        imported_count = 0
+        skipped_count = 0
+
+        for task in tasks:
+            if skip_duplicates and task.title in existing_titles:
+                skipped_count += 1
+                continue
+
+            existing_tasks.append(task)
+            existing_titles.add(task.title)
+            imported_count += 1
+
+        self._save_tasks(existing_tasks)
+        return imported_count, skipped_count
+
     def _save_tasks(self, tasks: list[Task]) -> None:
         """Save tasks to storage.
 

tests/test_cli.py

@@ -145,3 +145,161 @@ def test_list_all_flag(runner):
         result = runner.invoke(cli, ["list", "--all"])
         assert "Test task" in result.output
         assert "completed" in result.output.lower()
+
+
+def test_import_md_basic(runner, tmp_path):
+    """Test import-md command with basic markdown file."""
+    md_file = tmp_path / "tasks.md"
+    md_file.write_text("""
+# Tasks
+
+- [ ] Task 1
+- [x] Task 2
+- [ ] Task 3
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        result = runner.invoke(cli, ["import-md", str(md_file)])
+        assert result.exit_code == 0
+        assert "Imported 3 task(s)" in result.output
+        assert "Task 1" in result.output
+        assert "Task 2" in result.output
+        assert "Task 3" in result.output
+
+
+def test_import_md_without_init(runner, tmp_path):
+    """Test import-md command without initialization."""
+    md_file = tmp_path / "tasks.md"
+    md_file.write_text("- [ ] Task 1")
+
+    with runner.isolated_filesystem():
+        result = runner.invoke(cli, ["import-md", str(md_file)])
+        assert result.exit_code != 0
+        assert "not initialized" in result.output.lower()
+
+
+def test_import_md_file_not_found(runner):
+    """Test import-md command with non-existent file."""
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        result = runner.invoke(cli, ["import-md", "/non/existent/file.md"])
+        assert result.exit_code != 0
+
+
+def test_import_md_no_checkboxes(runner, tmp_path):
+    """Test import-md command with file without checkboxes."""
+    md_file = tmp_path / "no_tasks.md"
+    md_file.write_text("""
+# Just some text
+
+No checkbox items here.
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        result = runner.invoke(cli, ["import-md", str(md_file)])
+        assert result.exit_code == 0
+        assert "No checkbox items found" in result.output
+
+
+def test_import_md_skip_duplicates(runner, tmp_path):
+    """Test import-md command with --skip-duplicates flag."""
+    md_file = tmp_path / "tasks.md"
+    md_file.write_text("""
+- [ ] Duplicate task
+- [ ] Unique task
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        # Add a task manually first
+        runner.invoke(cli, ["add", "Duplicate task"])
+
+        # Import with skip-duplicates
+        result = runner.invoke(cli, ["import-md", str(md_file), "--skip-duplicates"])
+        assert result.exit_code == 0
+        assert "Imported 1 task(s)" in result.output
+        assert "Skipped 1 duplicate(s)" in result.output
+
+
+def test_import_md_dry_run(runner, tmp_path):
+    """Test import-md command with --dry-run flag."""
+    md_file = tmp_path / "tasks.md"
+    md_file.write_text("""
+- [ ] Task 1
+- [ ] Task 2
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        result = runner.invoke(cli, ["import-md", str(md_file), "--dry-run"])
+        assert result.exit_code == 0
+        assert "Task 1" in result.output
+        assert "Task 2" in result.output
+        assert "Dry run - no tasks were imported" in result.output
+
+        # Verify tasks were not actually imported
+        list_result = runner.invoke(cli, ["list"])
+        assert "No tasks found" in list_result.output
+
+
+def test_import_md_complex_file(runner, tmp_path):
+    """Test import-md with complex markdown file."""
+    md_file = tmp_path / "complex.md"
+    md_file.write_text("""
+# Project Tasks
+
+## Phase 1
+- [x] Setup project
+- [ ] Write docs
+
+## Phase 2
+- [ ] Implement feature A
+  - [ ] Sub-task 1
+  - [ ] Sub-task 2
+- [ ] Implement feature B
+
+Some random text here.
+
+## Phase 3
+- [ ] Deploy to production
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        result = runner.invoke(cli, ["import-md", str(md_file)])
+        assert result.exit_code == 0
+        assert "Imported 7 task(s)" in result.output
+
+        # Verify tasks are in storage
+        list_result = runner.invoke(cli, ["list", "--all"])
+        assert "Setup project" in list_result.output
+        assert "Write docs" in list_result.output
+        assert "Deploy to production" in list_result.output
+
+
+def test_import_md_preserves_status(runner, tmp_path):
+    """Test that import-md preserves task status (completed vs pending)."""
+    md_file = tmp_path / "tasks.md"
+    md_file.write_text("""
+- [ ] Pending task
+- [x] Completed task
+- [X] Another completed task
+""")
+
+    with runner.isolated_filesystem():
+        runner.invoke(cli, ["init"])
+        runner.invoke(cli, ["import-md", str(md_file)])
+
+        # Check that completed tasks show up in --all but not in default list
+        default_list = runner.invoke(cli, ["list"])
+        all_list = runner.invoke(cli, ["list", "--all"])
+
+        assert "Pending task" in default_list.output
+        assert "Completed task" not in default_list.output
+        assert "Another completed task" not in default_list.output
+
+        assert "Pending task" in all_list.output
+        assert "Completed task" in all_list.output
+        assert "Another completed task" in all_list.output