cli-todo-jd 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

cli_todo_jd/main.py

@@ -1,10 +1,8 @@
 from pathlib import Path
-import questionary
 from rich.console import Console
 from rich.table import Table
 from rich.padding import Padding
 import sqlite3
-
 from cli_todo_jd.storage.schema import ensure_schema
 from cli_todo_jd.storage.migrate import migrate_from_json
 
@@ -14,17 +12,19 @@ def main():
 
 
 class TodoApp:
-    """
-    A simple command-line todo application.
-    """
+    """A simple command-line todo application."""
 
     def __init__(self, file_path_to_db="./.todo_list.db"):
-        self.todos = []
-        self.status = []
+        self.todo_ids: list[int] = []
+        self.todos: list[str] = []
+        self.status: list[int] = []
         self.file_path_to_db = Path(file_path_to_db)
         self._check_and_load_todos(self.file_path_to_db)
         self._console = Console()
 
+    def reload_todos(self) -> None:
+        self._check_and_load_todos(self.file_path_to_db)
+
     def add_todo(self, item: str) -> None:
         item = (item or "").strip()
         if not item:
@@ -43,7 +43,6 @@ class TodoApp:
             return
 
         print(f'Added todo: "{item}"')
-        self._check_and_load_todos(self.file_path_to_db)
 
     def list_todos(self, *, show: str = "open") -> None:
         """List todos.
@@ -61,35 +60,52 @@ class TodoApp:
         # Always read fresh so output reflects the DB
         self._check_and_load_todos(self.file_path_to_db)
         if not self.todos:
-            print("No todos found.")
+            print("Your todo list is empty! Start adding some with 'todo add <task>'")
             return
 
         if show == "all":
             self._table_print(title="Todos")
             return
 
-        # Filter in-memory to keep this change minimal. (You can later filter in SQL.)
+        # Filter in-memory to keep this change minimal.
+        filtered_ids: list[int] = []
         filtered_todos: list[str] = []
         filtered_status: list[int] = []
-        for todo, done in zip(self.todos, self.status, strict=False):
+        for todo_id, todo, done in zip(
+            self.todo_ids, self.todos, self.status, strict=False
+        ):
             if show == "open" and not done:
+                filtered_ids.append(todo_id)
                 filtered_todos.append(todo)
                 filtered_status.append(done)
             elif show == "done" and done:
+                filtered_ids.append(todo_id)
                 filtered_todos.append(todo)
                 filtered_status.append(done)
 
         if not filtered_todos:
-            print("No todos found.")
+            print(f"No todos found when filtering on {show}.")
             return
 
-        original_todos, original_status = self.todos, self.status
+        original_ids, original_todos, original_status = (
+            self.todo_ids,
+            self.todos,
+            self.status,
+        )
         try:
-            self.todos, self.status = filtered_todos, filtered_status
+            self.todo_ids, self.todos, self.status = (
+                filtered_ids,
+                filtered_todos,
+                filtered_status,
+            )
             title = "Open todos" if show == "open" else "Completed todos"
             self._table_print(title=title)
         finally:
-            self.todos, self.status = original_todos, original_status
+            self.todo_ids, self.todos, self.status = (
+                original_ids,
+                original_todos,
+                original_status,
+            )
 
     def remove_todo(self, index: int) -> None:
         # Maintain current UX: index refers to the displayed (1-based) ordering.
@@ -119,7 +135,6 @@ class TodoApp:
             return
 
         print(f'Removed todo: "{removed_item}"')
-        self._check_and_load_todos(self.file_path_to_db)
 
     def clear_all(self) -> None:
         try:
@@ -127,11 +142,16 @@ class TodoApp:
                 ensure_schema(conn)
                 with conn:
                     conn.execute("DELETE FROM todos;")
+                    # Reset AUTOINCREMENT counter so ids start from 1 again.
+                    # This is SQLite-specific and only applies to tables created with AUTOINCREMENT.
+                    conn.execute("DELETE FROM sqlite_sequence WHERE name = 'todos';")
         except sqlite3.Error as e:
             print(f"Error: Failed to clear todos. ({e})")
             return
 
+        self.todo_ids = []
         self.todos = []
+        self.status = []
         print("Cleared all todos.")
 
     def _check_and_load_todos(self, file_path: Path) -> None:
@@ -151,12 +171,13 @@ class TodoApp:
                     "SELECT id, item, done, created_at, done_at FROM todos ORDER BY id"
                 ).fetchall()
 
-                # In-memory list is used by the interactive menu for selection.
-                # Keep it as a simple list[str] for now.
+                # In-memory lists are used by the interactive menu.
+                self.todo_ids = [int(row[0]) for row in rows]
                 self.todos = [row[1] for row in rows]
                 self.status = [row[2] for row in rows]
         except sqlite3.Error as e:
             print(f"Warning: Failed to load existing todos. Starting fresh. ({e})")
+            self.todo_ids = []
             self.todos = []
             self.status = []
 
@@ -172,11 +193,13 @@ class TodoApp:
         for col in columns:
             table.add_column(str(col))
 
-        for idx, todo in enumerate(self.todos, start=1):
+        for todo_id, todo, done in zip(
+            self.todo_ids, self.todos, self.status, strict=False
+        ):
             table.add_row(
-                f"{idx}.",
+                str(todo_id),
                 str(todo),
-                "[green]✔[/green]" if self.status[idx - 1] else "[red]✖[/red]",
+                "[green]✔[/green]" if done else "[red]✖[/red]",
             )
 
         self._console.print(Padding(table, (2, 2)))
@@ -211,7 +234,6 @@ class TodoApp:
             return
 
         print(f'Marked todo as not done: "{item}"')
-        self._check_and_load_todos(self.file_path_to_db)
 
     def mark_as_done(self, index: int) -> None:
         self._check_and_load_todos(self.file_path_to_db)
@@ -243,7 +265,6 @@ class TodoApp:
             return
 
         print(f'Marked todo as done: "{item}"')
-        self._check_and_load_todos(self.file_path_to_db)
 
     def update_done_data(self, index, done_value, done_at_value, todo_id):
         text_done_value = "done" if done_value == 1 else "not done"
@@ -310,171 +331,101 @@ class TodoApp:
             return
 
         print(f'Edited todo: "{old_item}" to "{new_text}"')
-        self._check_and_load_todos(self.file_path_to_db)
 
+    def remove_by_id(self, todo_id: int) -> None:
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                row = conn.execute(
+                    "SELECT id, item FROM todos WHERE id = ?;",
+                    (todo_id,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo id.")
+                    return
+
+                _, removed_item = row
+                with conn:
+                    conn.execute("DELETE FROM todos WHERE id = ?;", (todo_id,))
+        except sqlite3.Error as e:
+            print(f"Error: Failed to remove todo. ({e})")
+            return
+
+        print(f'Removed todo: "{removed_item}"')
+
+    def mark_done_by_id(self, todo_id: int) -> None:
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                row = conn.execute(
+                    "SELECT id, item FROM todos WHERE id = ?;",
+                    (todo_id,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo id.")
+                    return
+
+                _, item = row
+                with conn:
+                    conn.execute(
+                        "UPDATE todos SET done = 1, done_at = datetime('now') WHERE id = ?;",
+                        (todo_id,),
+                    )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to mark todo as done. ({e})")
+            return
 
-def create_list(file_path_to_db: str = "./.todo_list.db"):
-    """
-    Create a new todo list.
-
-    Parameters
-    ----------
-    file_path_to_db : str, optional
-        The file path to the JSON file for storing todos, by default "./.todo_list.db"
-
-    Returns
-    -------
-    TodoApp
-        An instance of the TodoApp class.
-    """
-    app = TodoApp(file_path_to_db=file_path_to_db)
-    return app
-
-
-def add_item_to_list(item: str, filepath: str):
-    """
-    Add a new item to the todo list.
-
-    Parameters
-    ----------
-    item : str
-        The todo item to add.
-    filepath : str
-        The file path to the JSON file for storing todos.
-    """
-    app = create_list(file_path_to_db=filepath)
-    app.add_todo(item)
-    app.list_todos()
-
-
-def list_items_on_list(filepath: str, show: str = "open"):
-    """List items in the todo list.
-
-    Parameters
-    ----------
-    filepath:
-        The SQLite database path.
-    show:
-        "open" (default), "done", or "all".
-    """
-    app = create_list(file_path_to_db=filepath)
-    app.list_todos(show=show)
-
-
-def remove_item_from_list(index: int, filepath: str):
-    """
-    remove an item from the todo list using index
-
-    Parameters
-    ----------
-    index : int
-        The index of the todo item to remove.
-    filepath : str
-        The file path to the JSON file for storing todos.
-    """
-    app = create_list(file_path_to_db=filepath)
-    app.remove_todo(index)
-    app.list_todos()
-
-
-def clear_list_of_items(filepath: str):
-    """
-    Clear all items from the todo list.
-
-    Parameters
-    ----------
-    filepath : str
-        The file path to the JSON file for storing todos.
-    """
-    app = create_list(file_path_to_db=filepath)
-    app.clear_all()
-
-
-def mark_item_as_done(index: int, filepath: str):
-    app = create_list(file_path_to_db=filepath)
-    app.mark_as_done(index)
-
-
-def mark_item_as_not_done(index: int, filepath: str):
-    app = create_list(file_path_to_db=filepath)
-    app.mark_as_not_done(index)
-
-
-def cli_menu(filepath="./.todo_list.db"):
-    """
-    Display the command-line interface menu for the todo list.
-
-    Parameters
-    ----------
-    filepath : str, optional
-        The file path to the JSON file for storing todos, by default "./.todo_list.db"
-    """
-    app = create_list(file_path_to_db=filepath)
-    while True:
-        action = questionary.select(
-            "What would you like to do?",
-            choices=[
-                "Add todo",
-                "List todos",
-                "Update todo status",
-                "Remove todo",
-                "Clear all todos",
-                "Exit",
-            ],
-        ).ask()
-
-        if action == "Add todo":
-            item = questionary.text("Enter the todo item:").ask()
-            app.add_todo(item)
-        elif action == "List todos":
-            app.list_todos(show="all")
-        elif action == "Update todo status":
-            if not app.todos:
-                print("No todos to update.")
-                continue
-            todo_choice = questionary.select(
-                "Select the todo to update:",
-                choices=["<Back>"] + app.todos,
-            ).ask()
-
-            if todo_choice == "<Back>" or todo_choice is None:
-                continue
-
-            todo_index = app.todos.index(todo_choice) + 1
-            status_choice = questionary.select(
-                "Mark as:",
-                choices=["Done", "Not Done", "<Back>"],
-            ).ask()
-
-            if status_choice == "<Back>" or status_choice is None:
-                continue
-            elif status_choice == "Done":
-                app.mark_as_done(todo_index)
-            elif status_choice == "Not Done":
-                app.mark_as_not_done(todo_index)
-            app.list_todos(show="all")
-        elif action == "Remove todo":
-            if not app.todos:
-                print("No todos to remove.")
-                continue
-            todo_choice = questionary.select(
-                "Select the todo to remove:",
-                choices=["<Back>"] + app.todos,
-            ).ask()
-
-            if todo_choice == "<Back>" or todo_choice is None:
-                continue
-
-            todo_to_remove = app.todos.index(todo_choice) + 1
-            app.remove_todo(todo_to_remove)
-
-        elif action == "Clear all todos":
-            confirm = questionary.confirm(
-                "Are you sure you want to clear all todos?"
-            ).ask()
-            if confirm:
-                app.clear_all()
-        elif action == "Exit":
-            break
-        else:
-            break
+        print(f'Marked todo as done: "{item}"')
+
+    def mark_not_done_by_id(self, todo_id: int) -> None:
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                row = conn.execute(
+                    "SELECT id, item FROM todos WHERE id = ?;",
+                    (todo_id,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo id.")
+                    return
+
+                _, item = row
+                with conn:
+                    conn.execute(
+                        "UPDATE todos SET done = 0, done_at = NULL WHERE id = ?;",
+                        (todo_id,),
+                    )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to mark todo as not done. ({e})")
+            return
+
+        print(f'Marked todo as not done: "{item}"')
+
+    def edit_by_id(self, todo_id: int, new_text: str) -> None:
+        new_text = (new_text or "").strip()
+        if not new_text:
+            print("Error: Todo item cannot be empty.")
+            return
+
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                row = conn.execute(
+                    "SELECT id, item FROM todos WHERE id = ?;",
+                    (todo_id,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo id.")
+                    return
+
+                _, old_item = row
+                with conn:
+                    conn.execute(
+                        "UPDATE todos SET item = ? WHERE id = ?;",
+                        (new_text, todo_id),
+                    )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to edit todo. ({e})")
+            return
+
+        print(f'Edited todo: "{old_item}" to "{new_text}"')

cli_todo_jd/web/app.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from flask import Flask, redirect, render_template, request, url_for
+
+from cli_todo_jd.storage.schema import ensure_schema
+from cli_todo_jd.storage.migrate import migrate_from_json
+
+
+def create_app(db_path: Path) -> Flask:
+    app = Flask(__name__)
+    app.config["TODO_DB_PATH"] = str(db_path)
+
+    def _connect() -> sqlite3.Connection:
+        conn = sqlite3.connect(db_path)
+        conn.row_factory = sqlite3.Row
+        ensure_schema(conn)
+        return conn
+
+    # Optional one-time JSON migration (mirrors CLI behavior)
+    json_path = db_path.with_suffix(".json")
+    if json_path.exists() and db_path.suffix == ".db":
+        migrate_from_json(json_path=json_path, db_path=db_path, backup=True)
+
+    @app.get("/")
+    def index():
+        show = request.args.get("show", "open")
+        if show not in {"open", "done", "all"}:
+            show = "open"
+
+        with _connect() as conn:
+            if show == "open":
+                todos = conn.execute(
+                    "SELECT id, item, done, created_at, done_at FROM todos WHERE done = ? ORDER BY id DESC",
+                    (0,),
+                ).fetchall()
+            elif show == "done":
+                todos = conn.execute(
+                    "SELECT id, item, done, created_at, done_at FROM todos WHERE done = ? ORDER BY id DESC",
+                    (1,),
+                ).fetchall()
+            else:
+                todos = conn.execute(
+                    "SELECT id, item, done, created_at, done_at FROM todos ORDER BY id DESC"
+                ).fetchall()
+
+        return render_template("index.html", todos=todos, show=show)
+
+    @app.post("/add")
+    def add():
+        item = (request.form.get("item") or "").strip()
+        if item:
+            with _connect() as conn:
+                with conn:
+                    conn.execute("INSERT INTO todos(item, done) VALUES (?, 0)", (item,))
+        return redirect(url_for("index"))
+
+    @app.post("/toggle/<int:todo_id>")
+    def toggle(todo_id: int):
+        with _connect() as conn:
+            row = conn.execute(
+                "SELECT done FROM todos WHERE id = ?", (todo_id,)
+            ).fetchone()
+            if row is not None:
+                new_done = 0 if row["done"] else 1
+                with conn:
+                    if new_done:
+                        conn.execute(
+                            "UPDATE todos SET done = 1, done_at = datetime('now') WHERE id = ?",
+                            (todo_id,),
+                        )
+                    else:
+                        conn.execute(
+                            "UPDATE todos SET done = 0, done_at = NULL WHERE id = ?",
+                            (todo_id,),
+                        )
+        return redirect(url_for("index"))
+
+    @app.post("/delete/<int:todo_id>")
+    def delete(todo_id: int):
+        with _connect() as conn:
+            with conn:
+                conn.execute("DELETE FROM todos WHERE id = ?", (todo_id,))
+        return redirect(url_for("index"))
+
+    @app.post("/clear")
+    def clear():
+        if request.form.get("confirm") == "yes":
+            with _connect() as conn:
+                with conn:
+                    conn.execute("DELETE FROM todos")
+        return redirect(url_for("index"))
+
+    return app
+
+
+def run_web(
+    db_path: Path, host: str = "127.0.0.1", port: int = 8000, debug: bool = False
+) -> None:
+    db_path = Path(db_path)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    app = create_app(db_path)
+    app.run(host=host, port=port, debug=debug)