leadger 0.1.0__py3-none-any.whl

leadger/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

leadger/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m leadger` as an alias for the `leadger` command."""
+
+from .cli import app
+
+app()

leadger/cli.py

@@ -0,0 +1,253 @@
+"""Leadger CLI - typer entry point."""
+
+from __future__ import annotations
+
+import socket
+import threading
+import time
+import webbrowser
+from datetime import timedelta
+from pathlib import Path
+from typing import Optional
+
+import typer
+import uvicorn
+
+app = typer.Typer(
+    name="leadger",
+    help="Leadger - produtividade pessoal local, calma e enxuta.",
+    invoke_without_command=True,
+)
+
+DEFAULT_DATA_PATH = Path.home() / ".leadger" / "leadger.yaml"
+DEFAULT_PORT = 4242
+
+
+def _find_free_port(start: int = DEFAULT_PORT, attempts: int = 50) -> int:
+    """Return the first free TCP port starting at `start`."""
+    for port in range(start, start + attempts):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            try:
+                sock.bind(("127.0.0.1", port))
+            except OSError:
+                continue
+            return port
+    raise RuntimeError(
+        f"Nenhuma porta livre entre {start} e {start + attempts - 1}"
+    )
+
+
+def _run_serve(data_path: Path, port: Optional[int], open_browser: bool) -> None:
+    from leadger.server import create_app
+
+    chosen_port = port or _find_free_port()
+    fastapi_app = create_app(data_path)
+
+    if open_browser:
+
+        def _open() -> None:
+            time.sleep(0.5)
+            webbrowser.open(f"http://127.0.0.1:{chosen_port}")
+
+        threading.Thread(target=_open, daemon=True).start()
+
+    typer.echo(f"Leadger em http://127.0.0.1:{chosen_port}  (dados: {data_path})")
+    uvicorn.run(fastapi_app, host="127.0.0.1", port=chosen_port, log_level="warning")
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    data: Optional[Path] = typer.Option(
+        None,
+        "--data",
+        envvar="LEADGER_DATA",
+        help="Caminho para o arquivo leadger.yaml (default: ~/.leadger/leadger.yaml)",
+    ),
+) -> None:
+    """Leadger - produtividade pessoal local, calma e enxuta."""
+    ctx.obj = {"data": data or DEFAULT_DATA_PATH}
+    if ctx.invoked_subcommand is None:
+        _run_serve(ctx.obj["data"], port=None, open_browser=True)
+
+
+@app.command()
+def serve(
+    ctx: typer.Context,
+    port: Optional[int] = typer.Option(
+        None,
+        "--port",
+        help="Porta do servidor (default: primeira porta livre a partir de 4242)",
+    ),
+    no_browser: bool = typer.Option(
+        False, "--no-browser", help="Nao abre o navegador automaticamente"
+    ),
+) -> None:
+    """Sobe o servidor web local e abre o navegador."""
+    _run_serve(ctx.obj["data"], port=port, open_browser=not no_browser)
+
+
+def _open_storage(ctx: typer.Context):
+    from leadger.core import CorruptedYAMLError, Storage
+
+    try:
+        return Storage(ctx.obj["data"])
+    except CorruptedYAMLError as exc:
+        typer.echo(f"Erro: {exc}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def add(
+    ctx: typer.Context,
+    text: str = typer.Argument(
+        ...,
+        help="Texto da tarefa (suporta #tag, !data e recorrencia, ex.: !amanha, !rec:seg)",
+    ),
+) -> None:
+    """Adiciona uma tarefa direto pelo terminal."""
+    from leadger.core.parse import parse_inline
+
+    storage = _open_storage(ctx)
+    parsed = parse_inline(text, storage.today())
+    if not parsed.title:
+        typer.echo("Erro: tarefa sem titulo.", err=True)
+        raise typer.Exit(1)
+
+    task = storage.add_task(
+        parsed.title, target=parsed.target, tags=parsed.tags, recur=parsed.recur
+    )
+    tags_label = "  " + " ".join(f"#{tag}" for tag in task.tags) if task.tags else ""
+    recur_label = f"  (rec: {task.recur})" if task.recur else ""
+    typer.echo(
+        f"Adicionada: {task.title} -> {task.target.isoformat()}{tags_label}{recur_label}"
+    )
+
+
+_STATUS_SECTIONS = [
+    ("A fazer", "todo", "[ ]"),
+    ("Pausadas", "paused", "[~]"),
+    ("Concluidas", "done", "[x]"),
+]
+
+
+@app.command()
+def today(ctx: typer.Context) -> None:
+    """Mostra o resumo do dia atual: meta, entregues, % e lista."""
+    storage = _open_storage(ctx)
+    metrics = storage.get_day_metrics()
+
+    if metrics.bonus_day:
+        pct_label = "dia bonus"
+    elif metrics.pct is None:
+        pct_label = "-"
+    else:
+        pct_label = f"{metrics.pct:.0f}%"
+    extras_label = f" ({metrics.extras_done} extras)" if metrics.extras_done else ""
+    typer.echo(
+        f"{metrics.date.isoformat()}  |  meta {metrics.goal}"
+        f"  |  entregues {metrics.done}{extras_label}  |  {pct_label}"
+    )
+
+    day_tasks = [task for task in storage.all_tasks() if task.target == metrics.date]
+    for label, status, marker in _STATUS_SECTIONS:
+        section = [task for task in day_tasks if task.status.value == status]
+        if not section:
+            continue
+        typer.echo(f"\n{label}:")
+        for task in section:
+            tags_label = "  " + " ".join(f"#{tag}" for tag in task.tags) if task.tags else ""
+            recur_label = f"  (rec: {task.recur})" if task.recur else ""
+            rotten = f"  (migrada {task.migrations}x)" if task.migrations >= 3 else ""
+            typer.echo(f"  {marker} {task.title}{tags_label}{recur_label}{rotten}")
+
+
+_WEEKDAY_LABELS = ["seg", "ter", "qua", "qui", "sex", "sab", "dom"]
+
+
+@app.command()
+def week(ctx: typer.Context) -> None:
+    """Resumo da semana: % por dia, agregado e tarefas (nao) concluidas."""
+    from leadger.core.periods import period_range
+
+    storage = _open_storage(ctx)
+    today_metrics = storage.get_day_metrics()  # runs the lazy snapshot + rollover
+    today = today_metrics.date
+    start, end = period_range("week", today)
+    recorded = set(storage.recorded_days())
+
+    week_days = [start + timedelta(days=i) for i in range(7)]
+    day_metrics = {day: storage.get_day_metrics(day) for day in week_days if day in recorded}
+    goal_sum = sum(m.goal for m in day_metrics.values())
+    done_sum = sum(m.done for m in day_metrics.values())
+    if goal_sum == 0:
+        week_pct = "dia bonus" if done_sum > 0 else "0%"
+    else:
+        week_pct = f"{done_sum / goal_sum * 100:.0f}%"
+    typer.echo(
+        f"Semana {start.isoformat()} -> {end.isoformat()}"
+        f"  |  meta {goal_sum}  |  entregues {done_sum}  |  {week_pct}"
+    )
+
+    typer.echo("")
+    for i, day in enumerate(week_days):
+        marker = "*" if day == today else " "
+        label = f"{_WEEKDAY_LABELS[i]} {day.day:02d}"
+        metrics = day_metrics.get(day)
+        if metrics is None:
+            typer.echo(f" {marker}{label}   -")
+            continue
+        if metrics.bonus_day:
+            pct_label = "dia bonus"
+        elif metrics.pct is None:
+            pct_label = "-"
+        else:
+            pct_label = f"{metrics.pct:.0f}%"
+        typer.echo(
+            f" {marker}{label}   meta {metrics.goal}  entregues {metrics.done}  {pct_label}"
+        )
+
+    week_tasks = [
+        task
+        for task in storage.all_tasks()
+        if start <= task.target <= end and task.status.value != "cancelled"
+    ]
+    week_tasks.sort(key=lambda task: (task.target, task.created.isoformat()))
+    open_tasks = [task for task in week_tasks if task.status.value != "done"]
+    done_tasks = [task for task in week_tasks if task.status.value == "done"]
+
+    def _echo_section(label: str, marker: str, tasks: list) -> None:
+        typer.echo(f"\n{label} ({len(tasks)}):")
+        for task in tasks:
+            tags_label = "  " + " ".join(f"#{tag}" for tag in task.tags) if task.tags else ""
+            recur_label = f"  (rec: {task.recur})" if task.recur else ""
+            day_label = f"({_WEEKDAY_LABELS[task.target.weekday()]} {task.target.day:02d})"
+            typer.echo(f"  {marker} {task.title}{tags_label}{recur_label}  {day_label}")
+
+    _echo_section("Nao concluidas", "[ ]", open_tasks)
+    _echo_section("Concluidas", "[x]", done_tasks)
+
+
+@app.command()
+def ics(
+    ctx: typer.Context,
+    out: Optional[Path] = typer.Option(
+        None, "--out", help="Grava o .ics nesse arquivo (default: imprime no stdout)"
+    ),
+) -> None:
+    """Exporta as tarefas abertas como iCalendar (.ics), com RRULE para recorrentes."""
+    from leadger.core.ics import tasks_to_ics
+
+    storage = _open_storage(ctx)
+    storage.ensure_day()
+    content = tasks_to_ics(storage.all_tasks(), now=storage.now())
+    if out:
+        out.write_text(content, encoding="utf-8", newline="")  # keep the RFC's CRLF
+        typer.echo(f"Calendario exportado: {out}")
+    else:
+        typer.echo(content, nl=False)
+
+
+if __name__ == "__main__":
+    app()

leadger/core/__init__.py

@@ -0,0 +1,14 @@
+"""Leadger core domain: YAML storage, task state machine, day metrics."""
+
+from .storage import DayMetrics, Storage
+from .tasks import InvalidTransitionError, Task, TaskStatus
+from .yaml_io import CorruptedYAMLError
+
+__all__ = [
+    "Storage",
+    "DayMetrics",
+    "Task",
+    "TaskStatus",
+    "InvalidTransitionError",
+    "CorruptedYAMLError",
+]

leadger/core/ics.py

@@ -0,0 +1,82 @@
+"""Read-only iCalendar export: open tasks as all-day events. Recurrence
+becomes RRULE, so the whole series shows up projected on the calendar even
+though the YAML only holds the current occurrence.
+
+No cloud: the file is generated locally (CLI `leadger ics`) or served at
+`/calendar.ics` by the local server, and any calendar app can import it.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Iterable
+
+from .recur import DAILY
+from .tasks import Task, TaskStatus
+
+_BYDAY = {"seg": "MO", "ter": "TU", "qua": "WE", "qui": "TH", "sex": "FR", "sab": "SA", "dom": "SU"}
+
+_MAX_LINE = 73  # RFC 5545 folds lines longer than 75 octets
+
+
+def _escape(text: str) -> str:
+    return (
+        text.replace("\\", "\\\\")
+        .replace(";", "\\;")
+        .replace(",", "\\,")
+        .replace("\n", "\\n")
+    )
+
+
+def _fold(line: str) -> list[str]:
+    """Break long lines with space-prefixed continuations (RFC 5545 3.1)."""
+    if len(line) <= _MAX_LINE:
+        return [line]
+    parts = [line[:_MAX_LINE]]
+    rest = line[_MAX_LINE:]
+    while rest:
+        parts.append(" " + rest[: _MAX_LINE - 1])
+        rest = rest[_MAX_LINE - 1 :]
+    return parts
+
+
+def _rrule(recur: str) -> str:
+    if recur == DAILY:
+        return "FREQ=DAILY"
+    return f"FREQ=WEEKLY;BYDAY={_BYDAY[recur]}"
+
+
+def tasks_to_ics(tasks: Iterable[Task], *, now: datetime) -> str:
+    """VCALENDAR with one all-day VEVENT per open (todo/paused) task."""
+    stamp = now.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    lines = [
+        "BEGIN:VCALENDAR",
+        "VERSION:2.0",
+        "PRODID:-//Leadger//Leadger//PT",
+        "CALSCALE:GREGORIAN",
+        "X-WR-CALNAME:Leadger",
+    ]
+    for task in tasks:
+        if task.status not in (TaskStatus.TODO, TaskStatus.PAUSED):
+            continue
+        start = task.target
+        end = start + timedelta(days=1)
+        lines += [
+            "BEGIN:VEVENT",
+            f"UID:{task.id}@leadger",
+            f"DTSTAMP:{stamp}",
+            f"DTSTART;VALUE=DATE:{start.strftime('%Y%m%d')}",
+            f"DTEND;VALUE=DATE:{end.strftime('%Y%m%d')}",
+            f"SUMMARY:{_escape(task.title)}",
+        ]
+        if task.tags:
+            lines.append("CATEGORIES:" + ",".join(_escape(tag) for tag in task.tags))
+        if task.recur:
+            lines.append(f"RRULE:{_rrule(task.recur)}")
+        lines.append("END:VEVENT")
+    lines.append("END:VCALENDAR")
+
+    folded: list[str] = []
+    for line in lines:
+        folded.extend(_fold(line))
+    return "\r\n".join(folded) + "\r\n"

leadger/core/ids.py

@@ -0,0 +1,16 @@
+"""Task ID generation."""
+
+from __future__ import annotations
+
+import secrets
+from typing import AbstractSet
+
+ID_PREFIX = "t_"
+
+
+def generate_task_id(existing_ids: AbstractSet[str]) -> str:
+    """Generate a unique task id: 't_' + 6 lowercase hex chars."""
+    while True:
+        candidate = ID_PREFIX + secrets.token_hex(3)
+        if candidate not in existing_ids:
+            return candidate

leadger/core/parse.py

@@ -0,0 +1,79 @@
+"""Inline capture syntax: "Estudar FAISS #estudo !amanha".
+
+Tokens:
+  - `#tag`  -> adds a tag (removed from the title)
+  - `!hoje`, `!amanha`, `!seg`..`!dom`, `!YYYY-MM-DD` -> sets the target
+    date (removed from the title); the last date token wins
+  - `!todo-dia`, `!rec:dia`, `!rec:seg`..`!rec:dom` -> recurrence; without
+    an explicit date, the target defaults to the first occurrence
+Unrecognized `!...` tokens stay in the title untouched.
+"""
+
+from __future__ import annotations
+
+import unicodedata
+from dataclasses import dataclass, field
+from datetime import date, timedelta
+from typing import Optional
+
+from .recur import WEEKDAYS as _WEEKDAYS
+from .recur import first_occurrence, normalize_recur
+
+
+@dataclass(frozen=True)
+class ParsedInput:
+    title: str
+    tags: list[str] = field(default_factory=list)
+    target: Optional[date] = None  # None = not specified (caller defaults to today)
+    recur: Optional[str] = None  # "dia" | "seg".."dom" (see core/recur.py)
+
+
+def _strip_accents(text: str) -> str:
+    return unicodedata.normalize("NFKD", text).encode("ascii", "ignore").decode("ascii")
+
+
+def _resolve_date_token(token: str, today: date) -> Optional[date]:
+    """`hoje`/`amanha`/weekday/ISO date -> date, or None if unrecognized."""
+    word = _strip_accents(token.lower())
+    if word == "hoje":
+        return today
+    if word == "amanha":
+        return today + timedelta(days=1)
+    if word in _WEEKDAYS:
+        # next occurrence of that weekday; today itself counts
+        return today + timedelta(days=(_WEEKDAYS[word] - today.weekday()) % 7)
+    try:
+        return date.fromisoformat(word)
+    except ValueError:
+        return None
+
+
+def parse_inline(text: str, today: date) -> ParsedInput:
+    """Split capture text into title, tags, target date and recurrence."""
+    tags: list[str] = []
+    target: Optional[date] = None
+    recur: Optional[str] = None
+    title_words: list[str] = []
+
+    for token in text.split():
+        if token.startswith("#") and len(token) > 1:
+            tag = token[1:]
+            if tag not in tags:
+                tags.append(tag)
+        elif token.startswith("!") and len(token) > 1:
+            recur_spec = normalize_recur(_strip_accents(token[1:].lower()))
+            if recur_spec is not None:
+                recur = recur_spec
+                continue
+            resolved = _resolve_date_token(token[1:], today)
+            if resolved is not None:
+                target = resolved
+            else:
+                title_words.append(token)
+        else:
+            title_words.append(token)
+
+    if target is None and recur is not None:
+        target = first_occurrence(recur, today)
+
+    return ParsedInput(title=" ".join(title_words), tags=tags, target=target, recur=recur)

leadger/core/periods.py

@@ -0,0 +1,32 @@
+"""Period filters (regra 5): date ranges over `target`, week starts Monday."""
+
+from __future__ import annotations
+
+import calendar
+from datetime import date, timedelta
+
+PERIODS = ("day", "week", "month", "quarter", "semester", "year")
+
+
+def _month_end(year: int, month: int) -> date:
+    return date(year, month, calendar.monthrange(year, month)[1])
+
+
+def period_range(period: str, today: date) -> tuple[date, date]:
+    """Inclusive (start, end) range of `period` containing `today`."""
+    if period == "day":
+        return today, today
+    if period == "week":
+        start = today - timedelta(days=today.weekday())
+        return start, start + timedelta(days=6)
+    if period == "month":
+        return today.replace(day=1), _month_end(today.year, today.month)
+    if period == "quarter":
+        start_month = 3 * ((today.month - 1) // 3) + 1
+        return date(today.year, start_month, 1), _month_end(today.year, start_month + 2)
+    if period == "semester":
+        start_month = 1 if today.month <= 6 else 7
+        return date(today.year, start_month, 1), _month_end(today.year, start_month + 5)
+    if period == "year":
+        return date(today.year, 1, 1), date(today.year, 12, 31)
+    raise ValueError(f"Periodo desconhecido: {period!r} (esperado um de {PERIODS})")

leadger/core/recur.py

@@ -0,0 +1,45 @@
+"""Minimal recurrence: `dia` (daily) or a weekday `seg`..`dom`.
+
+Capture syntax: `!todo-dia`, `!rec:dia`, `!rec:seg`..`!rec:dom`.
+The series is materialized one occurrence at a time: completing the open
+occurrence creates the next one; cancelling or deleting ends the series.
+"""
+
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import Optional
+
+DAILY = "dia"
+
+# Monday=0 .. Sunday=6, matching date.weekday()
+WEEKDAYS = {"seg": 0, "ter": 1, "qua": 2, "qui": 3, "sex": 4, "sab": 5, "dom": 6}
+
+
+def normalize_recur(word: str) -> Optional[str]:
+    """`todo-dia` / `rec:dia` / `rec:seg` -> normalized spec, else None.
+
+    `word` must already be lowercase and accent-stripped (as in parse_inline).
+    """
+    if word == "todo-dia":
+        return DAILY
+    if word.startswith("rec:"):
+        spec = word[4:]
+        if spec == DAILY or spec in WEEKDAYS:
+            return spec
+    return None
+
+
+def first_occurrence(recur: str, today: date) -> date:
+    """First occurrence starting at `today` (today itself counts)."""
+    if recur == DAILY:
+        return today
+    return today + timedelta(days=(WEEKDAYS[recur] - today.weekday()) % 7)
+
+
+def next_occurrence(recur: str, after: date) -> date:
+    """Next occurrence strictly after `after`."""
+    if recur == DAILY:
+        return after + timedelta(days=1)
+    delta = (WEEKDAYS[recur] - after.weekday()) % 7
+    return after + timedelta(days=delta or 7)