devtodo 0.1.0__py3-none-any.whl

devtodo/__init__.py

@@ -0,0 +1,3 @@
+"""devtodo – a developer-focused CLI todo tool."""
+
+__version__ = "0.1.0"

devtodo/commands/add.py

@@ -0,0 +1,44 @@
+from typing import Optional
+import typer
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error, print_todo
+from devtodo.utils.dates import parse_date
+
+app = typer.Typer(help="Add a new todo.")
+
+
+@app.callback(invoke_without_command=True)
+def add(
+    title: str = typer.Argument(..., help="Title of the todo"),
+    description: Optional[str] = typer.Option(None, "--desc", "-d", help="Optional description"),
+    priority: str = typer.Option("medium", "--priority", "-p", help="Priority: low, medium, high"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="Project name"),
+    tags: Optional[str] = typer.Option(None, "--tags", "-t", help="Comma-separated tags"),
+    due: Optional[str] = typer.Option(None, "--due", help="Due date (YYYY-MM-DD)"),
+) -> None:
+    if priority not in ("low", "medium", "high"):
+        error(f"Invalid priority '{priority}'. Use: low, medium, high")
+        raise typer.Exit(1)
+
+    due_date = None
+    if due:
+        try:
+            due_date = parse_date(due)
+        except ValueError as e:
+            error(str(e))
+            raise typer.Exit(1)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.add(
+            title=title,
+            description=description,
+            priority=priority,
+            project=project,
+            tags=tags,
+            due_date=due_date,
+        )
+    success(f"Added todo [bold]#{todo.id}[/bold]: {todo.title}")
+    print_todo(todo)

devtodo/commands/done.py

@@ -0,0 +1,22 @@
+import typer
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error
+
+app = typer.Typer(help="Mark a todo as done.")
+
+
+@app.callback(invoke_without_command=True)
+def done(
+    todo_id: int = typer.Argument(..., help="ID of the todo to mark as done"),
+) -> None:
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.mark_done(todo_id)
+
+    if todo:
+        success(f"Todo [bold]#{todo.id}[/bold] marked as done: {todo.title}")
+    else:
+        error(f"Todo #{todo_id} not found.")
+        raise typer.Exit(1)

devtodo/commands/edit.py

@@ -0,0 +1,56 @@
+from typing import Optional
+import typer
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error, print_todo
+from devtodo.utils.dates import parse_date
+
+app = typer.Typer(help="Edit a todo.")
+
+
+@app.callback(invoke_without_command=True)
+def edit(
+    todo_id: int = typer.Argument(..., help="ID of the todo to edit"),
+    title: Optional[str] = typer.Option(None, "--title", help="New title"),
+    description: Optional[str] = typer.Option(None, "--desc", "-d", help="New description"),
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="New status: open, done, in_progress"),
+    priority: Optional[str] = typer.Option(None, "--priority", "-p", help="New priority: low, medium, high"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="New project"),
+    tags: Optional[str] = typer.Option(None, "--tags", "-t", help="New tags (comma-separated)"),
+    due: Optional[str] = typer.Option(None, "--due", help="New due date (YYYY-MM-DD)"),
+) -> None:
+    if priority and priority not in ("low", "medium", "high"):
+        error(f"Invalid priority '{priority}'. Use: low, medium, high")
+        raise typer.Exit(1)
+    if status and status not in ("open", "done", "in_progress"):
+        error(f"Invalid status '{status}'. Use: open, done, in_progress")
+        raise typer.Exit(1)
+
+    due_date = None
+    if due:
+        try:
+            due_date = parse_date(due)
+        except ValueError as e:
+            error(str(e))
+            raise typer.Exit(1)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.edit(
+            todo_id=todo_id,
+            title=title,
+            description=description,
+            status=status,
+            priority=priority,
+            project=project,
+            tags=tags,
+            due_date=due_date,
+        )
+
+    if todo:
+        success(f"Todo [bold]#{todo.id}[/bold] updated.")
+        print_todo(todo)
+    else:
+        error(f"Todo #{todo_id} not found.")
+        raise typer.Exit(1)

devtodo/commands/github_cmd.py

@@ -0,0 +1,120 @@
+"""devtodo github – GitHub Issue integration commands."""
+
+from typing import Optional
+import typer
+from rich.console import Console
+
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error, print_todos
+
+app = typer.Typer(help="GitHub Issue integration.")
+console = Console()
+
+
+def _require_repo(repo: Optional[str]) -> str:
+    if not repo:
+        error("Provide --repo owner/reponame  e.g. --repo torvalds/linux")
+        raise typer.Exit(1)
+    if "/" not in repo:
+        error("--repo must be in format  owner/reponame")
+        raise typer.Exit(1)
+    return repo
+
+
+@app.command("sync")
+def sync(
+    repo: Optional[str] = typer.Option(None, "--repo", "-r", help="GitHub repo (owner/name)"),
+    state: str = typer.Option("open", "--state", "-s", help="Issue state: open / closed / all"),
+    limit: int = typer.Option(50, "--limit", "-n", help="Max issues to fetch"),
+) -> None:
+    """Import GitHub Issues as todos."""
+    from devtodo.github_client import fetch_issues
+    repo = _require_repo(repo)
+
+    console.print(f"[dim]Fetching {state} issues from [bold]{repo}[/bold]...[/dim]")
+    try:
+        issues = fetch_issues(repo, state=state, limit=limit)
+    except Exception as e:
+        error(f"GitHub API error: {e}")
+        raise typer.Exit(1)
+
+    if not issues:
+        console.print("[dim]No issues found.[/dim]")
+        return
+
+    engine = init_db()
+    added = 0
+    skipped = 0
+    with get_session(engine) as session:
+        service = TodoService(session)
+        existing_urls = {t.github_url for t in service.list_todos() if t.github_url}
+
+        for issue in issues:
+            url = issue["html_url"]
+            if url in existing_urls:
+                skipped += 1
+                continue
+            service.add(
+                title=issue["title"],
+                description=issue.get("body") or None,
+                github_url=url,
+                github_issue_number=issue["number"],
+            )
+            added += 1
+
+    success(f"Imported {added} issue(s) from [bold]{repo}[/bold]  ({skipped} already existed).")
+
+
+@app.command("push")
+def push(
+    todo_id: int = typer.Argument(..., help="Todo ID to push as GitHub Issue"),
+    repo: Optional[str] = typer.Option(None, "--repo", "-r", help="GitHub repo (owner/name)"),
+) -> None:
+    """Push a todo as a new GitHub Issue."""
+    from devtodo.github_client import create_issue
+    repo = _require_repo(repo)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.get(todo_id)
+        if not todo:
+            error(f"Todo #{todo_id} not found.")
+            raise typer.Exit(1)
+
+        if todo.github_url:
+            error(f"Todo #{todo_id} is already linked to: {todo.github_url}")
+            raise typer.Exit(1)
+
+        console.print(f"[dim]Creating issue in [bold]{repo}[/bold]...[/dim]")
+        try:
+            issue = create_issue(repo, title=todo.title, body=todo.description)
+        except Exception as e:
+            error(f"GitHub API error: {e}")
+            raise typer.Exit(1)
+
+        service.edit(
+            todo_id=todo_id,
+            github_url=issue["html_url"],
+            github_issue_number=issue["number"],
+        )
+
+    success(f"Issue created: [link={issue['html_url']}]{issue['html_url']}[/link]")
+
+
+@app.command("list")
+def list_linked() -> None:
+    """List todos that are linked to GitHub Issues."""
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todos = [t for t in service.list_todos() if t.github_url]
+
+    if not todos:
+        console.print("[dim]No todos linked to GitHub Issues.[/dim]")
+        return
+
+    print_todos(todos)
+    for t in todos:
+        console.print(f"  #{t.id} → [dim]{t.github_url}[/dim]")

devtodo/commands/list.py

@@ -0,0 +1,21 @@
+from typing import Optional
+import typer
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import print_todos
+
+app = typer.Typer(help="List todos.")
+
+
+@app.callback(invoke_without_command=True)
+def list_todos(
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="Filter by status (open, done, in_progress)"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="Filter by project"),
+    priority: Optional[str] = typer.Option(None, "--priority", "-p", help="Filter by priority"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Filter by tag"),
+) -> None:
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todos = service.list_todos(status=status, project=project, priority=priority, tag=tag)
+    print_todos(todos)

devtodo/commands/remove.py

@@ -0,0 +1,27 @@
+import typer
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error
+
+app = typer.Typer(help="Remove a todo.")
+
+
+@app.callback(invoke_without_command=True)
+def remove(
+    todo_id: int = typer.Argument(..., help="ID of the todo to remove"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+) -> None:
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.get(todo_id)
+        if not todo:
+            error(f"Todo #{todo_id} not found.")
+            raise typer.Exit(1)
+
+        if not force:
+            typer.confirm(f"Remove todo #{todo_id}: '{todo.title}'?", abort=True)
+
+        service.remove(todo_id)
+
+    success(f"Todo #{todo_id} removed.")

devtodo/db.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from sqlmodel import SQLModel, create_engine, Session
+
+DB_PATH = Path.home() / ".devtodo" / "devtodo.db"
+
+
+def get_engine():
+    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+    return create_engine(f"sqlite:///{DB_PATH}", connect_args={"check_same_thread": False})
+
+
+def init_db(engine=None):
+    from devtodo.models import Todo  # noqa: F401 – registers the table
+    if engine is None:
+        engine = get_engine()
+    SQLModel.metadata.create_all(engine)
+    _migrate(engine)
+    return engine
+
+
+def _migrate(engine) -> None:
+    """Add new columns to existing databases without Alembic."""
+    new_columns = [
+        ("github_url", "TEXT"),
+        ("github_issue_number", "INTEGER"),
+    ]
+    with engine.connect() as conn:
+        for col, col_type in new_columns:
+            try:
+                conn.exec_driver_sql(f"ALTER TABLE todo ADD COLUMN {col} {col_type}")
+                conn.commit()
+            except Exception:
+                pass  # column already exists
+
+
+def get_session(engine=None):
+    if engine is None:
+        engine = get_engine()
+    return Session(engine)

devtodo/github_client.py

@@ -0,0 +1,50 @@
+"""GitHub API client for devtodo."""
+
+import os
+from typing import Optional
+import httpx
+
+GITHUB_API = "https://api.github.com"
+
+
+def _get_token() -> Optional[str]:
+    return os.environ.get("GITHUB_TOKEN")
+
+
+def _headers() -> dict:
+    token = _get_token()
+    headers = {"Accept": "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def fetch_issues(repo: str, state: str = "open", limit: int = 50) -> list[dict]:
+    """Fetch issues from a GitHub repo. repo = 'owner/name'"""
+    url = f"{GITHUB_API}/repos/{repo}/issues"
+    params = {"state": state, "per_page": min(limit, 100), "page": 1}
+    resp = httpx.get(url, headers=_headers(), params=params, timeout=10)
+    resp.raise_for_status()
+    # filter out pull requests (GitHub returns PRs as issues too)
+    return [i for i in resp.json() if "pull_request" not in i]
+
+
+def create_issue(repo: str, title: str, body: Optional[str] = None, labels: list[str] | None = None) -> dict:
+    """Create a GitHub issue. Returns the created issue dict."""
+    url = f"{GITHUB_API}/repos/{repo}/issues"
+    payload: dict = {"title": title}
+    if body:
+        payload["body"] = body
+    if labels:
+        payload["labels"] = labels
+    resp = httpx.post(url, headers=_headers(), json=payload, timeout=10)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def close_issue(repo: str, issue_number: int) -> dict:
+    """Close a GitHub issue."""
+    url = f"{GITHUB_API}/repos/{repo}/issues/{issue_number}"
+    resp = httpx.patch(url, headers=_headers(), json={"state": "closed"}, timeout=10)
+    resp.raise_for_status()
+    return resp.json()

devtodo/main.py

@@ -0,0 +1,230 @@
+from typing import Optional
+import typer
+from rich.console import Console
+from datetime import date
+
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.utils.output import success, error, print_todos, print_todo
+from devtodo.utils.dates import parse_date
+
+app = typer.Typer(
+    name="devtodo",
+    help="[bold]devtodo[/bold] – a developer-focused CLI todo tool.",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+console = Console()
+
+
+@app.command("add")
+def cmd_add(
+    title: str = typer.Argument(..., help="Title of the todo"),
+    description: Optional[str] = typer.Option(None, "--desc", "-d", help="Optional description"),
+    priority: str = typer.Option("medium", "--priority", "-p", help="Priority: low, medium, high"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="Project name"),
+    tags: Optional[str] = typer.Option(None, "--tags", "-t", help="Comma-separated tags"),
+    due: Optional[str] = typer.Option(None, "--due", help="Due date (YYYY-MM-DD)"),
+) -> None:
+    """Add a new todo."""
+    if priority not in ("low", "medium", "high"):
+        error(f"Invalid priority '{priority}'. Use: low, medium, high")
+        raise typer.Exit(1)
+
+    due_date = None
+    if due:
+        try:
+            due_date = parse_date(due)
+        except ValueError as e:
+            error(str(e))
+            raise typer.Exit(1)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.add(
+            title=title,
+            description=description,
+            priority=priority,
+            project=project,
+            tags=tags,
+            due_date=due_date,
+        )
+    success(f"Added todo [bold]#{todo.id}[/bold]: {todo.title}")
+    print_todo(todo)
+
+
+@app.command("list")
+def cmd_list(
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="Filter: open, done, in_progress"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="Filter by project"),
+    priority: Optional[str] = typer.Option(None, "--priority", "-p", help="Filter by priority"),
+    tag: Optional[str] = typer.Option(None, "--tag", "-t", help="Filter by tag"),
+) -> None:
+    """List todos."""
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todos = service.list_todos(status=status, project=project, priority=priority, tag=tag)
+    print_todos(todos)
+
+
+@app.command("done")
+def cmd_done(
+    todo_id: int = typer.Argument(..., help="ID of the todo to mark as done"),
+) -> None:
+    """Mark a todo as done."""
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.mark_done(todo_id)
+
+    if todo:
+        success(f"Todo [bold]#{todo.id}[/bold] marked as done: {todo.title}")
+    else:
+        error(f"Todo #{todo_id} not found.")
+        raise typer.Exit(1)
+
+
+@app.command("remove")
+def cmd_remove(
+    todo_id: int = typer.Argument(..., help="ID of the todo to remove"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+) -> None:
+    """Remove a todo."""
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.get(todo_id)
+        if not todo:
+            error(f"Todo #{todo_id} not found.")
+            raise typer.Exit(1)
+
+        if not force:
+            typer.confirm(f"Remove todo #{todo_id}: '{todo.title}'?", abort=True)
+
+        service.remove(todo_id)
+
+    success(f"Todo #{todo_id} removed.")
+
+
+@app.command("edit")
+def cmd_edit(
+    todo_id: int = typer.Argument(..., help="ID of the todo to edit"),
+    title: Optional[str] = typer.Option(None, "--title", help="New title"),
+    description: Optional[str] = typer.Option(None, "--desc", "-d", help="New description"),
+    status: Optional[str] = typer.Option(None, "--status", "-s", help="New status: open, done, in_progress"),
+    priority: Optional[str] = typer.Option(None, "--priority", "-p", help="New priority: low, medium, high"),
+    project: Optional[str] = typer.Option(None, "--project", "-P", help="New project"),
+    tags: Optional[str] = typer.Option(None, "--tags", "-t", help="New tags (comma-separated)"),
+    due: Optional[str] = typer.Option(None, "--due", help="New due date (YYYY-MM-DD)"),
+) -> None:
+    """Edit a todo."""
+    if priority and priority not in ("low", "medium", "high"):
+        error(f"Invalid priority '{priority}'. Use: low, medium, high")
+        raise typer.Exit(1)
+    if status and status not in ("open", "done", "in_progress"):
+        error(f"Invalid status '{status}'. Use: open, done, in_progress")
+        raise typer.Exit(1)
+
+    due_date = None
+    if due:
+        try:
+            due_date = parse_date(due)
+        except ValueError as e:
+            error(str(e))
+            raise typer.Exit(1)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        todo = service.edit(
+            todo_id=todo_id,
+            title=title,
+            description=description,
+            status=status,
+            priority=priority,
+            project=project,
+            tags=tags,
+            due_date=due_date,
+        )
+
+    if todo:
+        success(f"Todo [bold]#{todo.id}[/bold] updated.")
+        print_todo(todo)
+    else:
+        error(f"Todo #{todo_id} not found.")
+        raise typer.Exit(1)
+
+
+@app.command("clear")
+def cmd_clear(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+) -> None:
+    """Delete ALL todos. Cannot be undone!"""
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        count = service.list_todos().__len__()
+
+    if count == 0:
+        console.print("[dim]No todos to delete.[/dim]")
+        raise typer.Exit()
+
+    if not force:
+        console.print(f"[bold red]⚠ This will delete ALL {count} todo(s). This cannot be undone![/bold red]")
+        typer.confirm("Are you sure?", abort=True)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        service.clear_all()
+
+    success(f"Deleted all {count} todo(s). Database is now empty.")
+
+
+def cmd_clear_completed(
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+) -> None:
+    """Remove all completed todos."""
+    if not force:
+        typer.confirm("Remove all completed todos?", abort=True)
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        count = service.clear_completed()
+
+    success(f"Removed {count} completed todo(s).")
+
+
+@app.command("start")
+def cmd_start() -> None:
+    """Launch the interactive TUI."""
+    from devtodo.tui import run_tui
+    run_tui()
+
+
+def cmd_today() -> None:
+    """Show high-priority todos and todos due today."""
+    today_date = date.today()
+
+    engine = init_db()
+    with get_session(engine) as session:
+        service = TodoService(session)
+        all_todos = service.list_todos(status="open")
+
+    focused = [
+        t for t in all_todos
+        if t.priority == "high"
+        or (t.due_date and t.due_date.date() <= today_date)
+    ]
+
+    console.print("[bold]📅 Today's focus[/bold]")
+    print_todos(focused)
+
+
+if __name__ == "__main__":
+    app()
+

devtodo/models.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+from typing import Optional
+from sqlmodel import SQLModel, Field
+
+
+class Todo(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    title: str
+    description: Optional[str] = None
+    status: str = "open"
+    priority: str = "medium"
+    project: Optional[str] = None
+    tags: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    due_date: Optional[datetime] = None
+    github_url: Optional[str] = None
+    github_issue_number: Optional[int] = None

devtodo/services/todo_service.py

@@ -0,0 +1,118 @@
+from datetime import datetime
+from typing import Optional
+from sqlmodel import select, Session
+
+from devtodo.models import Todo
+
+
+class TodoService:
+    def __init__(self, session: Session):
+        self.session = session
+
+    def add(
+        self,
+        title: str,
+        description: Optional[str] = None,
+        priority: str = "medium",
+        project: Optional[str] = None,
+        tags: Optional[str] = None,
+        due_date: Optional[datetime] = None,
+    ) -> Todo:
+        todo = Todo(
+            title=title,
+            description=description,
+            priority=priority,
+            project=project,
+            tags=tags,
+            due_date=due_date,
+        )
+        self.session.add(todo)
+        self.session.commit()
+        self.session.refresh(todo)
+        return todo
+
+    def list_todos(
+        self,
+        status: Optional[str] = None,
+        project: Optional[str] = None,
+        priority: Optional[str] = None,
+        tag: Optional[str] = None,
+    ) -> list[Todo]:
+        statement = select(Todo)
+        if status:
+            statement = statement.where(Todo.status == status)
+        if project:
+            statement = statement.where(Todo.project == project)
+        if priority:
+            statement = statement.where(Todo.priority == priority)
+        if tag:
+            statement = statement.where(Todo.tags.contains(tag))
+        statement = statement.order_by(Todo.id)
+        return list(self.session.exec(statement).all())
+
+    def get(self, todo_id: int) -> Optional[Todo]:
+        return self.session.get(Todo, todo_id)
+
+    def mark_done(self, todo_id: int) -> Optional[Todo]:
+        todo = self.get(todo_id)
+        if todo:
+            todo.status = "done"
+            self.session.add(todo)
+            self.session.commit()
+            self.session.refresh(todo)
+        return todo
+
+    def remove(self, todo_id: int) -> bool:
+        todo = self.get(todo_id)
+        if todo:
+            self.session.delete(todo)
+            self.session.commit()
+            return True
+        return False
+
+    def edit(
+        self,
+        todo_id: int,
+        title: Optional[str] = None,
+        description: Optional[str] = None,
+        status: Optional[str] = None,
+        priority: Optional[str] = None,
+        project: Optional[str] = None,
+        tags: Optional[str] = None,
+        due_date: Optional[datetime] = None,
+    ) -> Optional[Todo]:
+        todo = self.get(todo_id)
+        if not todo:
+            return None
+        if title is not None:
+            todo.title = title
+        if description is not None:
+            todo.description = description
+        if status is not None:
+            todo.status = status
+        if priority is not None:
+            todo.priority = priority
+        if project is not None:
+            todo.project = project
+        if tags is not None:
+            todo.tags = tags
+        if due_date is not None:
+            todo.due_date = due_date
+        self.session.add(todo)
+        self.session.commit()
+        self.session.refresh(todo)
+        return todo
+
+    def clear_completed(self) -> int:
+        todos = self.list_todos(status="done")
+        for todo in todos:
+            self.session.delete(todo)
+        self.session.commit()
+        return len(todos)
+
+    def clear_all(self) -> int:
+        todos = self.list_todos()
+        for todo in todos:
+            self.session.delete(todo)
+        self.session.commit()
+        return len(todos)

devtodo/tui.py

@@ -0,0 +1,238 @@
+from textual.app import App, ComposeResult
+from textual.widgets import (
+    Header, Footer, DataTable, Input, Label, Button, Static
+)
+from textual.containers import Vertical, Horizontal, Container
+from textual.screen import ModalScreen
+from textual.binding import Binding
+from textual import events
+from rich.text import Text
+
+from devtodo.db import init_db, get_session
+from devtodo.services.todo_service import TodoService
+from devtodo.models import Todo
+
+
+PRIORITY_STYLE = {
+    "high":   ("red",    "●"),
+    "medium": ("yellow", "●"),
+    "low":    ("green",  "●"),
+}
+
+STATUS_STYLE = {
+    "open":        ("cyan",      "○"),
+    "in_progress": ("blue",      "◑"),
+    "done":        ("dim green", "✔"),
+}
+
+
+class AddTodoModal(ModalScreen):
+    """Modal dialog to add a new todo."""
+
+    BINDINGS = [("escape", "dismiss", "Cancel")]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="modal-box"):
+            yield Label("➕ Add new todo", id="modal-title")
+            yield Input(placeholder="Title *", id="input-title")
+            yield Input(placeholder="Description (optional)", id="input-desc")
+            yield Input(placeholder="Priority: low / medium / high  (default: medium)", id="input-priority")
+            yield Input(placeholder="Project (optional)", id="input-project")
+            yield Input(placeholder="Tags, comma-separated (optional)", id="input-tags")
+            with Horizontal(id="modal-buttons"):
+                yield Button("Add", variant="success", id="btn-add")
+                yield Button("Cancel", variant="default", id="btn-cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-cancel":
+            self.dismiss(None)
+            return
+
+        title = self.query_one("#input-title", Input).value.strip()
+        if not title:
+            self.query_one("#input-title", Input).focus()
+            return
+
+        priority = self.query_one("#input-priority", Input).value.strip() or "medium"
+        if priority not in ("low", "medium", "high"):
+            priority = "medium"
+
+        self.dismiss({
+            "title":       title,
+            "description": self.query_one("#input-desc", Input).value.strip() or None,
+            "priority":    priority,
+            "project":     self.query_one("#input-project", Input).value.strip() or None,
+            "tags":        self.query_one("#input-tags", Input).value.strip() or None,
+        })
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        # pressing Enter in any field triggers add
+        self.query_one("#btn-add", Button).press()
+
+
+class DevtodoTUI(App):
+    """devtodo – Terminal UI"""
+
+    CSS = """
+    Screen {
+        background: $surface;
+    }
+
+    #main-table {
+        height: 1fr;
+    }
+
+    #status-bar {
+        height: 1;
+        padding: 0 1;
+        background: $panel;
+        color: $text-muted;
+    }
+
+    /* Modal */
+    AddTodoModal {
+        align: center middle;
+    }
+
+    #modal-box {
+        width: 60;
+        height: auto;
+        border: round $primary;
+        background: $surface;
+        padding: 1 2;
+    }
+
+    #modal-box Input {
+        margin-bottom: 1;
+    }
+
+    #modal-title {
+        text-style: bold;
+        color: $primary;
+        margin-bottom: 1;
+    }
+
+    #modal-buttons {
+        height: auto;
+        margin-top: 1;
+    }
+
+    #btn-add {
+        margin-right: 2;
+    }
+    """
+
+    BINDINGS = [
+        Binding("a",      "add_todo",      "Add",      show=True),
+        Binding("d",      "mark_done",     "Done",     show=True),
+        Binding("delete", "remove_todo",   "Remove",   show=True),
+        Binding("r",      "refresh",       "Refresh",  show=True),
+        Binding("q",      "quit",          "Quit",     show=True),
+        Binding("f",      "filter_open",   "Open only",show=True),
+        Binding("F",      "filter_all",    "All",      show=True),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.engine = init_db()
+        self._filter_status = None  # None = all
+        self._todos: list[Todo] = []
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=True)
+        yield DataTable(id="main-table", cursor_type="row", zebra_stripes=True)
+        yield Static("", id="status-bar")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.title = "devtodo"
+        self.sub_title = "press [a] add · [d] done · [del] remove · [q] quit"
+        table = self.query_one(DataTable)
+        table.add_columns("ID", "●", "Title", "Status", "Priority", "Project", "Tags")
+        self._load_todos()
+
+    def _load_todos(self) -> None:
+        with get_session(self.engine) as session:
+            service = TodoService(session)
+            self._todos = service.list_todos(status=self._filter_status)
+
+        table = self.query_one(DataTable)
+        table.clear()
+
+        for todo in self._todos:
+            p_color, p_dot = PRIORITY_STYLE.get(todo.priority, ("white", "●"))
+            s_color, s_icon = STATUS_STYLE.get(todo.status, ("white", "?"))
+
+            table.add_row(
+                Text(str(todo.id), style="dim"),
+                Text(p_dot, style=p_color),
+                Text(todo.title),
+                Text(f"{s_icon} {todo.status}", style=s_color),
+                Text(todo.priority, style=p_color),
+                Text(todo.project or "", style="blue"),
+                Text(todo.tags or "", style="magenta"),
+                key=str(todo.id),
+            )
+
+        self._update_status_bar()
+
+    def _update_status_bar(self) -> None:
+        total = len(self._todos)
+        done  = sum(1 for t in self._todos if t.status == "done")
+        open_ = sum(1 for t in self._todos if t.status == "open")
+        filt  = f"  [filter: open only]" if self._filter_status else ""
+        self.query_one("#status-bar", Static).update(
+            f" {total} todos · {open_} open · {done} done{filt}"
+        )
+
+    def _current_todo(self) -> Todo | None:
+        table = self.query_one(DataTable)
+        if table.cursor_row < 0 or not self._todos:
+            return None
+        try:
+            return self._todos[table.cursor_row]
+        except IndexError:
+            return None
+
+    # ── Actions ─────────────────────────────────────────────────────────────
+
+    def action_add_todo(self) -> None:
+        def handle_result(data: dict | None) -> None:
+            if not data:
+                return
+            with get_session(self.engine) as session:
+                TodoService(session).add(**data)
+            self._load_todos()
+
+        self.push_screen(AddTodoModal(), handle_result)
+
+    def action_mark_done(self) -> None:
+        todo = self._current_todo()
+        if not todo:
+            return
+        with get_session(self.engine) as session:
+            TodoService(session).mark_done(todo.id)
+        self._load_todos()
+
+    def action_remove_todo(self) -> None:
+        todo = self._current_todo()
+        if not todo:
+            return
+        with get_session(self.engine) as session:
+            TodoService(session).remove(todo.id)
+        self._load_todos()
+
+    def action_refresh(self) -> None:
+        self._load_todos()
+
+    def action_filter_open(self) -> None:
+        self._filter_status = "open"
+        self._load_todos()
+
+    def action_filter_all(self) -> None:
+        self._filter_status = None
+        self._load_todos()
+
+
+def run_tui() -> None:
+    DevtodoTUI().run()

devtodo/utils/dates.py

@@ -0,0 +1,13 @@
+from datetime import datetime
+from typing import Optional
+
+
+def parse_date(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    for fmt in ("%Y-%m-%d", "%d.%m.%Y", "%d/%m/%Y"):
+        try:
+            return datetime.strptime(value, fmt)
+        except ValueError:
+            continue
+    raise ValueError(f"Cannot parse date: '{value}'. Use YYYY-MM-DD format.")

devtodo/utils/output.py

@@ -0,0 +1,80 @@
+from datetime import datetime
+from rich.console import Console
+from rich.table import Table
+from rich import box
+from devtodo.models import Todo
+
+console = Console()
+
+PRIORITY_COLORS = {
+    "high": "red",
+    "medium": "yellow",
+    "low": "green",
+}
+
+STATUS_COLORS = {
+    "open": "cyan",
+    "done": "dim green",
+    "in_progress": "blue",
+}
+
+
+def _priority_badge(priority: str) -> str:
+    color = PRIORITY_COLORS.get(priority, "white")
+    return f"[{color}]{priority}[/{color}]"
+
+
+def _status_badge(status: str) -> str:
+    color = STATUS_COLORS.get(status, "white")
+    return f"[{color}]{status}[/{color}]"
+
+
+def print_todos(todos: list[Todo]) -> None:
+    if not todos:
+        console.print("[dim]No todos found.[/dim]")
+        return
+
+    table = Table(box=box.ROUNDED, show_header=True, header_style="bold magenta")
+    table.add_column("ID", style="bold", justify="right", width=4)
+    table.add_column("Title", min_width=20)
+    table.add_column("Status", width=12)
+    table.add_column("Priority", width=10)
+    table.add_column("Project", width=12)
+    table.add_column("Tags", width=14)
+    table.add_column("Due", width=11)
+
+    for todo in todos:
+        due = todo.due_date.strftime("%Y-%m-%d") if todo.due_date else ""
+        table.add_row(
+            str(todo.id),
+            todo.title,
+            _status_badge(todo.status),
+            _priority_badge(todo.priority),
+            todo.project or "",
+            todo.tags or "",
+            due,
+        )
+
+    console.print(table)
+
+
+def print_todo(todo: Todo) -> None:
+    console.print(f"[bold]#{todo.id}[/bold] {todo.title}")
+    if todo.description:
+        console.print(f"  [dim]{todo.description}[/dim]")
+    console.print(f"  Status:   {_status_badge(todo.status)}")
+    console.print(f"  Priority: {_priority_badge(todo.priority)}")
+    if todo.project:
+        console.print(f"  Project:  [blue]{todo.project}[/blue]")
+    if todo.tags:
+        console.print(f"  Tags:     [magenta]{todo.tags}[/magenta]")
+    if todo.due_date:
+        console.print(f"  Due:      {todo.due_date.strftime('%Y-%m-%d')}")
+
+
+def success(msg: str) -> None:
+    console.print(f"[bold green]✔[/bold green] {msg}")
+
+
+def error(msg: str) -> None:
+    console.print(f"[bold red]✘[/bold red] {msg}")

devtodo-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: devtodo
+Version: 0.1.0
+Summary: A developer-focused CLI todo tool
+Author: jakok
+License: MIT
+Project-URL: Homepage, https://github.com/jakok/devtodo
+Project-URL: Repository, https://github.com/jakok/devtodo
+Keywords: todo,cli,developer,terminal,productivity
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: Console
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: sqlmodel>=0.0.19
+Requires-Dist: textual>=0.80
+Requires-Dist: httpx>=0.27
+
+# devtodo 📝
+
+A fast, developer-focused CLI todo tool with a beautiful TUI.
+
+## Install
+
+```bash
+pipx install devtodo
+```
+
+> Requires Python 3.12+. Install `pipx` first: `pip install pipx`
+
+## Usage
+
+```bash
+dt add "Fix login bug" --priority high --project backend
+dt list
+dt list --project backend
+dt done 1
+dt edit 2 --priority low --tags "bug,ui"
+dt remove 3
+dt clear-completed
+dt today         # high priority + due today
+dt start         # interactive TUI
+```
+
+## GitHub Integration
+
+```bash
+export GITHUB_TOKEN=ghp_yourtoken
+
+dt github sync --repo owner/repo     # import open issues as todos
+dt github push 5 --repo owner/repo   # push todo #5 as a GitHub issue
+dt github list                        # show todos linked to GitHub
+```
+
+## Keyboard shortcuts (TUI)
+
+| Key | Action |
+|-----|--------|
+| `a` | Add todo |
+| `e` | Edit selected |
+| `d` | Mark done |
+| `Del` | Remove |
+| `f` / `F` | Filter open / show all |
+| `q` | Quit |
+
+## Data
+
+Todos are stored locally at `~/.devtodo/devtodo.db` (SQLite).

devtodo-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+devtodo/__init__.py,sha256=1Oeb1VkZTRqRrNw2Xp78L41PI3boM_O-oxv3uNUzFhk,76
+devtodo/db.py,sha256=i0bWvXfDx09vYhIMHiZd6e2IhBBAW5e_WWwXvprY0a0,1128
+devtodo/github_client.py,sha256=TBs4v_GhDwoYuSbzeu0Lxut_oc8BMzWc5uLF5uPkPJ8,1695
+devtodo/main.py,sha256=tbIsoJ3xgXSEM2aKIh-p0QHmUMJxiRJ3SWjJZHfzpD4,7421
+devtodo/models.py,sha256=CTqVhFNncpfdj5auG4WmEjdqjE3JkjXIAe-mY9V0-ws,554
+devtodo/tui.py,sha256=cHII3LQKOg8TDNYL7oE4corlpt1hOQk9k4WOCJHrfOE,7599
+devtodo/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devtodo/commands/add.py,sha256=UVTS7t2yvivr5dAZ5-67Zj7_P4EyavTq6dz2x8Wromo,1605
+devtodo/commands/done.py,sha256=qpv-LlDw2uHW2safeFPXKZ9L5fzahmQ653nk-Dl1L4c,672
+devtodo/commands/edit.py,sha256=10ehEKJkTk1eibZItLYYzonTlU4x6EKrfza1ICPI2Bs,2141
+devtodo/commands/github_cmd.py,sha256=zUbd6Ff3zP_0z_7uN5omoXuFZBvn-XEiXyf8hYPUkQg,3888
+devtodo/commands/list.py,sha256=pFVjZwJ7z6vDSVL59CYf6Cpgrxl0Cuaxd7CXwTyl2fY,906
+devtodo/commands/remove.py,sha256=t47HFEQyTcERS5ks1TiXCMsYwnQL1DQNAqiYP5Eq4oo,845
+devtodo/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devtodo/services/todo_service.py,sha256=my17-ax2IfEEd0QBOVpH7Q_x2cHJerHzIGMxfN6stR4,3478
+devtodo/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devtodo/utils/dates.py,sha256=CYfhGHASwgXm2Qxp8o-VOwAEAeUcERS0z9wBgMvY-Bk,399
+devtodo/utils/output.py,sha256=zfjN4zZ05iqSpv-4ZgWH6Mp8dmhOS7Cj72Sx-FyxdcA,2267
+devtodo-0.1.0.dist-info/METADATA,sha256=v8hdfsaVfpOmyrpnBsjIufm1yT9WyzddPpXqEZcsEzw,1670
+devtodo-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+devtodo-0.1.0.dist-info/entry_points.txt,sha256=Zph7i34gUVm4WIvG3IybJupznzQXLYQjj9QltEXDmRw,67
+devtodo-0.1.0.dist-info/top_level.txt,sha256=iedrhl7lx7pyAMlH0aM03NALgkjAAGHPZRAyXwpcdzc,8
+devtodo-0.1.0.dist-info/RECORD,,

devtodo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devtodo-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+devtodo = devtodo.main:app
+dt = devtodo.main:app

devtodo-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devtodo