tasko 0.0.1__tar.gz → 0.0.2__tar.gz

{tasko-0.0.1 → tasko-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tasko
-Version: 0.0.1
+Version: 0.0.2
 Summary: Personal task manager
 Author: pybass
 License-Expression: MIT
@@ -17,30 +17,20 @@ Description-Content-Type: text/markdown
 
 # tasko
 
-A personal task manager: a fast Textual TUI over local SQLite, with a minimal
-CLI for quick capture.
+A personal task manager: a fast Textual TUI over local SQLite.
 
 ## Usage
 
-`tasko` with no arguments launches the TUI — the primary interface, where all
-task and project management lives.
-
-The CLI is deliberately minimal (see
-[docs/architecture.md](docs/architecture.md) for why):
-
-```sh
-tasko add "fix nginx" -p infra   # quick capture from the shell
-tasko list                       # a quick look without launching the TUI
-```
+`tasko` launches the TUI — the only interface, where all task and project
+management lives.
 
 Data is a single SQLite file under `$XDG_DATA_HOME/tasko` (default
-`~/.local/share/tasko`); override the directory with `--data-dir` or the
-`TASKO_DATA_DIR` env var.
+`~/.local/share/tasko`); override the directory with `--data-dir`.
 
 ## Design
 
-- [docs/architecture.md](docs/architecture.md) — layering (`core/` + `cli/` +
-  `tui/`), the TUI-first UI strategy, tool choices.
+- [docs/architecture.md](docs/architecture.md) — layering (`core/` + `tui/`),
+  the TUI-only UI strategy, tool choices.
 - [docs/data-model.md](docs/data-model.md) — entities, the full SQL schema,
   and the reasoning behind it.
 - [docs/non-goals.md](docs/non-goals.md) — features deliberately not built,

tasko-0.0.2/README.md

@@ -0,0 +1,24 @@
+# tasko
+
+A personal task manager: a fast Textual TUI over local SQLite.
+
+## Usage
+
+`tasko` launches the TUI — the only interface, where all task and project
+management lives.
+
+Data is a single SQLite file under `$XDG_DATA_HOME/tasko` (default
+`~/.local/share/tasko`); override the directory with `--data-dir`.
+
+## Design
+
+- [docs/architecture.md](docs/architecture.md) — layering (`core/` + `tui/`),
+  the TUI-only UI strategy, tool choices.
+- [docs/data-model.md](docs/data-model.md) — entities, the full SQL schema,
+  and the reasoning behind it.
+- [docs/non-goals.md](docs/non-goals.md) — features deliberately not built,
+  and why.
+
+## License
+
+[MIT](LICENSE)

{tasko-0.0.1 → tasko-0.0.2}/pyproject.toml

@@ -3,7 +3,7 @@
 # ============================================================================
 [project]
 name = "tasko"
-version = "0.0.1"
+version = "0.0.2"
 description = "Personal task manager"
 readme = "README.md"
 authors = [{ name = "pybass" }]
@@ -25,7 +25,7 @@ Repository = "https://github.com/pybass/tasko"
 Issues = "https://github.com/pybass/tasko/issues"
 
 [project.scripts]
-tasko = "tasko.cli.main:main"
+tasko = "tasko.main:main"
 
 
 # ============================================================================
@@ -48,7 +48,6 @@ dev = [
     "ruff~=0.15.22",
     # Type checking
     "mypy~=2.3.0",
-    "ty~=0.0.60",
     # Testing & coverage
     "pytest~=9.1.1",
     "pytest-asyncio~=1.4.0",
@@ -122,7 +121,7 @@ docstring-code-format = true  # keep code examples in docstrings formatted like
 
 
 # ============================================================================
-#  Type checking — mypy (strict) + ty
+#  Type checking — mypy (strict)
 # ============================================================================
 [tool.mypy]
 python_version = "3.14"
@@ -137,16 +136,6 @@ disallow_untyped_decorators = false
 disallow_untyped_calls = false
 warn_unused_ignores = false
 
-[tool.ty.environment]
-python-version = "3.14"
-
-# Same intent as the mypy test override: silence test-only false positives.
-[[tool.ty.overrides]]
-include = ["tests/**"]
-[tool.ty.overrides.rules]
-possibly-missing-attribute = "ignore"
-invalid-assignment = "ignore"
-
 
 # ============================================================================
 #  Spell checking — codespell

{tasko-0.0.1 → tasko-0.0.2}/src/tasko/core/core.py

@@ -20,13 +20,15 @@ def _now() -> int:
 class Core:
     """The application without UI: owns the SQLite connection and every operation on it.
 
-    Adapters (CLI, TUI) call these methods and show AppError messages to the user.
+    Adapters (the TUI) call these methods and show AppError messages to the user.
     """
 
     def __init__(self, db_path: Path) -> None:
         """Open the database (creating the file and its directory if needed) and migrate it."""
         db_path.parent.mkdir(parents=True, exist_ok=True)
-        self._conn = sqlite3.connect(db_path)  # single shared connection
+        # autocommit: every write is a single self-committing statement; anything that ever
+        # needs multi-statement atomicity must use explicit BEGIN/COMMIT (as _migrate does).
+        self._conn = sqlite3.connect(db_path, autocommit=True)  # single shared connection
         self._conn.row_factory = sqlite3.Row
         self._conn.execute("PRAGMA journal_mode = WAL")
         self._conn.execute("PRAGMA busy_timeout = 5000")
@@ -68,7 +70,6 @@ class Core:
             ).fetchone()
         except sqlite3.IntegrityError as e:  # foreign key: no such project
             raise AppError(f"Project #{project_id} not found.") from e
-        self._conn.commit()
         return self.get_task(int(row["id"]))
 
     def get_task(self, task_id: int) -> Task:
@@ -121,7 +122,6 @@ class Core:
             "UPDATE tasks SET status = :status, done_at = :done_at, updated_at = :now WHERE id = :id",
             {"status": status, "done_at": done_at, "now": now, "id": task_id},
         )
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
@@ -134,7 +134,6 @@ class Core:
             "UPDATE tasks SET title = :title, updated_at = :now WHERE id = :id",
             {"title": title, "now": _now(), "id": task_id},
         )
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
@@ -146,7 +145,6 @@ class Core:
             "UPDATE tasks SET body = :body, updated_at = :now WHERE id = :id",
             {"body": body, "now": _now(), "id": task_id},
         )
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
@@ -156,7 +154,6 @@ class Core:
             "UPDATE tasks SET priority = :priority, updated_at = :now WHERE id = :id",
             {"priority": priority, "now": _now(), "id": task_id},
         )
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
@@ -169,14 +166,12 @@ class Core:
             )
         except sqlite3.IntegrityError as e:  # foreign key: no such project
             raise AppError(f"Project #{project_id} not found.") from e
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
     def delete_task(self, task_id: int) -> None:
         """Delete a task permanently."""
         cur = self._conn.execute("DELETE FROM tasks WHERE id = ?", (task_id,))
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Task #{task_id} not found.")
 
@@ -194,26 +189,16 @@ class Core:
             raise AppError(f"Project #{project_id} not found.")
         return Project(**dict(row))
 
-    def get_project_by_name(self, name: str) -> Project:
-        """Return a project by its unique name; raises AppError when it does not exist.
-
-        For adapters whose input addresses projects by name (the CLI); everything else uses ids.
-        """
-        row = self._conn.execute("SELECT id, name FROM projects WHERE name = ?", (name,)).fetchone()
-        if row is None:
-            raise AppError(f"Project '{name}' not found.")
-        return Project(**dict(row))
-
-    def create_project(self, name: str) -> None:
-        """Create a project with a unique non-empty name."""
+    def create_project(self, name: str) -> Project:
+        """Create a project with a unique non-empty name and return it."""
         name = name.strip()
         if not name:
             raise AppError("Project name cannot be empty.")
         try:
-            self._conn.execute("INSERT INTO projects (name) VALUES (?)", (name,))
+            row = self._conn.execute("INSERT INTO projects (name) VALUES (?) RETURNING id", (name,)).fetchone()
         except sqlite3.IntegrityError as e:
             raise AppError(f"Project '{name}' already exists.") from e
-        self._conn.commit()
+        return Project(id=row["id"], name=name)
 
     def rename_project(self, project_id: int, new_name: str) -> None:
         """Rename a project; the new name must be unique and non-empty."""
@@ -224,7 +209,6 @@ class Core:
             cur = self._conn.execute("UPDATE projects SET name = ? WHERE id = ?", (new_name, project_id))
         except sqlite3.IntegrityError as e:
             raise AppError(f"Project '{new_name}' already exists.") from e
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Project #{project_id} not found.")
 
@@ -233,7 +217,6 @@ class Core:
         if project_id == self.app_state().default_project_id:
             raise AppError("Cannot delete the default project; make another project the default first.")
         cur = self._conn.execute("DELETE FROM projects WHERE id = ?", (project_id,))
-        self._conn.commit()
         if cur.rowcount == 0:
             raise AppError(f"Project #{project_id} not found.")
 
@@ -251,12 +234,10 @@ class Core:
     def set_selected_project(self, project_id: int | None) -> None:
         """Set the persisted project filter; None means all projects."""
         self._conn.execute("UPDATE app_state SET selected_project_id = ? WHERE id = 1", (project_id,))
-        self._conn.commit()
 
     def set_theme(self, theme: str) -> None:
         """Persist the UI theme choice."""
         self._conn.execute("UPDATE app_state SET theme = ? WHERE id = 1", (theme,))
-        self._conn.commit()
 
     def set_default_project(self, project_id: int) -> None:
         """Make the given project the default target for quick capture."""
@@ -264,4 +245,3 @@ class Core:
             self._conn.execute("UPDATE app_state SET default_project_id = ? WHERE id = 1", (project_id,))
         except sqlite3.IntegrityError as e:  # foreign key: no such project
             raise AppError(f"Project #{project_id} not found.") from e
-        self._conn.commit()

tasko-0.0.2/src/tasko/main.py

@@ -0,0 +1,33 @@
+"""Entry point: resolve the data directory, open the database, run the TUI."""
+
+import argparse
+import os
+import sys
+from importlib.metadata import version
+from pathlib import Path
+
+from tasko.core.core import Core
+from tasko.core.errors import AppError
+from tasko.tui.app import TaskoApp
+
+
+def main() -> None:
+    """Launch the TUI against the resolved database."""
+    parser = argparse.ArgumentParser(prog="tasko", description="Personal task manager.")
+    parser.add_argument("--version", action="version", version=version("tasko"))
+    parser.add_argument("--data-dir", type=Path, help="data directory (default: XDG data dir)")
+    args = parser.parse_args()
+    core = Core(_resolve_db_path(args.data_dir))
+    try:
+        TaskoApp(core).run()
+    except AppError as e:
+        sys.exit(f"error: {e}")
+    finally:
+        core.close()
+
+
+def _resolve_db_path(data_dir: Path | None) -> Path:
+    """Database file path; without an explicit directory the XDG data dir is used."""
+    if data_dir is None:
+        data_dir = Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share") / "tasko"
+    return data_dir / "tasko.db"

{tasko-0.0.1 → tasko-0.0.2}/src/tasko/tui/app.py

@@ -42,7 +42,7 @@ class TaskoApp(App[None]):
     def __init__(self, core: Core) -> None:
         """Wire the app to the shared core."""
         super().__init__()
-        self._core = core  # application core, shared with the CLI
+        self._core = core  # application core, built by main() and owned by it
 
     def action_help(self) -> None:
         """Show the current screen's keys; screens opt in by defining a HELP_KEYS attribute."""
@@ -64,8 +64,9 @@ class TaskoApp(App[None]):
     def on_app_focus(self) -> None:
         """Reload the visible screen when the terminal regains focus.
 
-        This closes the quick-capture loop: `tasko add` from a shell, alt-tab back, the
-        list is fresh. Skipped while a dialog is on top — reloading under a modal could
+        The database can change under a running instance — a second tasko in another
+        terminal — so alt-tabbing back shows a fresh list rather than a stale one.
+        Skipped while a dialog is on top — reloading under a modal could
         fight the interaction in progress (r covers that case), and TaskDetailScreen.reload
         pops the top screen when its task is gone, which must never hit a dialog.
         """

{tasko-0.0.1 → tasko-0.0.2}/src/tasko/tui/screens/task_list.py

@@ -46,6 +46,7 @@ class TaskListScreen(Screen[None]):
         ("j", "cursor_down", "Down"),
         ("k", "cursor_up", "Up"),
         ("a", "add", "Add"),
+        ("A", "add_with_project", "Add to project"),
         ("d", "toggle_done", "Done"),
         ("s", "toggle_doing", "Doing"),
         ("plus,equals_sign", "priority_up", "Priority up"),  # = raises too: + is shifted on most layouts
@@ -64,6 +65,7 @@ class TaskListScreen(Screen[None]):
         ("↑ ↓ j k", "move the cursor"),
         ("enter", "open the task under the cursor"),
         ("a", "add a task into the cursor row's project"),
+        ("A", "add a task, choosing the project first"),
         ("d", "mark done / back to todo"),
         ("s", "mark doing / back to todo"),
         ("+ -", "raise / lower the priority"),
@@ -183,6 +185,44 @@ class TaskListScreen(Screen[None]):
 
         self.app.push_screen(InputDialog(f'New task in "{name}":'), on_result)
 
+    def action_add_with_project(self) -> None:
+        """Pick the target project from the full list, then prompt for a title.
+
+        The escape hatch for 'a': used when no visible row carries the wanted project.
+        """
+        options: list[tuple[str, str | Text]] = [(str(p.id), p.name) for p in self._core.list_projects()]
+        # Preselect the project plain 'a' would target, so Enter-Enter behaves like 'a'.
+        task_id = self._cursor_task_id()
+        if task_id is not None:
+            current = str(self._core.get_task(task_id).project_id)
+        else:
+            state = self._core.app_state()
+            current = str(state.selected_project_id or state.default_project_id)
+
+        def on_project(choice: str | None) -> None:
+            if choice is None:
+                return
+            project_id = int(choice)
+            name = self._core.get_project(project_id).name
+
+            def on_title(title: str | None) -> None:
+                if not title:
+                    return
+                try:
+                    self._core.add_task(title, project_id=project_id)
+                except AppError as e:
+                    self.notify(str(e), severity="error")
+                    return
+                self.reload()
+                # The task is invisible when a different project filter is active — confirm it landed.
+                filter_id = self._core.app_state().selected_project_id
+                if filter_id is not None and filter_id != project_id:
+                    self.notify(f'Added to "{name}"')
+
+            self.app.push_screen(InputDialog(f'New task in "{name}":'), on_title)
+
+        self.app.push_screen(SelectDialog("Add task to project:", options, current), on_project)
+
     def _cursor_task_id(self) -> int | None:
         """Return the id of the task under the cursor, or None on an empty table.
 
@@ -297,7 +337,7 @@ class TaskListScreen(Screen[None]):
         self.reload()
 
     def action_refresh(self) -> None:
-        """Reload the list: apply pending re-sorts/hides from d/s and pick up outside changes (e.g. CLI adds)."""
+        """Reload the list: apply pending re-sorts/hides from d/s and pick up changes from another instance."""
         self.reload()
 
     def action_focus_project(self) -> None:

tasko-0.0.1/README.md

@@ -1,34 +0,0 @@
-# tasko
-
-A personal task manager: a fast Textual TUI over local SQLite, with a minimal
-CLI for quick capture.
-
-## Usage
-
-`tasko` with no arguments launches the TUI — the primary interface, where all
-task and project management lives.
-
-The CLI is deliberately minimal (see
-[docs/architecture.md](docs/architecture.md) for why):
-
-```sh
-tasko add "fix nginx" -p infra   # quick capture from the shell
-tasko list                       # a quick look without launching the TUI
-```
-
-Data is a single SQLite file under `$XDG_DATA_HOME/tasko` (default
-`~/.local/share/tasko`); override the directory with `--data-dir` or the
-`TASKO_DATA_DIR` env var.
-
-## Design
-
-- [docs/architecture.md](docs/architecture.md) — layering (`core/` + `cli/` +
-  `tui/`), the TUI-first UI strategy, tool choices.
-- [docs/data-model.md](docs/data-model.md) — entities, the full SQL schema,
-  and the reasoning behind it.
-- [docs/non-goals.md](docs/non-goals.md) — features deliberately not built,
-  and why.
-
-## License
-
-[MIT](LICENSE)

tasko-0.0.1/src/tasko/cli/__init__.py

@@ -1 +0,0 @@
-"""CLI adapter."""

tasko-0.0.1/src/tasko/cli/main.py

@@ -1,89 +0,0 @@
-"""CLI adapter: quick capture and a quick look at the list. The TUI is the primary interface."""
-
-# ruff: noqa: T201 -- printing to stdout is this module's purpose: every command's user-facing
-# output goes through print(); the rule targets stray debug prints, which cannot exist here.
-
-import argparse
-import os
-import sys
-from importlib.metadata import version
-from pathlib import Path
-
-from tasko.core.core import Core
-from tasko.core.errors import AppError
-from tasko.core.models import Priority, Status
-
-DATA_DIR_ENV_VAR = "TASKO_DATA_DIR"  # overrides the default data directory
-
-
-def main() -> None:
-    """Entry point: no subcommand launches the TUI; `add` and `list` serve capture and a quick look."""
-    args = _build_parser().parse_args()
-    core = Core(_resolve_db_path(args.data_dir))
-    try:
-        if args.command is None:
-            # Lazy import: quick capture (`tasko add`) must not pay the TUI framework's import cost.
-            from tasko.tui.app import TaskoApp  # noqa: PLC0415
-
-            TaskoApp(core).run()
-        elif args.command == "add":
-            _cmd_add(core, args)
-        else:
-            _cmd_list(core, args)
-    except AppError as e:
-        sys.exit(f"error: {e}")
-    finally:
-        core.close()
-
-
-def _resolve_db_path(data_dir: Path | None = None) -> Path:
-    """Path to the SQLite database file, resolving the data directory as CLI arg → env var → XDG default."""
-    if data_dir is None:
-        env = os.environ.get(DATA_DIR_ENV_VAR)
-        if env:
-            data_dir = Path(env)
-        else:
-            xdg_data_home = Path(os.environ.get("XDG_DATA_HOME") or Path.home() / ".local" / "share")
-            data_dir = xdg_data_home / "tasko"
-    return data_dir / "tasko.db"
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    """Build the argument parser with the `add` and `list` subcommands."""
-    parser = argparse.ArgumentParser(prog="tasko", description="Personal task manager.")
-    parser.add_argument("--version", action="version", version=version("tasko"))
-    parser.add_argument("--data-dir", type=Path, help=f"data directory (env: {DATA_DIR_ENV_VAR}; default: XDG data dir)")
-    subparsers = parser.add_subparsers(dest="command")
-
-    add = subparsers.add_parser("add", help="add a task")
-    add.add_argument("title", help="task title")
-    add.add_argument("-p", "--project", help="project name (default: the default project)")
-    add.add_argument("-b", "--body", help="longer description")
-    add.add_argument("--priority", type=Priority, choices=list(Priority), default=Priority.MEDIUM, help="task priority")
-
-    list_ = subparsers.add_parser("list", help="list tasks (open ones by default)")
-    list_.add_argument("-p", "--project", help="filter by project name")
-    list_.add_argument("-s", "--status", type=Status, choices=list(Status), help="filter by status")
-    list_.add_argument("--all", action="store_true", help="include done tasks")
-    return parser
-
-
-def _cmd_add(core: Core, args: argparse.Namespace) -> None:
-    """Create a task and confirm where it landed."""
-    project_id = core.get_project_by_name(args.project).id if args.project is not None else None
-    task = core.add_task(args.title, project_id=project_id, body=args.body, priority=args.priority)
-    print(f"Task #{task.id} created in project '{task.project_name}'.")
-
-
-def _cmd_list(core: Core, args: argparse.Namespace) -> None:
-    """Print tasks as an aligned table."""
-    project_id = core.get_project_by_name(args.project).id if args.project is not None else None
-    tasks = core.list_tasks(project_id=project_id, status=args.status, include_done=args.all)
-    if not tasks:
-        print("No tasks.")
-        return
-    header = ("ID", "Project", "Status", "Priority", "Title")
-    rows = [(str(t.id), t.project_name, t.status, t.priority, t.title) for t in tasks]
-    widths = [max(len(row[i]) for row in (header, *rows)) for i in range(len(header))]
-    for row in (header, *rows):
-        print("  ".join(cell.ljust(width) for cell, width in zip(row, widths, strict=True)).rstrip())