cli-todo-jd 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

cli_todo_jd/cli_entry.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from argparse import ArgumentParser
 from cli_todo_jd.main import (
     add_item_to_list,
@@ -5,75 +7,98 @@ from cli_todo_jd.main import (
     list_items_on_list,
     clear_list_of_items,
     cli_menu,
+    mark_item_as_done,
+    mark_item_as_not_done,
 )
+from pathlib import Path
+import typer
 
+app = typer.Typer(help="A tiny todo CLI built with Typer.")
 
-def parser_optional_args(parser: ArgumentParser):
-    parser.add_argument(
-        "-f",
+
+@app.command()
+def add(
+    text: list[str] = typer.Argument(..., help="Todo item text (no quotes needed)."),
+    filepath: Path = typer.Option(
+        Path(".todo_list.db"),
         "--filepath",
-        help="Path to the file to process",
-        default="./.todo_list.json",
-    )
+        "-f",
+        help="Path to the JSON file used for storage.",
+    ),
+) -> None:
+    full_text = " ".join(text).strip()
+    if not full_text:
+        raise typer.BadParameter("Todo item text cannot be empty.")
 
+    add_item_to_list(full_text, filepath)
+    typer.echo(f"Added: {full_text}")
 
-def add_item():
-    parser = ArgumentParser(description="Add a todo item")
-    parser.add_argument(
-        "item",
-        nargs="+",
-        help="The todo item to add (use quotes or multiple words)",
-    )
-    parser_optional_args(parser)
 
-    args = parser.parse_args()
-    args.item = " ".join(args.item)
-    add_item_to_list(args.item, args.filepath)
+@app.command(name="list")
+def list_(
+    filepath: Path = typer.Option(Path(".todo_list.db"), "--filepath", "-f"),
+) -> None:
+    list_items_on_list(filepath)
 
 
-def remove_item():
-    parser = ArgumentParser(description="Remove a todo item by index")
-    parser.add_argument(
-        "index",
-        type=int,
-        help="The index of the todo item to remove (1-based)",
-    )
-    parser_optional_args(parser)
+@app.command()
+def remove(
+    index: int = typer.Argument(..., help="1-based index of item to remove."),
+    filepath: Path = typer.Option(Path(".todo_list.db"), "--filepath", "-f"),
+) -> None:
+    remove_item_from_list(index, filepath)
 
-    args = parser.parse_args()
-    remove_item_from_list(args.index, args.filepath)
 
+@app.command()
+def clear(
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+    filepath: Path = typer.Option(Path(".todo_list.db"), "--filepath", "-f"),
+) -> None:
+    if not yes and not typer.confirm(f"Clear all todos in {filepath}?"):
+        typer.echo("Cancelled.")
+        raise typer.Exit(code=1)
 
-def list_items():
-    parser = ArgumentParser(description="List all todo items")
-    parser_optional_args(parser)
+    clear_list_of_items(filepath)
 
-    args = parser.parse_args()
-    list_items_on_list(args.filepath)
 
+@app.command(name="menu")
+def menu_(
+    filepath: Path = typer.Option(
+        Path(".todo_list.db"),
+        "--filepath",
+        "-f",
+        help="Path to the JSON file used for storage.",
+    ),
+) -> None:
+    cli_menu(filepath)
+    typer.echo("Exited menu.")
 
-def clear_list():
-    parser = ArgumentParser(description="Clear all todo items")
-    parser.add_argument(
-        "-y",
-        "--yes",
-        action="store_true",
-        help="Do not prompt for confirmation",
-    )
-    parser_optional_args(parser)
 
-    args = parser.parse_args()
-    list_items_on_list(args.filepath)
+@app.command()
+def done(
+    index: int = typer.Argument(..., help="1-based index of item to mark as done."),
+    filepath: Path = typer.Option(Path(".todo_list.db"), "--filepath", "-f"),
+) -> None:
+    mark_item_as_done(index, filepath)
+    list_(filepath=filepath)
 
-    if not args.yes:
-        resp = (
-            input(f"Clear all todo items in '{args.filepath}'? [y/n]: ").strip().lower()
-        )
-        if resp not in ("y", "yes"):
-            return
 
-    # assuming remove_item_from_list(0/None) clears; otherwise replace with your clear implementation
-    clear_list_of_items(args.filepath)
+@app.command()
+def not_done(
+    index: int = typer.Argument(..., help="1-based index of item to mark as done."),
+    filepath: Path = typer.Option(Path(".todo_list.db"), "--filepath", "-f"),
+) -> None:
+    mark_item_as_not_done(index, filepath)
+    list_(filepath=filepath)
+
+
+def parser_optional_args(parser: ArgumentParser):
+    parser.add_argument(
+        "-f",
+        "--filepath",
+        help="Path to the file to process",
+        default="./.todo_list.db",
+    )
 
 
 def todo_menu():
@@ -82,3 +107,7 @@ def todo_menu():
     args = parser.parse_args()
 
     cli_menu(filepath=args.filepath)
+
+
+if __name__ == "__main__":
+    app()

cli_todo_jd/main.py

@@ -1,9 +1,12 @@
-import json
 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
 
 
 def main():
@@ -15,43 +18,109 @@ class TodoApp:
     A simple command-line todo application.
     """
 
-    def __init__(self, file_path_to_json="./.todo_list.json"):
+    def __init__(self, file_path_to_db="./.todo_list.db"):
         self.todos = []
-        self.file_path_to_json = Path(file_path_to_json)
-        self._check_and_load_todos(self.file_path_to_json)
+        self.status = []
+        self.file_path_to_db = Path(file_path_to_db)
+        self._check_and_load_todos(self.file_path_to_db)
         self._console = Console()
 
-    def add_todo(self, item):
-        self.todos.append(item)
+    def add_todo(self, item: str) -> None:
+        item = (item or "").strip()
+        if not item:
+            print("Error: Todo item cannot be empty.")
+            return
+
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                with conn:
+                    conn.execute(
+                        "INSERT INTO todos(item, done) VALUES (?, 0);", (item,)
+                    )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to add todo. ({e})")
+            return
+
         print(f'Added todo: "{item}"')
+        self._check_and_load_todos(self.file_path_to_db)
 
-    def list_todos(self):
+    def list_todos(self) -> None:
+        # 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.")
             return
         self._table_print()
 
-    def remove_todo(self, index):
-        try:
-            removed = self.todos.pop(index - 1)
-            print(f'Removed todo: "{removed}"')
-        except IndexError:
+    def remove_todo(self, index: int) -> None:
+        # Maintain current UX: index refers to the displayed (1-based) ordering.
+        self._check_and_load_todos(self.file_path_to_db)
+
+        if index < 1 or index > len(self.todos):
             print("Error: Invalid todo index.")
+            return
+
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+
+                row = conn.execute(
+                    "SELECT id, item FROM todos ORDER BY id LIMIT 1 OFFSET ?;",
+                    (index - 1,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo index.")
+                    return
+
+                todo_id, 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}"')
+        self._check_and_load_todos(self.file_path_to_db)
+
+    def clear_all(self) -> None:
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+                with conn:
+                    conn.execute("DELETE FROM todos;")
+        except sqlite3.Error as e:
+            print(f"Error: Failed to clear todos. ({e})")
+            return
+
+        self.todos = []
+        print("Cleared all todos.")
 
-    def _check_and_load_todos(self, file_path):
-        if file_path.exists():
-            try:
-                with file_path.open("r", encoding="utf-8") as f:
-                    self.todos = json.load(f)
-            except (json.JSONDecodeError, OSError):
-                print("Warning: Failed to load existing todos. Starting fresh.")
+    def _check_and_load_todos(self, file_path: Path) -> None:
+        # Create parent directory if needed
+        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Optional one-time migration: if the user still has a legacy JSON file and
+        # the DB is empty/new, import the items. This keeps upgrades smooth.
+        json_path = file_path.with_suffix(".json")
+        if json_path.exists() and file_path.suffix == ".db":
+            migrate_from_json(json_path=json_path, db_path=file_path, backup=True)
 
-    def write_todos(self):
         try:
-            with self.file_path_to_json.open("w", encoding="utf-8") as f:
-                json.dump(self.todos, f, ensure_ascii=False, indent=2)
-        except OSError as e:
-            print(f"Warning: failed to save todos: {e}")
+            with sqlite3.connect(file_path) as conn:
+                ensure_schema(conn)
+                rows = conn.execute(
+                    "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.
+                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.todos = []
+            self.status = []
 
     def _table_print(
         self,
@@ -61,29 +130,166 @@ class TodoApp:
         table = Table(
             title=title, header_style=style, border_style=style, show_lines=True
         )
-        columns = ["ID", "Todo Item"]
+        columns = ["ID", "Todo Item", "Done"]
         for col in columns:
             table.add_column(str(col))
+
         for idx, todo in enumerate(self.todos, start=1):
-            table.add_row(f"{idx}.", todo)
+            table.add_row(
+                f"{idx}.",
+                str(todo),
+                "[green]✔[/green]" if self.status[idx - 1] else "[red]✖[/red]",
+            )
+
         self._console.print(Padding(table, (2, 2)))
 
+    def mark_as_not_done(self, index: int) -> None:
+        self._check_and_load_todos(self.file_path_to_db)
+
+        if index < 1 or index > len(self.todos):
+            print("Error: Invalid todo index.")
+            return
+
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+
+                row = conn.execute(
+                    "SELECT id, item FROM todos ORDER BY id LIMIT 1 OFFSET ?;",
+                    (index - 1,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo index.")
+                    return
+
+                todo_id, 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}"')
+        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)
+
+        if index < 1 or index > len(self.todos):
+            print("Error: Invalid todo index.")
+            return
+
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+
+                row = conn.execute(
+                    "SELECT id, item FROM todos ORDER BY id LIMIT 1 OFFSET ?;",
+                    (index - 1,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo index.")
+                    return
+
+                todo_id, item = row
+                with conn:
+                    conn.execute(
+                        "UPDATE todos SET done = ?, done_at = datetime('now') WHERE id = ?;",
+                        (1, todo_id),
+                    )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to mark todo as done. ({e})")
+            return
+
+        print(f'Marked todo as done: "{item}"')
+        self._check_and_load_todos(self.file_path_to_db)
 
-def create_list(file_path_to_json: str = "./.todo_list.json"):
+    def update_done_data(self, index, done_value, done_at_value, todo_id):
+        text_done_value = "done" if done_value == 1 else "not done"
+        try:
+            with sqlite3.connect(self.file_path_to_db) as conn:
+                ensure_schema(conn)
+
+                row = conn.execute(
+                    "SELECT id, item FROM todos ORDER BY id LIMIT 1 OFFSET ?;",
+                    (index - 1,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo index.")
+                    return
+
+                todo_id, item = row
+                with conn:
+                    if done_value:
+                        conn.execute(
+                            "UPDATE todos SET done = ?, done_at = datetime('now') WHERE id = ?;",
+                            (1, todo_id),
+                        )
+                    else:
+                        conn.execute(
+                            "UPDATE todos SET done = ?, done_at = NULL WHERE id = ?;",
+                            (0, todo_id),
+                        )
+        except sqlite3.Error as e:
+            print(f"Error: Failed to mark todo as {text_done_value}. ({e})")
+            return
+
+    def edit_entry(self, index: int, new_text: str) -> None:
+        self._check_and_load_todos(self.file_path_to_db)
+
+        if index < 1 or index > len(self.todos):
+            print("Error: Invalid todo index.")
+            return
+
+        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 ORDER BY id LIMIT 1 OFFSET ?;",
+                    (index - 1,),
+                ).fetchone()
+                if row is None:
+                    print("Error: Invalid todo index.")
+                    return
+
+                todo_id, 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}"')
+        self._check_and_load_todos(self.file_path_to_db)
+
+
+def create_list(file_path_to_db: str = "./.todo_list.db"):
     """
     Create a new todo list.
 
     Parameters
     ----------
     file_path_to_json : str, optional
-        The file path to the JSON file for storing todos, by default "./.todo_list.json"
+        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_json=file_path_to_json)
+    app = TodoApp(file_path_to_db=file_path_to_db)
     return app
 
 
@@ -98,10 +304,9 @@ def add_item_to_list(item: str, filepath: str):
     filepath : str
         The file path to the JSON file for storing todos.
     """
-    app = create_list(file_path_to_json=filepath)
+    app = create_list(file_path_to_db=filepath)
     app.add_todo(item)
     app.list_todos()
-    app.write_todos()
 
 
 def list_items_on_list(filepath: str):
@@ -113,7 +318,7 @@ def list_items_on_list(filepath: str):
     filepath : str
         The file path to the JSON file for storing todos.
     """
-    app = create_list(file_path_to_json=filepath)
+    app = create_list(file_path_to_db=filepath)
     app.list_todos()
 
 
@@ -128,10 +333,9 @@ def remove_item_from_list(index: int, filepath: str):
     filepath : str
         The file path to the JSON file for storing todos.
     """
-    app = create_list(file_path_to_json=filepath)
+    app = create_list(file_path_to_db=filepath)
     app.remove_todo(index)
     app.list_todos()
-    app.write_todos()
 
 
 def clear_list_of_items(filepath: str):
@@ -143,28 +347,37 @@ def clear_list_of_items(filepath: str):
     filepath : str
         The file path to the JSON file for storing todos.
     """
-    app = create_list(file_path_to_json=filepath)
-    app.todos = []
-    print("Cleared all todos.")
-    app.write_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.json"):
+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.json"
+        The file path to the JSON file for storing todos, by default "./.todo_list.db"
     """
-    app = create_list(file_path_to_json=filepath)
+    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",
@@ -174,9 +387,33 @@ def cli_menu(filepath="./.todo_list.json"):
         if action == "Add todo":
             item = questionary.text("Enter the todo item:").ask()
             app.add_todo(item)
-            app.write_todos()
         elif action == "List todos":
             app.list_todos()
+        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>":
+                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>":
+                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()
         elif action == "Remove todo":
             if not app.todos:
                 print("No todos to remove.")
@@ -191,24 +428,13 @@ def cli_menu(filepath="./.todo_list.json"):
 
             todo_to_remove = app.todos.index(todo_choice) + 1
             app.remove_todo(todo_to_remove)
-            app.write_todos()
 
         elif action == "Clear all todos":
             confirm = questionary.confirm(
                 "Are you sure you want to clear all todos?"
             ).ask()
             if confirm:
-                app.todos = []
-                print("Cleared all todos.")
-                app.write_todos()
-        elif action == "Clear all todos":
-            confirm = questionary.confirm(
-                "Are you sure you want to clear all todos?"
-            ).ask()
-            if confirm:
-                app.todos = []
-                print("Cleared all todos.")
-                app.write_todos()
+                app.clear_all()
         elif action == "Exit":
             break
         else:

cli_todo_jd/storage/__init__.py

@@ -0,0 +1,6 @@
+"""Storage helpers (SQLite schema + migrations)."""
+
+from .schema import ensure_schema, SCHEMA_VERSION
+from .migrate import migrate_from_json
+
+__all__ = ["ensure_schema", "SCHEMA_VERSION", "migrate_from_json"]

cli_todo_jd/storage/migrate.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Iterable
+
+from .schema import ensure_schema
+
+
+def _iter_json_items(data: object) -> Iterable[str]:
+    """Yield todo item strings from supported legacy JSON formats.
+
+    Supported:
+    - ["item1", "item2", ...]
+    - [{"item": "..."}, {"text": "..."}, ...]
+    """
+    if isinstance(data, list):
+        for entry in data:
+            if isinstance(entry, str):
+                text = entry
+            elif isinstance(entry, dict):
+                text = entry.get("item") or entry.get("text")
+                if not isinstance(text, str):
+                    continue
+            else:
+                continue
+
+            text = text.strip()
+            if text:
+                yield text
+
+
+def migrate_from_json(
+    *,
+    json_path: Path,
+    db_path: Path,
+    backup: bool = True,
+) -> int:
+    """Migrate todos from a legacy JSON file into a SQLite database.
+
+    Parameters
+    ----------
+    json_path:
+        Path to legacy JSON file (e.g. `.todo_list.json`).
+    db_path:
+        Path to SQLite file (e.g. `.todo_list.db`).
+    backup:
+        If True, rename the JSON file to `.bak` after successful import.
+
+    Returns
+    -------
+    int
+        Number of rows inserted.
+
+    Behavior
+    --------
+    - If the JSON file doesn't exist, returns 0.
+    - If the database already has todos, does not import (returns 0).
+      (This avoids duplicate imports when multiple commands run.)
+    """
+
+    if not json_path.exists():
+        return 0
+
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        raw = json_path.read_text(encoding="utf-8")
+        data = json.loads(raw) if raw.strip() else []
+    except (OSError, json.JSONDecodeError):
+        # Fail safe: don't destroy/rename the user's file.
+        return 0
+
+    items = list(_iter_json_items(data))
+    if not items:
+        return 0
+
+    inserted = 0
+    with sqlite3.connect(db_path) as conn:
+        ensure_schema(conn)
+
+        # Guard against double-import
+        existing = conn.execute("SELECT 1 FROM todos LIMIT 1;").fetchone()
+        if existing is not None:
+            return 0
+
+        with conn:
+            conn.executemany(
+                "INSERT INTO todos(item, done) VALUES (?, 0);", [(t,) for t in items]
+            )
+            inserted = conn.execute("SELECT changes();").fetchone()[0]
+
+    if backup:
+        try:
+            bak_path = json_path.with_suffix(json_path.suffix + ".bak")
+            if bak_path.exists():
+                # Avoid overwrite; add a numeric suffix
+                i = 1
+                while True:
+                    candidate = json_path.with_suffix(json_path.suffix + f".bak{i}")
+                    if not candidate.exists():
+                        bak_path = candidate
+                        break
+                    i += 1
+            json_path.rename(bak_path)
+        except OSError:
+            # Backup failure shouldn't invalidate a successful migration
+            pass
+
+    return inserted

cli_todo_jd/storage/schema.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import sqlite3
+
+
+SCHEMA_VERSION = 1
+
+
+def ensure_schema(conn: sqlite3.Connection) -> None:
+    """Ensure required SQLite schema exists and is migrated.
+
+    Uses `PRAGMA user_version` for lightweight, in-app migrations.
+
+    Parameters
+    ----------
+    conn:
+        An open sqlite3 connection.
+
+    Notes
+    -----
+    - Call this once per process/command, right after connecting.
+    - Keep migrations idempotent and wrapped in a transaction.
+    """
+
+    # Improve concurrent CLI usage (separate processes) and durability.
+    # WAL is persistent for the database file once set.
+    conn.execute("PRAGMA journal_mode = WAL;")
+    conn.execute("PRAGMA foreign_keys = ON;")
+
+    current_version = conn.execute("PRAGMA user_version;").fetchone()[0]
+
+    # Fresh database
+    if current_version == 0:
+        with conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS todos (
+                  id         INTEGER PRIMARY KEY AUTOINCREMENT,
+                  item       TEXT    NOT NULL,
+                  done       INTEGER NOT NULL DEFAULT 0,
+                  created_at TEXT    NOT NULL DEFAULT (datetime('now')),
+                  done_at    TEXT
+                );
+                """
+            )
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_todos_done ON todos(done);")
+            conn.execute(f"PRAGMA user_version = {int(SCHEMA_VERSION)};")
+        return
+
+    # Incremental migrations
+    if current_version < 1:
+        # Example placeholder for future migrations.
+        # Keep each migration block small and bump user_version accordingly.
+        with conn:
+            conn.execute("PRAGMA user_version = 1;")
+        current_version = 1
+
+    # If you bump SCHEMA_VERSION, add `if current_version < N:` blocks above.

{cli_todo_jd-0.1.1.dist-info → cli_todo_jd-0.2.0.dist-info}/METADATA

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: cli-todo-jd
-Version: 0.1.1
+Version: 0.2.0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: questionary>=2.1.1
 Requires-Dist: rich>=14.2.0
+Requires-Dist: typer>=0.21.1
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
@@ -20,16 +21,16 @@ A command line to do list with interactive menu
 This is a command line interface todo list. Once installed, there are two ways to interact 
 with the list. 
 
-### `todo-menu`
+### `todo_menu`
 
-Once installed us `todo_menu` to launch into the interactive menu. From here you can add,
+Once installed use `todo_menu` to launch into the interactive menu. From here you can add,
 remove, list, or clear your todo list. Items in your list are stored (by default) as
 `.todo_list.json`. The menu does also support optional filepaths using `-f` or `--filepath`.
 
 
 ### interacting with todo list without menu
 
-Alternatly you can interact directly using the following commands (`--filepath can be substituted for -f`)
+Alternately you can interact directly using the following commands (`--filepath can be substituted for -f`)
 
 - `todo_add text --filepath optional_path_to_json` used to add an item to your list
 - `todo_remove index --filepath optional_path_to_json` used to remove item number `index`

cli_todo_jd-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cli_todo_jd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli_todo_jd/cli_entry.py,sha256=sKp-aIWVldH8DiXv22bokjlIiJcAZshKHdLEqjM09HA,2877
+cli_todo_jd/main.py,sha256=AN22ojW0iIXArJQmtEjQ1jSdAb7Z-xr8i4NIEE4xAQ0,13965
+cli_todo_jd/storage/__init__.py,sha256=u0jMfDuUIEy9mor1dVeIiAE0Cap6FL77tW9GlsyskYU,210
+cli_todo_jd/storage/migrate.py,sha256=Ij_0OwTvibow79KVilf2O2nfMuohj0raarVV7OcjwbY,3063
+cli_todo_jd/storage/schema.py,sha256=r5BTtcRn8J72_b8NJlryYnd_aiuy0y00eX01QavKE98,1824
+cli_todo_jd-0.2.0.dist-info/METADATA,sha256=rra5GQZYrK8xCKX3pUaW0wnmw_pujlKR8bpOIVH-a1U,2982
+cli_todo_jd-0.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cli_todo_jd-0.2.0.dist-info/entry_points.txt,sha256=BIfrMKcC340A79aXHg34nnhiDsXh7c9hPck1k-Rb28c,95
+cli_todo_jd-0.2.0.dist-info/top_level.txt,sha256=hOnYr7w1JdQs6MlD1Uzjt24Ca8nvriOWNNq6NaqgHqM,12
+cli_todo_jd-0.2.0.dist-info/RECORD,,

{cli_todo_jd-0.1.1.dist-info → cli_todo_jd-0.2.0.dist-info}/WHEEL

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

cli_todo_jd-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+todo = cli_todo_jd.cli_entry:app
+todo_menu = cli_todo_jd.cli_entry:todo_menu

cli_todo_jd-0.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-cli_todo_jd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli_todo_jd/cli_entry.py,sha256=WFigVsmponzukNW-T_35ChdMWS3AVerdfKp2MePZzVo,2109
-cli_todo_jd/main.py,sha256=PfzsSz6whW8BMQ79PoCRvJO5oBN7qhpDFut_HtgjJns,5877
-cli_todo_jd-0.1.1.dist-info/METADATA,sha256=PhFUYCFtAyTd5u_CQ-b5Pn1K6Q_5nvYlxNcqigRLoWs,2951
-cli_todo_jd-0.1.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-cli_todo_jd-0.1.1.dist-info/entry_points.txt,sha256=UtqZ1yqzeQNOOVC232_iqRQCcKu9hL9k5Q-BtyMZSGg,243
-cli_todo_jd-0.1.1.dist-info/top_level.txt,sha256=hOnYr7w1JdQs6MlD1Uzjt24Ca8nvriOWNNq6NaqgHqM,12
-cli_todo_jd-0.1.1.dist-info/RECORD,,

cli_todo_jd-0.1.1.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[console_scripts]
-todo_add = cli_todo_jd.cli_entry:add_item
-todo_clear = cli_todo_jd.cli_entry:clear_list
-todo_list = cli_todo_jd.cli_entry:list_items
-todo_menu = cli_todo_jd.cli_entry:todo_menu
-todo_remove = cli_todo_jd.cli_entry:remove_item