taskcheck 1.4.1__tar.gz → 1.5.1__tar.gz

{taskcheck-1.4.1/taskcheck.egg-info → taskcheck-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.4.1
+Version: 1.5.1
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -32,11 +32,12 @@ Use it if you want to:
 - ✨ Auto-schedule tasks from working hours + calendar blocks
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
-- 🧪 Dry-run mode to preview changes
+- 🧪 Persisted dry-run previews for reports and timelines
 - ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
+- 🗓️ Project-grouped timelines with day, week, and month views
 - 🎨 Report styling with emoji and extra attributes
 - 🗓️ Block time with iCal or Google Calendar, including all-day events
 
@@ -76,10 +77,16 @@ monday = [[9, 12.30], [14, 17]]
 tuesday = [[9, 12.30], [14, 17]]
 ```
 
-### Reports
+### Reports and timelines
 
 - `taskcheck -r today` → tasks planned for today
 - `taskcheck -r 1w` → tasks planned for the next week
+- `taskcheck --timeline 1w` → automatic day/week/month timeline for the next week
+- `taskcheck --timeline eom --zoom week` → weekly timeline through month end
+
+Create a preview with `taskcheck --schedule --dry-run`. It does not update Taskwarrior; instead, it saves the generated schedule to the Taskwarrior data directory. Reuse it with `taskcheck --report today --dry-run` or `taskcheck --timeline 1w --dry-run`.
+
+Timeline rows follow dotted project levels such as `work.client`. Without `--zoom`, the most detailed view that fits the terminal width is selected: day, then week, then month. The track uses `▶` for a start, `━` for work, `◀` for an end, and `◆` for a deadline. Thin, heavy, and double rules separate days, weeks, and months. Project colors are deterministic and adapt to light or dark terminals through OSC 11, with config and environment fallbacks.
 
 ## Reference
 

{taskcheck-1.4.1 → taskcheck-1.5.1}/README.md

@@ -17,11 +17,12 @@ Use it if you want to:
 - ✨ Auto-schedule tasks from working hours + calendar blocks
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
-- 🧪 Dry-run mode to preview changes
+- 🧪 Persisted dry-run previews for reports and timelines
 - ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
+- 🗓️ Project-grouped timelines with day, week, and month views
 - 🎨 Report styling with emoji and extra attributes
 - 🗓️ Block time with iCal or Google Calendar, including all-day events
 
@@ -61,10 +62,16 @@ monday = [[9, 12.30], [14, 17]]
 tuesday = [[9, 12.30], [14, 17]]
 ```
 
-### Reports
+### Reports and timelines
 
 - `taskcheck -r today` → tasks planned for today
 - `taskcheck -r 1w` → tasks planned for the next week
+- `taskcheck --timeline 1w` → automatic day/week/month timeline for the next week
+- `taskcheck --timeline eom --zoom week` → weekly timeline through month end
+
+Create a preview with `taskcheck --schedule --dry-run`. It does not update Taskwarrior; instead, it saves the generated schedule to the Taskwarrior data directory. Reuse it with `taskcheck --report today --dry-run` or `taskcheck --timeline 1w --dry-run`.
+
+Timeline rows follow dotted project levels such as `work.client`. Without `--zoom`, the most detailed view that fits the terminal width is selected: day, then week, then month. The track uses `▶` for a start, `━` for work, `◀` for an end, and `◆` for a deadline. Thin, heavy, and double rules separate days, weeks, and months. Project colors are deterministic and adapt to light or dark terminals through OSC 11, with config and environment fallbacks.
 
 ## Reference
 

{taskcheck-1.4.1 → taskcheck-1.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskcheck"
-version = "1.4.1"
+version = "1.5.1"
 description = "Automatic scheduler for taskwarrior"
 readme = "README.md"
 requires-python = ">=3.11"

{taskcheck-1.4.1 → taskcheck-1.5.1}/taskcheck/__main__.py

@@ -4,6 +4,7 @@ from importlib.metadata import version
 
 from taskcheck.parallel import check_tasks_parallel
 from taskcheck.common import config_dir
+from taskcheck.dry_run import load_dry_run_results, save_dry_run_results
 
 arg_parser = argparse.ArgumentParser()
 arg_parser.add_argument("--version", action="version", version=f"taskcheck {version('taskcheck')}")
@@ -22,6 +23,18 @@ arg_parser.add_argument(
     action="store",
     help="Generate a report of the tasks based on the scheduling; can be any Taskwarrior datetime specification (e.g. today, tomorrow, eom, som, 1st, 2nd, etc.). It is considered as `by`, meaning that the report will be generated for all the days until the specified date and including it.",
 )
+arg_parser.add_argument(
+    "-t",
+    "--timeline",
+    action="store",
+    help="Show the schedule as a timeline through the specified Taskwarrior date.",
+)
+arg_parser.add_argument(
+    "--zoom",
+    choices=("auto", "day", "week", "month"),
+    default="auto",
+    help="Set timeline column granularity (default: auto).",
+)
 arg_parser.add_argument(
     "-s",
     "--schedule",
@@ -139,6 +152,8 @@ def main():
             config,
             **check_tasks_kwargs,
         )
+        if args.dry_run and result is not None:
+            save_dry_run_results(result, taskrc=args.taskrc)
         print_help = False
 
     if args.report:
@@ -146,9 +161,8 @@ def main():
 
         config = load_config()
         scheduling_results = None
-        if args.schedule and args.dry_run:
-            # If we just did a dry-run schedule, use those results
-            scheduling_results = result
+        if args.dry_run:
+            scheduling_results = result if args.schedule else load_dry_run_results(args.taskrc)
         generate_report(
             config,
             args.report,
@@ -159,6 +173,29 @@ def main():
         )
         print_help = False
 
+    timeline = getattr(args, "timeline", None)
+    if isinstance(timeline, str):
+        from taskcheck.timeline import generate_timeline
+
+        scheduling_results = result if args.schedule and args.dry_run else None
+        if args.dry_run and scheduling_results is None:
+            scheduling_results = load_dry_run_results(args.taskrc)
+        zoom = getattr(args, "zoom", "day")
+        if zoom not in {"auto", "day", "week", "month"}:
+            zoom = "auto"
+        try:
+            config = load_config().get("timeline", {})
+        except FileNotFoundError:
+            config = {}
+        generate_timeline(
+            timeline,
+            zoom=zoom,
+            taskrc=args.taskrc,
+            scheduling_results=scheduling_results,
+            config=config,
+        )
+        print_help = False
+
     if print_help:
         arg_parser.print_help()
 

taskcheck-1.5.1/taskcheck/dry_run.py

@@ -0,0 +1,22 @@
+import json
+from pathlib import Path
+
+from taskcheck.undo import get_task_data_dir
+
+
+def get_dry_run_path(taskrc=None):
+    return get_task_data_dir(taskrc) / "taskcheck" / "dry-run.json"
+
+
+def save_dry_run_results(results, taskrc=None):
+    path = get_dry_run_path(taskrc)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(results, indent=2, sort_keys=True))
+    return path
+
+
+def load_dry_run_results(taskrc=None):
+    path = get_dry_run_path(taskrc)
+    if not path.exists():
+        return None
+    return json.loads(path.read_text())

{taskcheck-1.4.1 → taskcheck-1.5.1}/taskcheck/install.py

@@ -24,6 +24,9 @@ additional_attributes = []
 additional_attributes_unplanned = []
 # unplanned_max_due = "30d"
 emoji_keywords = {}
+
+[timeline]
+# theme = "auto" # or "light" / "dark"
 """
 
 

{taskcheck-1.4.1 → taskcheck-1.5.1}/taskcheck/report.py

@@ -13,6 +13,8 @@ from rich.table import Table
 from rich.text import Text
 from rich.panel import Panel
 
+from taskcheck.theme import detect_theme
+
 from random_unicode_emoji import random_emoji
 
 
@@ -280,22 +282,23 @@ def get_unplanned_tasks(config, tasks, taskrc=None):
 
 
 def generate_report(config, constraint, verbose=False, force_update=False, taskrc=None, scheduling_results=None):
-    config = config["report"]
+    report_config = config["report"]
+    theme = detect_theme(config=config.get("timeline", {}))
     console = Console()
     
     original_tasks = fetch_tasks(taskrc)
     tasks = scheduling_results if scheduling_results is not None else original_tasks
 
-    if config.get("include_unplanned"):
-        unplanned_tasks = get_unplanned_tasks(config, original_tasks, taskrc=taskrc)
-        display_unplanned_tasks(console, config, unplanned_tasks)
+    if report_config.get("include_unplanned"):
+        unplanned_tasks = get_unplanned_tasks(report_config, original_tasks, taskrc=taskrc)
+        display_unplanned_tasks(console, report_config, unplanned_tasks, theme=theme)
 
     for year, month, day in get_days_in_constraint(constraint, taskrc=taskrc):
-        this_day_tasks = get_tasks(config, tasks, year, month, day)
+        this_day_tasks = get_tasks(report_config, tasks, year, month, day)
 
-        display_date_header(console, year, month, day)
+        display_date_header(console, year, month, day, theme=theme)
 
-        display_tasks_table(console, config, this_day_tasks)
+        display_tasks_table(console, report_config, this_day_tasks, theme=theme)
 
 
 def parse_taskwarrior_timestamp(value):
@@ -321,24 +324,26 @@ def fetch_tasks(taskrc=None):
     return json.loads(tasks.stdout)
 
 
-def display_date_header(console, year, month, day):
+def display_date_header(console, year, month, day, theme="dark"):
     """Display a date header with a calendar emoji."""
-    date_str = f":calendar: [bold cyan]{year}-{month}-{day}[/bold cyan]"
-    console.print(Panel(date_str, style="bold blue", expand=False))
+    accent = "cyan" if theme == "dark" else "blue"
+    date_str = f":calendar: [bold {accent}]{year}-{month}-{day}[/bold {accent}]"
+    console.print(Panel(date_str, style=f"bold {accent}", expand=False))
 
 
-def display_tasks_table(console, config, tasks):
+def display_tasks_table(console, config, tasks, theme="dark"):
     """Display a table of tasks for a specific day."""
     if tasks:
-        table = build_tasks_table(config, tasks)
+        table = build_tasks_table(config, tasks, theme=theme)
         console.print(table)
     else:
         console.print("[italic dim]No tasks scheduled for this day.[/italic dim]")
 
 
-def build_tasks_table(config, tasks):
+def build_tasks_table(config, tasks, theme="dark"):
     """Build a Rich table for displaying tasks."""
-    table = Table(show_header=True, header_style="bold blue")
+    header_style = "bold cyan" if theme == "dark" else "bold blue"
+    table = Table(show_header=True, header_style=header_style)
     table.add_column("Task", style="dim", width=12)
     table.add_column("Project", style="dim", width=12)
     table.add_column("Description")
@@ -388,11 +393,12 @@ def get_task_emoji(config, task):
     return emoji
 
 
-def display_unplanned_tasks(console, config, tasks):
+def display_unplanned_tasks(console, config, tasks, theme="dark"):
     """Display unplanned tasks if any are found."""
     if tasks:
-        table = build_unplanned_tasks_table(config, tasks)
-        console.print(Panel("Unplanned Tasks", style="bold blue", expand=False))
+        accent = "cyan" if theme == "dark" else "blue"
+        table = build_unplanned_tasks_table(config, tasks, theme=theme)
+        console.print(Panel("Unplanned Tasks", style=f"bold {accent}", expand=False))
         console.print(table)
     else:
         console.print(
@@ -404,9 +410,10 @@ def display_unplanned_tasks(console, config, tasks):
         )
 
 
-def build_unplanned_tasks_table(config, tasks):
+def build_unplanned_tasks_table(config, tasks, theme="dark"):
     """Build a Rich table for displaying unplanned tasks."""
-    table = Table(show_header=True, header_style="bold blue")
+    header_style = "bold cyan" if theme == "dark" else "bold blue"
+    table = Table(show_header=True, header_style=header_style)
     table.add_column("Task", style="dim", width=12)
     table.add_column("Project", style="dim", width=12)
     table.add_column("Description")

taskcheck-1.5.1/taskcheck/theme.py

@@ -0,0 +1,67 @@
+import os
+import re
+import selectors
+import termios
+import tty
+
+OSC11_QUERY = b"\x1b]11;?\x07"
+OSC11_RESPONSE = re.compile(rb"\x1b]11;(?P<spec>[^\x07\x1b]+)(?:\x07|\x1b\\)")
+
+
+def _parse_osc11_background(spec):
+    text = spec.decode(errors="ignore").strip().lower()
+    if text.startswith("rgb:"):
+        channels = text[4:].split("/")[:3]
+        try:
+            rgb = [int(channel[: len(channel) // 2 or 1], 16) for channel in channels]
+        except ValueError:
+            return None
+        return "light" if sum(rgb) / 3 >= 128 else "dark"
+    return None
+
+
+def _probe_osc11_background(timeout=0.2):
+    try:
+        with open("/dev/tty", "rb+", buffering=0) as tty_file:
+            fd = tty_file.fileno()
+            old = termios.tcgetattr(fd)
+            try:
+                tty.setraw(fd)
+                tty_file.write(OSC11_QUERY)
+                sel = selectors.DefaultSelector()
+                sel.register(tty_file, selectors.EVENT_READ)
+                events = sel.select(timeout)
+                if not events:
+                    return None
+                data = tty_file.read(128)
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    except (OSError, termios.error):
+        return None
+    if not data:
+        return None
+    match = OSC11_RESPONSE.search(data)
+    if not match:
+        return None
+    return _parse_osc11_background(match.group("spec"))
+
+
+def detect_theme(environ=None, config=None):
+    environ = os.environ if environ is None else environ
+    config = config or {}
+    for key in ("TASKCHECK_THEME", "PI_THEME"):
+        value = environ.get(key, "").strip().lower()
+        if value in {"light", "dark"}:
+            return value
+    value = str(config.get("theme", "")).strip().lower()
+    if value in {"light", "dark"}:
+        return value
+    osc11 = _probe_osc11_background()
+    if osc11:
+        return osc11
+    value = environ.get("COLORFGBG", "")
+    try:
+        background = int(value.split(";")[-1])
+    except ValueError:
+        return "dark"
+    return "light" if background >= 8 else "dark"

taskcheck-1.5.1/taskcheck/timeline.py

@@ -0,0 +1,233 @@
+import colorsys
+import hashlib
+import re
+from dataclasses import dataclass
+from datetime import date, datetime, timedelta
+
+from rich.console import Console, Group
+from rich.text import Text
+
+from taskcheck.report import (
+    fetch_tasks,
+    get_taskwarrior_date,
+    parse_taskwarrior_timestamp,
+)
+from taskcheck.theme import detect_theme
+
+SCHEDULING_DATE = re.compile(r"^(\d{4}-\d{2}-\d{2})\s+-\s+P")
+
+
+@dataclass(frozen=True)
+class Period:
+    start: date
+    end: date
+    label: str
+    width: int
+
+
+
+
+def project_color(project, theme):
+    digest = hashlib.sha256((project or "No project").encode()).digest()
+    hue = int.from_bytes(digest[:3], "big") / 0xFFFFFF
+    lightness = 0.32 if theme == "light" else 0.72
+    red, green, blue = colorsys.hls_to_rgb(hue, lightness, 0.68)
+    return f"#{round(red * 255):02x}{round(green * 255):02x}{round(blue * 255):02x}"
+
+
+def parse_scheduling_dates(task):
+    dates = []
+    for line in task.get("scheduling", "").splitlines():
+        match = SCHEDULING_DATE.match(line)
+        if match:
+            dates.append(date.fromisoformat(match.group(1)))
+    return sorted(set(dates))
+
+
+def _deadline(task):
+    value = task.get("due")
+    if not value:
+        return None
+    try:
+        return parse_taskwarrior_timestamp(value).date()
+    except ValueError:
+        try:
+            return date.fromisoformat(value[:10])
+        except ValueError:
+            return None
+
+
+def _periods(start, end, zoom):
+    periods = []
+    current = start
+    if zoom == "week":
+        current -= timedelta(days=current.weekday())
+    elif zoom == "month":
+        current = current.replace(day=1)
+
+    while current <= end:
+        if zoom == "day":
+            period_end = current
+            label = current.strftime("%d")
+            width = 3
+            next_period = current + timedelta(days=1)
+        elif zoom == "week":
+            period_end = current + timedelta(days=6)
+            label = f"W{current.isocalendar().week:02d}"
+            width = 5
+            next_period = current + timedelta(days=7)
+        else:
+            if current.month == 12:
+                next_period = date(current.year + 1, 1, 1)
+            else:
+                next_period = date(current.year, current.month + 1, 1)
+            period_end = next_period - timedelta(days=1)
+            label = current.strftime("%b %Y")
+            width = 8
+        periods.append(Period(current, period_end, label, width))
+        current = next_period
+    return periods
+
+
+def select_zoom(start, end, columns, label_width):
+    for zoom in ("day", "week", "month"):
+        periods = _periods(start, end, zoom)
+        if label_width + sum(period.width + 1 for period in periods) <= columns:
+            return zoom
+    return "month"
+
+
+def _separator(periods, index, zoom):
+    if index == 0:
+        return "║"
+    current = periods[index].start
+    previous = periods[index - 1].start
+    if zoom == "month" or (current.year, current.month) != (
+        previous.year,
+        previous.month,
+    ):
+        return "║"
+    if zoom == "week" or current.weekday() == 0:
+        return "┃"
+    return "│"
+
+
+def _cell(task_dates, deadline, period):
+    scheduled = [day for day in task_dates if period.start <= day <= period.end]
+    starts = bool(task_dates) and period.start <= task_dates[0] <= period.end
+    ends = bool(task_dates) and period.start <= task_dates[-1] <= period.end
+    due = deadline is not None and period.start <= deadline <= period.end
+
+    if starts and ends:
+        core = "▶━◀"
+    elif starts:
+        core = "▶━━"
+    elif ends:
+        core = "━━◀"
+    elif scheduled:
+        core = "━━━"
+    else:
+        core = "   "
+    if due:
+        core = core[0] + "◆" + core[2]
+    return core.center(period.width)
+
+
+def _label(text, width):
+    if len(text) <= width:
+        return text.ljust(width)
+    return text[: width - 1] + "…"
+
+
+def _header(periods, label_width, zoom):
+    lines = []
+    if zoom in {"day", "week"}:
+        context = Text(" " * label_width)
+        previous_month = None
+        for index, period in enumerate(periods):
+            context.append(_separator(periods, index, zoom), style="dim")
+            month = (period.start.year, period.start.month)
+            label = period.start.strftime("%b") if month != previous_month else ""
+            context.append(label.center(period.width), style="bold cyan")
+            previous_month = month
+        lines.append(context)
+
+    line = Text(" " * label_width)
+    for index, period in enumerate(periods):
+        line.append(_separator(periods, index, zoom), style="dim")
+        line.append(period.label.center(period.width), style="bold")
+    lines.append(line)
+    return lines
+
+
+def build_timeline(
+    tasks, start, end, zoom="auto", theme=None, config=None, columns=80
+):
+    if zoom not in {"auto", "day", "week", "month"}:
+        raise ValueError(f"Unsupported zoom: {zoom}")
+    planned = [(task, parse_scheduling_dates(task)) for task in tasks]
+    planned = [(task, dates) for task, dates in planned if dates]
+    planned.sort(key=lambda item: (item[0].get("project", ""), item[0].get("id", 0)))
+    labels = [
+        f"#{task.get('id', '?')} {task.get('description', '')}" for task, _ in planned
+    ]
+    label_width = min(36, max([20, *(len(label) + 6 for label in labels)]))
+    zoom = select_zoom(start, end, columns, label_width) if zoom == "auto" else zoom
+    periods = _periods(start, end, zoom)
+    theme = theme or detect_theme(config=config)
+
+    lines = [
+        Text(
+            f"Timeline · {zoom} · ▶ start · ━ work · ◀ end · ◆ deadline", style="bold"
+        ),
+        *_header(periods, label_width, zoom),
+    ]
+    previous_parts = []
+    for task, dates in planned:
+        project = task.get("project") or "No project"
+        parts = project.split(".")
+        common = 0
+        while (
+            common < min(len(parts), len(previous_parts))
+            and parts[common] == previous_parts[common]
+        ):
+            common += 1
+        for depth in range(common, len(parts)):
+            path = ".".join(parts[: depth + 1])
+            group = Text(
+                _label("  " * depth + parts[depth], label_width),
+                style=f"bold {project_color(path, theme)}",
+            )
+            for index, period in enumerate(periods):
+                group.append(_separator(periods, index, zoom), style="dim")
+                group.append(" " * period.width)
+            lines.append(group)
+        previous_parts = parts
+
+        color = project_color(project, theme)
+        row = Text(
+            _label(
+                "  " * len(parts)
+                + f"#{task.get('id', '?')} {task.get('description', '')}",
+                label_width,
+            ),
+            style=color,
+        )
+        deadline = _deadline(task)
+        for index, period in enumerate(periods):
+            row.append(_separator(periods, index, zoom), style="dim")
+            row.append(_cell(dates, deadline, period), style=f"bold {color}")
+        lines.append(row)
+    return Group(*lines)
+
+
+def generate_timeline(constraint, zoom="auto", taskrc=None, scheduling_results=None, config=None):
+    start = datetime.today().date()
+    end = get_taskwarrior_date(constraint, taskrc=taskrc).date()
+    tasks = (
+        scheduling_results if scheduling_results is not None else fetch_tasks(taskrc)
+    )
+    console = Console()
+    console.print(
+        build_timeline(tasks, start, end, zoom, config=config, columns=console.width)
+    )

{taskcheck-1.4.1 → taskcheck-1.5.1/taskcheck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskcheck
-Version: 1.4.1
+Version: 1.5.1
 Summary: Automatic scheduler for taskwarrior
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -32,11 +32,12 @@ Use it if you want to:
 - ✨ Auto-schedule tasks from working hours + calendar blocks
 - 🧭 Support complex working-hour maps
 - ⏱️ Consider urgency, due dates, and dependencies
-- 🧪 Dry-run mode to preview changes
+- 🧪 Persisted dry-run previews for reports and timelines
 - ↩️ Undo the latest schedule update
 - 🧠 Auto-adjust urgency when deadlines cannot be met
 - 🔄 Force-refresh iCal calendars
 - 📊 Custom reports for planned and unplanned tasks
+- 🗓️ Project-grouped timelines with day, week, and month views
 - 🎨 Report styling with emoji and extra attributes
 - 🗓️ Block time with iCal or Google Calendar, including all-day events
 
@@ -76,10 +77,16 @@ monday = [[9, 12.30], [14, 17]]
 tuesday = [[9, 12.30], [14, 17]]
 ```
 
-### Reports
+### Reports and timelines
 
 - `taskcheck -r today` → tasks planned for today
 - `taskcheck -r 1w` → tasks planned for the next week
+- `taskcheck --timeline 1w` → automatic day/week/month timeline for the next week
+- `taskcheck --timeline eom --zoom week` → weekly timeline through month end
+
+Create a preview with `taskcheck --schedule --dry-run`. It does not update Taskwarrior; instead, it saves the generated schedule to the Taskwarrior data directory. Reuse it with `taskcheck --report today --dry-run` or `taskcheck --timeline 1w --dry-run`.
+
+Timeline rows follow dotted project levels such as `work.client`. Without `--zoom`, the most detailed view that fits the terminal width is selected: day, then week, then month. The track uses `▶` for a start, `━` for work, `◀` for an end, and `◆` for a deadline. Thin, heavy, and double rules separate days, weeks, and months. Project colors are deterministic and adapt to light or dark terminals through OSC 11, with config and environment fallbacks.
 
 ## Reference
 

{taskcheck-1.4.1 → taskcheck-1.5.1}/taskcheck.egg-info/SOURCES.txt

@@ -3,11 +3,14 @@ README.md
 pyproject.toml
 taskcheck/__main__.py
 taskcheck/common.py
+taskcheck/dry_run.py
 taskcheck/google_calendar.py
 taskcheck/ical.py
 taskcheck/install.py
 taskcheck/parallel.py
 taskcheck/report.py
+taskcheck/theme.py
+taskcheck/timeline.py
 taskcheck/undo.py
 taskcheck.egg-info/PKG-INFO
 taskcheck.egg-info/SOURCES.txt
@@ -22,4 +25,5 @@ tests/test_install.py
 tests/test_main.py
 tests/test_parallel.py
 tests/test_report.py
+tests/test_timeline.py
 tests/test_undo.py

{taskcheck-1.4.1 → taskcheck-1.5.1}/tests/test_main.py

@@ -14,6 +14,8 @@ class TestArgumentParsing:
         assert args.verbose is False
         assert args.install is False
         assert args.report is None
+        assert args.timeline is None
+        assert args.zoom == "auto"
         assert args.schedule is False
         assert args.undo is False
         assert args.force_update is False
@@ -74,6 +76,12 @@ class TestArgumentParsing:
         assert args.taskrc == "/test"
         assert args.urgency_weight == 0.3
 
+    def test_timeline_arguments(self):
+        args = arg_parser.parse_args(["--timeline", "eom", "--zoom", "month"])
+
+        assert args.timeline == "eom"
+        assert args.zoom == "month"
+
     def test_urgency_weight_argument(self):
         """Test urgency weight argument parsing."""
         args = arg_parser.parse_args(["--urgency-weight", "0.7"])
@@ -405,10 +413,11 @@ class TestMainFunction:
                     auto_adjust_urgency=True,
                 )
 
+    @patch("taskcheck.__main__.save_dry_run_results")
     @patch("taskcheck.__main__.load_config")
     @patch("taskcheck.__main__.check_tasks_parallel")
     def test_main_schedule_with_dry_run(
-        self, mock_check_tasks, mock_load_config, sample_config, test_taskrc
+        self, mock_check_tasks, mock_load_config, mock_save, sample_config, test_taskrc
     ):
         """Test that dry-run mode returns scheduling results without modifying tasks."""
         mock_load_config.return_value = sample_config
@@ -429,6 +438,7 @@ class TestMainFunction:
             }
         ]
         mock_check_tasks.return_value = dry_run_results
+        mock_save.return_value = None
 
         with patch(
             "sys.argv",
@@ -461,6 +471,7 @@ class TestMainFunction:
         )
         mock_load_config.assert_called_once()
 
+    @patch("taskcheck.__main__.save_dry_run_results")
     @patch("taskcheck.__main__.load_config")
     @patch("taskcheck.__main__.check_tasks_parallel")
     @patch("taskcheck.report.generate_report")
@@ -469,6 +480,7 @@ class TestMainFunction:
         mock_generate_report,
         mock_check_tasks,
         mock_load_config,
+        mock_save,
         sample_config,
         test_taskrc,
     ):
@@ -491,6 +503,7 @@ class TestMainFunction:
             }
         ]
         mock_check_tasks.return_value = dry_run_results
+        mock_save.return_value = None
 
         with patch(
             "sys.argv",
@@ -528,6 +541,7 @@ class TestMainFunction:
             taskrc=test_taskrc,
             scheduling_results=dry_run_results,
         )
+        mock_save.assert_called_once_with(dry_run_results, taskrc=test_taskrc)
 
         # Verify that check_tasks_parallel was called with dry_run=True
         mock_check_tasks.assert_called_once_with(
@@ -540,6 +554,43 @@ class TestMainFunction:
             auto_adjust_urgency=True,
         )
 
+    @patch("taskcheck.__main__.load_dry_run_results")
+    @patch("taskcheck.__main__.load_config")
+    @patch("taskcheck.report.generate_report")
+    def test_main_report_dry_run_loads_cached_results(
+        self, mock_generate_report, mock_load_config, mock_load_cache, sample_config, test_taskrc
+    ):
+        mock_load_config.return_value = sample_config
+        cached = [{"id": "1", "scheduling": "2024-12-20 - PT2H"}]
+        mock_load_cache.return_value = cached
+
+        with patch("sys.argv", ["taskcheck", "--report", "today", "--dry-run", "--taskrc", test_taskrc]):
+            with patch("taskcheck.__main__.arg_parser.parse_args") as mock_parse:
+                mock_args = Mock()
+                mock_args.install = False
+                mock_args.schedule = False
+                mock_args.report = "today"
+                mock_args.timeline = None
+                mock_args.zoom = "auto"
+                mock_args.verbose = False
+                mock_args.force_update = False
+                mock_args.taskrc = test_taskrc
+                mock_args.urgency_weight = None
+                mock_args.dry_run = True
+                mock_args.auto_adjust_urgency = True
+                mock_parse.return_value = mock_args
+                main()
+
+        mock_load_cache.assert_called_once_with(test_taskrc)
+        mock_generate_report.assert_called_once_with(
+            sample_config,
+            "today",
+            False,
+            force_update=False,
+            taskrc=test_taskrc,
+            scheduling_results=cached,
+        )
+
     @patch("taskcheck.__main__.load_config")
     def test_main_config_loading_error(self, mock_load_config):
         """Test behavior when config loading fails."""
@@ -592,6 +643,26 @@ class TestMainFunction:
                     mock_load.assert_not_called()
 
 
+    @patch("taskcheck.timeline.generate_timeline")
+    def test_main_timeline_command(self, mock_generate, test_taskrc):
+        with patch(
+            "sys.argv",
+            [
+                "taskcheck",
+                "--timeline",
+                "eom",
+                "--zoom",
+                "month",
+                "--taskrc",
+                test_taskrc,
+            ],
+        ):
+            main()
+
+        mock_generate.assert_called_once()
+        assert mock_generate.call_args.kwargs["config"] == {}
+
+
 class TestImportErrorHandling:
     def test_install_import_error(self):
         """Test behavior when install module cannot be imported."""

taskcheck-1.5.1/tests/test_timeline.py

@@ -0,0 +1,130 @@
+from datetime import date
+
+from rich.console import Console
+
+from taskcheck.timeline import (
+    build_timeline,
+    detect_theme,
+    parse_scheduling_dates,
+    project_color,
+    select_zoom,
+)
+
+
+def render(renderable):
+    console = Console(width=200, record=True, color_system=None)
+    console.print(renderable)
+    return console.export_text()
+
+
+def test_parse_scheduling_dates_ignores_invalid_lines():
+    task = {"scheduling": "2024-01-02 - PT2H\ninvalid\n2024-01-03 - PT30M"}
+
+    assert parse_scheduling_dates(task) == [date(2024, 1, 2), date(2024, 1, 3)]
+
+
+def test_day_timeline_groups_projects_and_marks_events():
+    tasks = [
+        {
+            "id": 1,
+            "project": "work.client",
+            "description": "Build feature",
+            "scheduling": "2024-01-01 - PT2H\n2024-01-02 - PT2H\n2024-01-03 - PT1H",
+            "due": "20240102T170000Z",
+        },
+        {
+            "id": 2,
+            "project": "home",
+            "description": "Repair shelf",
+            "scheduling": "2024-01-02 - PT1H",
+        },
+    ]
+
+    output = render(
+        build_timeline(tasks, date(2024, 1, 1), date(2024, 1, 3), "day", "dark")
+    )
+
+    assert "▶ start" in output
+    assert "━ work" in output
+    assert "◀ end" in output
+    assert "◆ deadline" in output
+    assert "work" in output
+    assert "  client" in output
+    assert "#1 Build feature" in output
+    assert "▶━━│━◆━│━━◀" in output
+    assert "▶━◀" in output
+
+
+def test_select_zoom_uses_the_most_detailed_view_that_fits():
+    start = date(2024, 1, 1)
+    end = date(2024, 1, 31)
+
+    assert select_zoom(start, end, 200, 20) == "day"
+    assert select_zoom(start, end, 80, 20) == "week"
+    assert select_zoom(start, end, 40, 20) == "month"
+
+
+def test_day_boundaries_distinguish_week_and_month():
+    output = render(
+        build_timeline([], date(2024, 1, 28), date(2024, 2, 2), "day", "dark")
+    )
+
+    assert "┃" in output  # week boundary
+    assert "║" in output  # month boundary
+    assert "│" in output  # day boundary
+
+
+def test_week_and_month_zoom_aggregate_events():
+    tasks = [
+        {
+            "id": 1,
+            "project": "work",
+            "description": "Long task",
+            "scheduling": "2024-01-30 - PT1H\n2024-02-12 - PT1H",
+            "due": "20240215T120000Z",
+        }
+    ]
+
+    week = render(
+        build_timeline(tasks, date(2024, 1, 29), date(2024, 2, 18), "week", "dark")
+    )
+    month = render(
+        build_timeline(tasks, date(2024, 1, 1), date(2024, 2, 29), "month", "dark")
+    )
+
+    assert "W05" in week and "W07" in week
+    assert "Jan 2024" in month and "Feb 2024" in month
+    assert "▶" in week and "◀" in week and "◆" in week
+    assert "▶" in month and "◀" in month and "◆" in month
+
+
+def test_auto_zoom_uses_available_columns():
+    output = render(
+        build_timeline([], date(2024, 1, 1), date(2024, 1, 31), columns=80)
+    )
+
+    assert "Timeline · week" in output
+
+
+def test_build_timeline_uses_config_theme():
+    output = render(
+        build_timeline([], date(2024, 1, 1), date(2024, 1, 1), "day", config={"theme": "light"})
+    )
+
+    assert "Timeline · day" in output
+
+
+def test_theme_detection_and_project_colors(monkeypatch):
+    monkeypatch.setattr("taskcheck.theme._probe_osc11_background", lambda: "light")
+    assert detect_theme() == "light"
+    monkeypatch.setattr("taskcheck.theme._probe_osc11_background", lambda: None)
+    monkeypatch.setenv("COLORFGBG", "0;15")
+    assert detect_theme() == "light"
+    monkeypatch.setenv("COLORFGBG", "15;0")
+    assert detect_theme() == "dark"
+    assert detect_theme(config={"theme": "light"}) == "light"
+    assert detect_theme(config={"theme": "dark"}) == "dark"
+
+    assert project_color("work", "dark") == project_color("work", "dark")
+    assert project_color("work", "dark") != project_color("home", "dark")
+    assert project_color("work", "dark") != project_color("work", "light")