src/tt/cli.py

@@ -2,11 +2,11 @@ import typer
 import httpx
 import lxml.html
 from typing_extensions import Annotated
+from .controller.tasks import add_task
 from .db import initialize_db
-from .tui.things import run as things_tui
-#from .tui.overview import run as overview_tui
+from .tui.tasks import run as tasks_tui
+from .tui.overview import run as overview_tui
 from .tui.recurring import run as recurring_tui
-from .controller.things import add_thing
 
 app = typer.Typer()
 
@@ -37,15 +37,16 @@ def new(
     # due = typer.prompt("Due (YYYY-MM-DD):")
     # TODO: validate/allow blank
 
-    add_thing(name, category, due)
-    typer.echo("Created new thing!")
+    add_task(name, category, due)
+    typer.echo("Created new task!")
+
 
 @app.command()
-def table(
+def tasks(
     view: Annotated[str, typer.Option("-v", "--view", help="saved view")] = "default",
 ):
     initialize_db()
-    things_tui("tasks")
+    tasks_tui(view)
 
 
 @app.command()

src/tt/config.py

@@ -42,16 +42,6 @@ def get_view(name):
 
     raise ValueError(f"no such view! {name}")
 
-def get_column(name):
-    if name in ("id", "type"):
-        return {"field_name": name, "display_name": name, "read_only": True}
-
-    for col in _load_config().get("columns", []):
-        if col["field_name"] == name:
-            return col
-
-    raise ValueError(f"no such column! {name}")
-
 # Valid statuses & projects are read dynamically from the user's config.
 STATUSES = get_enum("status")
 PROJECTS = get_enum("projects")

src/tt/controller/generators.py

@@ -1,15 +1,15 @@
 import json
 from datetime import date, timedelta
-from ..db import db, ThingGenerator
-from .things import add_thing
+from ..db import db, TaskGenerator
+from .tasks import add_task
 
 
-def get_generator(item_id: int) -> ThingGenerator:
-    return ThingGenerator.get_by_id(item_id)
+def get_generator(item_id: int) -> TaskGenerator:
+    return TaskGenerator.get_by_id(item_id)
 
 
-def get_generators() -> list[ThingGenerator]:
-    query = ThingGenerator.select().where(~ThingGenerator.deleted)
+def get_generators() -> list[TaskGenerator]:
+    query = TaskGenerator.select().where(~TaskGenerator.deleted)
     return query.order_by("type", "template")
 
 
@@ -17,19 +17,19 @@ def add_generator(
     template: str,
     type: str,
     val: str,
-) -> ThingGenerator:
+) -> TaskGenerator:
     # JSON for future expansion
     config = json.dumps({"val": val})
     with db.atomic():
-        thing = ThingGenerator.create(
+        task = TaskGenerator.create(
             template=template,
             type=type,
             config=config,
         )
-    return thing
+    return task
 
 
-def generate_needed_things():
+def generate_needed_tasks():
     to_create = []
     for g in get_generators():
         next = g.next_at()
@@ -46,7 +46,7 @@ def generate_needed_things():
             )
 
     for c in to_create:
-        add_thing(**c)
+        add_task(**c)
 
     return to_create
 
@@ -54,13 +54,13 @@ def generate_needed_things():
 def update_generator(
     item_id: int,
     **kwargs,
-) -> ThingGenerator:
+) -> TaskGenerator:
     # replace "val" with JSON
     if "val" in kwargs:
         config = {"val": kwargs.pop("val")}
         kwargs["config"] = json.dumps(config)
     with db.atomic():
-        query = ThingGenerator.update(kwargs).where(ThingGenerator.id == item_id)
+        query = TaskGenerator.update(kwargs).where(TaskGenerator.id == item_id)
         query.execute()
-        thing = ThingGenerator.get_by_id(item_id)
-    return thing
+        task = TaskGenerator.get_by_id(item_id)
+    return task

src/tt/controller/summaries.py

@@ -0,0 +1,107 @@
+from datetime import datetime, timedelta
+from peewee import fn, JOIN
+from ..db import Task
+
+
+def get_category_summary(num: int = 5) -> list[dict]:
+    """
+    Returns summary of top categories with task counts by status and due dates.
+
+    Args:
+        num: Number of categories to return, ordered by total task count
+
+    Returns:
+        List of dicts containing category name and task statistics
+    """
+    return []
+
+def get_recently_active(num: int = 5, category: str | None = None) -> list[dict]:
+    """
+    Returns most recently active tasks, optionally filtered by category.
+
+    Args:
+        num: Number of tasks to return
+        category: Optional category name to filter by
+
+    Returns:
+        List of tasks ordered by last activity (updated_at)
+    """
+    query = (
+        Task.select(Task, Category).join(Category, JOIN.LEFT_OUTER).where(~Task.deleted)
+    )
+
+    if category:
+        query = query.where(Category.name == category)
+
+    query = query.order_by(Task.updated_at.desc()).limit(num)
+
+    return [
+        {
+            "id": task.id,
+            "text": task.text,
+            "status": task.status,
+            "type": task.type,
+            "category": task.category.name if task.category else None,
+            "due": task.due,
+            "updated_at": task.updated_at,
+        }
+        for task in query
+    ]
+
+
+def get_due_soon(
+    num: int = 5, all_overdue: bool = True, category: str | None = None
+) -> list[dict]:
+    """
+    Returns tasks ordered by due date, optionally including all overdue tasks.
+
+    Args:
+        num: Number of non-overdue tasks to return
+        all_overdue: If True, returns all overdue tasks plus num more tasks
+                    If False, includes overdue tasks in the count
+        category: Optional category name to filter by
+
+    Returns:
+        List of tasks ordered by due date
+    """
+    now = datetime.now()
+
+    # unfinished tasks w/ due date
+    query = (
+        Task.select(Task)
+        .join(Category, JOIN.LEFT_OUTER)
+        .where(
+            (~Task.deleted)
+            & (Task.due.is_null(False))
+            & (Task.due != "")
+            & (Task.status != "done")
+        )
+    )
+
+    # filter by category
+    if category:
+        query = query.where(Category.name == category)
+
+    if all_overdue:
+        # grab all overdue & append a few more on
+        overdue_tasks = list(query.where(Task.due < now).order_by(Task.due))
+        upcoming_tasks = list(
+            query.where(Task.due >= now).order_by(Task.due).limit(num)
+        )
+        tasks = overdue_tasks + upcoming_tasks
+    else:
+        # just most due tasks
+        tasks = list(query.order_by(Task.due).limit(num))
+
+    return [
+        {
+            "id": task.id,
+            "text": task.text,
+            "status": task.status,
+            "type": task.type,
+            "category": task.category.name if task.category else None,
+            "due": task.due,
+            "days_until_due": (task.due - now).days if task.due else None,
+        }
+        for task in tasks
+    ]

src/tt/controller/tasks.py

@@ -0,0 +1,114 @@
+import json
+from datetime import datetime
+from peewee import fn
+from peewee import Case, Value
+from ..db import db, Task, SavedSearch
+from .. import config
+from ..constants import SPECIAL_DATES_PIECES
+
+
+def get_task(item_id: int) -> Task:
+    return Task.get_by_id(item_id)
+
+
+def add_task(
+    text: str,
+    status: str,
+    due: datetime | str = SPECIAL_DATES_PIECES["unclassified"],
+    type: str = "",
+    project: str = "",
+) -> Task:
+    """
+    Add a new task to the database.
+    Returns the created task instance.
+    """
+    with db.atomic():
+        task = Task.create(
+            text=text, type=type, status=status, due=due, project=project
+        )
+    return task
+
+
+def update_task(
+    item_id: int,
+    **kwargs,
+) -> Task:
+    with db.atomic():
+        query = Task.update(kwargs).where(Task.id == item_id)
+        query.execute()
+        task = Task.get_by_id(item_id)
+    return task
+
+
+def _parse_sort_string(sort_string, status_order):
+    """
+    Convert sort string like 'field1,-field2' to peewee order_by expressions.
+    """
+    sort_expressions = []
+
+    if not sort_string:
+        return sort_expressions
+
+    for field in sort_string.split(","):
+        is_desc = field.startswith("-")
+        field_name = field[1:] if is_desc else field
+
+        if field == "status":
+            if not status_order:
+                status_order = list(config.STATUSES.keys())
+            # CASE statement that maps each status to its position in the order
+            order_case = Case(
+                Task.status,
+                [(s, Value(i)) for i, s in enumerate(status_order)],
+            )
+            sort_expressions.append(order_case.desc() if is_desc else order_case.asc())
+        elif field_name == "due_date":
+            expr = fn.COALESCE(getattr(Task, field_name), datetime(3000, 12, 31))
+            sort_expressions.append(expr.desc() if is_desc else expr)
+        else:
+            field_expr = getattr(Task, field_name)
+            sort_expressions.append(field_expr.desc() if is_desc else field_expr)
+
+    return sort_expressions
+
+
+def get_tasks(
+    search_text: str | None = None,
+    statuses: tuple[str] | None = None,
+    projects: tuple[str] | None = None,
+    sort: str = "",
+) -> list[Task]:
+    query = Task.select().where(~Task.deleted)
+
+    if search_text:
+        query = query.where(fn.Lower(Task.text).contains(search_text.lower()))
+    if statuses:
+        query = query.where(Task.status.in_(statuses))
+    if projects:
+         query = query.where(Task.project.in_(projects))
+
+    sort_expressions = _parse_sort_string(sort, statuses)
+    query = query.order_by(*sort_expressions)
+
+    return list(query)
+
+
+def save_view(name: str, *, filters: dict, sort_string: str) -> SavedSearch:
+    filters_json = json.dumps(filters)
+
+    with db.atomic():
+        if SavedSearch.select().where(SavedSearch.name == name).exists():
+            query = SavedSearch.update(
+                filters=filters_json, sort_string=sort_string
+            ).where(SavedSearch.name == name)
+            query.execute()
+        else:
+            SavedSearch.create(name=name, filters=filters_json, sort_string=sort_string)
+
+
+def get_saved_view_names() -> list[str]:
+    return [search.name for search in SavedSearch.select()]
+
+
+def get_saved_view(name: str) -> SavedSearch:
+    return SavedSearch.get(SavedSearch.name == name)

src/tt/controller/things.py

@@ -1,100 +0,0 @@
-from peewee import fn
-from peewee import Case, Value
-from ..db import db, Thing
-from .. import config
-
-
-def get_thing(item_id: int) -> Thing:
-    return Thing.get_by_id(item_id)
-
-
-def add_thing(
-    type: str = "?",
-    **kwargs,
-) -> Thing:
-    """
-    Add a new Thing to the database.
-    Returns the created Thing instance.
-    """
-    with db.atomic():
-        thing = Thing.create(
-            type=type, data=kwargs
-        )
-    return thing
-
-
-def update_thing(
-    item_id: int,
-    **kwargs,
-) -> Thing:
-    with db.atomic():
-        thing = Thing.get_by_id(item_id)
-        new_data = thing.data | kwargs
-        query = Thing.update(data=new_data).where(Thing.id == item_id)
-        query.execute()
-        thing = Thing.get_by_id(item_id)
-    return thing
-
-
-def _parse_sort_string(sort_string):
-    """
-    Convert sort string like 'field1,-field2' to peewee order_by expressions.
-    """
-    sort_expressions = []
-
-    if not sort_string:
-        return sort_expressions
-
-    for field_name in sort_string.split(","):
-        is_desc = field_name.startswith("-")
-        field_name = field_name[1:] if is_desc else field_name
-
-        # TODO: look up field type
-        field_type = "text"
-
-        if field_type == "enum":
-            # TODO: allow dynamic ordering
-            order = config.get_enum(field_name)
-            # CASE statement that maps each status to its position in the order
-            order_case = Case(
-                Thing.data[field_name],
-                [(s, Value(i)) for i, s in enumerate(order)],
-            )
-            sort_expressions.append(order_case.desc() if is_desc else order_case.asc())
-        elif field_type == "date":
-            expr = fn.COALESCE(Thing.data[field_name], "3000-01-01")
-            sort_expressions.append(expr.desc() if is_desc else expr)
-        else:
-            field_expr = Thing.data[field_name]
-            sort_expressions.append(field_expr.desc() if is_desc else field_expr)
-
-    return sort_expressions
-
-
-def get_things(
-    search_text: str | None = None,
-    filters: dict[str, str] | None = None,
-    sort: str = "",
-) -> list[Thing]:
-    query = Thing.select().where(~Thing.deleted)
-
-    if search_text:
-        # TODO: which fields are searchable should by dynamic
-        query = query.where(fn.Lower(Thing.data['text']).contains(search_text.lower()))
-
-    for param, val in filters.items():
-        if val is not None:
-            # no _in query for JSON fields, so use OR
-            condition = False
-            for cond in val:
-                # handle type filtering the same way
-                if param == "type":
-                    condition |= Thing.type == cond
-                else:
-                    condition |= Thing.data[param] == cond
-            query = query.where(condition)
-
-    sort_expressions = _parse_sort_string(sort)
-    query = query.order_by(*sort_expressions)
-
-    return list(query)

src/tt/db.py

@@ -9,13 +9,12 @@ from peewee import (
     SqliteDatabase,
     TextField,
 )
-from playhouse.sqlite_ext import JSONField
 
 # This module defines the core data types.
 # 
 
 db = SqliteDatabase(
-    xdg_data_home() / "tt/tt.db",
+    xdg_data_home() / "tt/tasks.db",
     pragmas={
         "journal_mode": "wal",
         "synchronous": "normal",
@@ -29,20 +28,24 @@ class BaseModel(Model):
         database = db
 
 
-class Thing(BaseModel):
+
+class Task(BaseModel):
+    text = TextField()
+    status = CharField()
+    due = DateTimeField(null=True)
     type = CharField()
-    data = JSONField()
+    project = CharField()
     created_at = DateTimeField(default=datetime.now)
     updated_at = DateTimeField(default=datetime.now)
     deleted = BooleanField(default=False)
 
     def save(self, *args, **kwargs):
         self.updated_at = datetime.now()
-        return super(Thing, self).save(*args, **kwargs)
+        return super(Task, self).save(*args, **kwargs)
 
-    # @property
-    # def due_week(self):
-    #     return self.due.isocalendar()[1] - 12
+    @property
+    def due_week(self):
+        return self.due.isocalendar()[1] - 12
 
 
 class SavedSearch(BaseModel):
@@ -54,7 +57,7 @@ class SavedSearch(BaseModel):
         return self.name
 
 
-class ThingGenerator(BaseModel):
+class TaskGenerator(BaseModel):
     template = CharField()
     type = CharField()
     config = TextField()  # JSON
@@ -84,7 +87,7 @@ class ThingGenerator(BaseModel):
                     month = 1
                     year += 1
 
-            # recurring on 29-31 in Feb will just happen on 28th
+            # recurring tasks on 29-31 in Feb will just happen on 28th
             if day_of_month >= 29 and month == 2:
                 maybe_next = date(year, month, 28)
             else:
@@ -108,5 +111,5 @@ class ThingGenerator(BaseModel):
 
 def initialize_db():
     db.connect()
-    db.create_tables([SavedSearch, ThingGenerator, Thing])
+    db.create_tables([Task, SavedSearch, TaskGenerator])
     db.close()

src/tt/tui/columns.py

@@ -69,9 +69,7 @@ class EnumColumnConfig(TableColumnConfig):
 class DateColumnConfig(TableColumnConfig):
     def preprocess(self, val):
         try:
-            # ensure it parses, return as string
-            datetime.datetime.strptime(val, "%Y-%m-%d")
-            return val
+            return datetime.datetime.strptime(val, "%Y-%m-%d")
         except ValueError:
             raise NotifyValidationError("Invalid date format. Use YYYY-MM-DD")
 

src/tt/tui/editor.py

@@ -15,7 +15,7 @@ from ..utils import (
 )
 from .keymodal import KeyModal
 from .modals import ConfirmModal
-from .columns import get_col_cls, NotifyValidationError
+from .columns import get_col_cls
 
 
 
@@ -105,14 +105,10 @@ class TableEditor(App):
             - sort_string
         """
         self.table_config = []
-        self.view = config.get_view(name)
-
-        # FIXME: special case during things conversion
-        # if recurring, different column definition
+        view = config.get_view(name)
 
         # set up columns
-        for col_name in self.view["columns"]:
-            col = config.get_column(col_name)
+        for col in view["columns"]:
             field_type = col.get("field_type", "text")
             field_cls = get_col_cls(field_type)
             field_name = col["field_name"]
@@ -129,9 +125,8 @@ class TableEditor(App):
             self.table_config.append(cc)
 
         # load default filters
-        self.filters = self.view["filters"]
-        self.sort_string = self.view["sort"]
-        self.defaults = self.view["defaults"]
+        self.filters = view["filters"]
+        self.sort_string = view["sort"]
      
     def _db_item_to_row(self, item):
         """
@@ -140,12 +135,7 @@ class TableEditor(App):
         row = []
 
         for col in self.table_config:
-            # look up properties first (ID, type, etc.)
-            # & fall back to data JSON if not found
-            try:
-                val = getattr(item, col.field)
-            except AttributeError:
-                val = item.data[col.field]
+            val = getattr(item, col.field)
             display_val = col.format_for_display(val)
             row.append(display_val)
 
@@ -243,20 +233,12 @@ class TableEditor(App):
         for fc in self.table_config:
             if fc.read_only:
                 continue
-            val = self.defaults.get(fc.field, fc.default)
+            val = self.filters.get(fc.field, fc.default)
             if val is not None:
                 if "," in val:
                     val = val.split(",")[0]  # TODO: fix hack for enums
                 prepopulated[fc.field] = val
 
-        # required fields
-        for required in ["type"]:
-            if required not in prepopulated:
-                try:
-                    prepopulated[required] = self.defaults[required]
-                except KeyError:
-                    raise Exception(f"must set a default for {required}")
-
         new_item = self.add_item_callback(**prepopulated)
         self.refresh_data(restore_cursor=False)
         self.move_cursor_to_item(new_item.id)  # TODO: check success here

src/tt/tui/recurring.py

@@ -5,12 +5,12 @@ from ..controller.generators import (
     get_generators,
     add_generator,
     update_generator,
-    generate_needed_things,
+    generate_needed_tasks,
 )
 from .editor import ( TableEditor, )
 
 
-class GenEditor(TableEditor):
+class TaskGenEditor(TableEditor):
     def __init__(self):
         super().__init__()
         self.update_item_callback = update_generator
@@ -19,9 +19,9 @@ class GenEditor(TableEditor):
         self.table_config = self._load_config("recurring")
 
     def refresh_items(self):
-        generated = generate_needed_things()
+        generated = generate_needed_tasks()
         if num := len(generated):
-            self.notify(f"created {num} things")
+            self.notify(f"created {num} tasks")
         items = get_generators()
         for item in items:
             self.table.add_row(
@@ -34,5 +34,5 @@ class GenEditor(TableEditor):
 
 
 def run():
-    app = GenEditor()
+    app = TaskGenEditor()
     app.run()

src/tt/tui/tasks.py

@@ -0,0 +1,78 @@
+import json
+from textual.widgets import Input
+
+from ..controller.tasks import (
+    get_task,
+    get_tasks,
+    add_task,
+    update_task,
+    save_view,
+    get_saved_view,
+)
+from .editor import TableEditor
+
+
+class TT(TableEditor):
+
+    BINDINGS = [
+        # saved views
+        ("ctrl+s", "save_view", "save current view"),
+        ("ctrl+o", "load_view", "load saved view"),
+    ]
+
+    def __init__(self, default_view="default"):
+        super().__init__("tasks")
+        self.update_item_callback = update_task
+        self.add_item_callback = add_task
+        self.get_item_callback = get_task
+
+    def _load_db_view(self, name):
+        try:
+            saved = get_saved_view(name)
+            self.filters = json.loads(saved.filters)
+            self.sort_string = saved.sort_string
+        except Exception:
+            self.notify(f"Could not load {name}")
+
+    def action_save_view(self):
+        self._show_input("save-view", "default")
+
+    def action_load_view(self):
+        self._show_input("load-view", "")
+
+    def on_input_submitted(self, event: Input.Submitted):
+        # Override to add save/load view
+        if self.mode == "save-view":
+            save_view(event.value, filters=self.filters, sort_string=self.sort_string)
+            self._hide_input()
+            event.prevent_default()
+        elif self.mode == "load-view":
+            self._load_view(event.value)
+            self.refresh_tasks(restore_cursor=False)
+            self._hide_input()
+            # if event isn't handled here it will bubble to parent
+            event.prevent_default()
+
+    def refresh_items(self):
+        items = get_tasks(
+            self.search_query,
+            projects=self._filters_to_list("project"),
+            statuses=self._filters_to_list("status"),
+            sort=self.sort_string,
+        )
+        for item in items:
+            self.table.add_row(
+                *self._db_item_to_row(item),
+                key=str(item.id),
+            )
+
+    def _filters_to_list(self, key):
+        filters = self.filters.get(key)
+        if filters:
+            return filters.split(",")
+        else:
+            return None
+
+def run(default_view):
+    app = TT(default_view)
+    app.run()

src/tt/tui/things.py

@@ -1,72 +0,0 @@
-from ..controller.things import (
-    get_thing,
-    get_things,
-    add_thing,
-    update_thing,
-)
-from .editor import TableEditor
-
-
-class ThingTable(TableEditor):
-
-    # BINDINGS = [
-    #     # saved views
-    #     ("ctrl+s", "save_view", "save current view"),
-    #     ("ctrl+o", "load_view", "load saved view"),
-    # ]
-
-    def __init__(self, view="default"):
-        super().__init__(view)
-        self.update_item_callback = update_thing
-        self.add_item_callback = add_thing
-        self.get_item_callback = get_thing
-
-    # def _load_db_view(self, name):
-    #     try:
-    #         saved = get_saved_view(name)
-    #         self.filters = json.loads(saved.filters)
-    #         self.sort_string = saved.sort_string
-    #     except Exception:
-    #         self.notify(f"Could not load {name}")
-
-    # def action_save_view(self):
-    #     self._show_input("save-view", "default")
-
-    # def action_load_view(self):
-    #     self._show_input("load-view", "")
-
-    # def on_input_submitted(self, event: Input.Submitted):
-    #     # Override to add save/load view
-    #     if self.mode == "save-view":
-    #         save_view(event.value, filters=self.filters, sort_string=self.sort_string)
-    #         self._hide_input()
-    #         event.prevent_default()
-    #     elif self.mode == "load-view":
-    #         self._load_view(event.value)
-    #         self.refresh_things(restore_cursor=False)
-    #         self._hide_input()
-    #         # if event isn't handled here it will bubble to parent
-    #         event.prevent_default()
-
-    def refresh_items(self):
-        items = get_things(
-            self.search_query,
-            filters={key: self._filters_to_list(key) for key in self.filters},
-            sort=self.sort_string,
-        )
-        for item in items:
-            self.table.add_row(
-                *self._db_item_to_row(item),
-                key=str(item.id),
-            )
-
-    def _filters_to_list(self, key):
-        filters = self.filters.get(key)
-        if filters:
-            return filters.split(",")
-        else:
-            return None
-
-def run(default_view):
-    app = ThingTable(default_view)
-    app.run()

src/tt/utils.py

@@ -39,23 +39,17 @@ def get_color_enum(value: str, enum: dict[str, dict]) -> str:
 
 
 def get_colored_date(date: datetime.date) -> str:
-    if isinstance(date, datetime.date):
-        as_date = date
-        as_str = date.strftime("%Y-%m-%d")
-    elif isinstance(date, str):
-        as_date = datetime.datetime.strptime(date, "%Y-%m-%d").date()
-        as_str = as_date.strftime("%Y-%m-%d")
-    else:
-        return "~bad~"
-
+    if not isinstance(date, datetime.date):
+        return ""
+    as_str = date.strftime("%Y-%m-%d")
     if as_str in SPECIAL_DATES_DISPLAY:
         return SPECIAL_DATES_DISPLAY[as_str]
     today = datetime.date.today()
-    if as_date < today:
+    if date.date() < today:
         return f"[#eeeeee on #dd1111]{as_str}[/]"
     else:
         # Calculate weeks into future
-        delta = as_date - today
+        delta = date.date() - today
         weeks = delta.days // 7
 
         colors = [