minutes-cli 0.1.0__tar.gz

minutes_cli-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: minutes-cli
+Version: 0.1.0
+Summary: Project-centric meeting notes and task tracker for the command line
+Project-URL: Repository, https://github.com/ucyo/minutes
+Author-email: Ugur Cayoglu <cayoglu@me.com>
+License: MIT
+Requires-Python: >=3.11
+Requires-Dist: prompt-toolkit
+Requires-Dist: rich
+Requires-Dist: typer
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# minutes
+
+Project-centric meeting notes and task tracker for the command line.
+
+Capture notes from meetings, track actions and decisions per project, and get a clean weekly summary before giving updates.
+
+## Getting started
+
+**Requirements:** Python 3.11+
+
+```bash
+pip install -e .
+```
+
+**Add entries after a meeting:**
+
+```bash
+minutes add
+```
+
+You will be prompted for a project name (with autocomplete) and an optional meeting name. Then enter entries one per line:
+
+```
+*  decision     → * Drop v1 endpoints by Q3
+!  action       → ! Write migration guide @fri
+>  waiting      → > Spec approval from Marco
+   note         → Just a note, no prefix needed
+```
+
+Press Enter on an empty line or Ctrl+D to finish. Each entry is saved immediately.
+
+**Enable shell completion (once):**
+
+```bash
+minutes --install-completion
+```
+
+After restarting your shell, `minutes logs -p <TAB>` and `minutes add -p <TAB>` will autocomplete project names from your store.
+
+**Browse entries:**
+
+```bash
+minutes logs                          # all projects, all entries
+minutes logs --project api-migration  # one project in detail
+minutes logs --since 14               # last 14 days
+minutes logs --since mon              # since Monday
+```
+
+**Check open actions:**
+
+```bash
+minutes logs --open
+```
+
+## Running tests
+
+```bash
+make test
+```
+
+## Data
+
+Entries are stored as JSONL at `~/.local/share/minutes/entries.jsonl`.
+
+See [docs/whitepaper.md](docs/whitepaper.md) for the full specification.

minutes_cli-0.1.0/README.md

@@ -0,0 +1,65 @@
+# minutes
+
+Project-centric meeting notes and task tracker for the command line.
+
+Capture notes from meetings, track actions and decisions per project, and get a clean weekly summary before giving updates.
+
+## Getting started
+
+**Requirements:** Python 3.11+
+
+```bash
+pip install -e .
+```
+
+**Add entries after a meeting:**
+
+```bash
+minutes add
+```
+
+You will be prompted for a project name (with autocomplete) and an optional meeting name. Then enter entries one per line:
+
+```
+*  decision     → * Drop v1 endpoints by Q3
+!  action       → ! Write migration guide @fri
+>  waiting      → > Spec approval from Marco
+   note         → Just a note, no prefix needed
+```
+
+Press Enter on an empty line or Ctrl+D to finish. Each entry is saved immediately.
+
+**Enable shell completion (once):**
+
+```bash
+minutes --install-completion
+```
+
+After restarting your shell, `minutes logs -p <TAB>` and `minutes add -p <TAB>` will autocomplete project names from your store.
+
+**Browse entries:**
+
+```bash
+minutes logs                          # all projects, all entries
+minutes logs --project api-migration  # one project in detail
+minutes logs --since 14               # last 14 days
+minutes logs --since mon              # since Monday
+```
+
+**Check open actions:**
+
+```bash
+minutes logs --open
+```
+
+## Running tests
+
+```bash
+make test
+```
+
+## Data
+
+Entries are stored as JSONL at `~/.local/share/minutes/entries.jsonl`.
+
+See [docs/whitepaper.md](docs/whitepaper.md) for the full specification.

minutes_cli-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "minutes-cli"
+version = "0.1.0"
+description = "Project-centric meeting notes and task tracker for the command line"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Ugur Cayoglu", email = "cayoglu@me.com" }]
+requires-python = ">=3.11"
+dependencies = ["typer", "rich", "prompt_toolkit"]
+
+[project.scripts]
+minutes = "minutes.cli:main"
+
+[project.urls]
+Repository = "https://github.com/ucyo/minutes"
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/minutes"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

minutes_cli-0.1.0/src/minutes/add.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import re
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Optional
+
+from prompt_toolkit import PromptSession
+from prompt_toolkit.application import get_app
+from prompt_toolkit.completion import FuzzyWordCompleter
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+from rich.console import Console
+
+from .display import _TYPE_COLORS, _TYPE_LABELS
+from .models import Entry, EntryStatus, EntryType
+from .store import append_entry, get_projects
+
+console = Console()
+
+_STYLE = Style.from_dict({
+    "bottom-toolbar": "bg:#2a2a2a #888888",
+    "completion-menu.completion": "bg:#1e3a5f #ffffff",
+    "completion-menu.completion.current": "bg:#0066cc #ffffff",
+})
+
+_WEEKDAYS = {"mon": 0, "tue": 1, "wed": 2, "thu": 3, "fri": 4, "sat": 5, "sun": 6}
+
+_entry_bindings = KeyBindings()
+
+@_entry_bindings.add("c-d")
+def _exit_on_ctrl_d(event):
+    event.app.exit(exception=EOFError())
+
+
+def _toolbar() -> HTML:
+    try:
+        text = get_app().current_buffer.text
+    except Exception:
+        text = ""
+
+    if text.startswith("*"):
+        return HTML(
+            "  <ansiblue><b>decision</b></ansiblue>  —  type the decision text"
+        )
+    if text.startswith("!"):
+        return HTML(
+            "  <ansiyellow><b>action</b></ansiyellow>  —  "
+            "due date: <ansigreen>@fri  @7  @2026-05-30</ansigreen>"
+        )
+    if text.startswith(">"):
+        return HTML(
+            "  <ansimagenta><b>waiting</b></ansimagenta>  —  "
+            "person: <ansigreen>@Person</ansigreen>"
+        )
+    return HTML(
+        "  <ansiblue>*</ansiblue> decision  "
+        "<ansiyellow>!</ansiyellow> action  "
+        "<ansimagenta>&gt;</ansimagenta> waiting  "
+        "note"
+        "  │  "
+        "Empty line or Ctrl+D to finish"
+    )
+
+
+def _parse_due(token: str) -> Optional[str]:
+    today = date.today()
+    t = token.lower()
+    if t in _WEEKDAYS:
+        target_wd = _WEEKDAYS[t]
+        delta = (target_wd - today.weekday()) % 7 or 7
+        return (today + timedelta(days=delta)).isoformat()
+    try:
+        return (today + timedelta(days=int(t))).isoformat()
+    except ValueError:
+        pass
+    try:
+        return date.fromisoformat(t).isoformat()
+    except ValueError:
+        return None
+
+
+def parse_line(raw: str, meeting: Optional[str] = None) -> Optional[Entry]:
+    raw = raw.strip()
+    if not raw:
+        return None
+
+    entry_id = Entry.make_id()
+    ts = Entry.now_ts()
+
+    if raw.startswith("*"):
+        return Entry(
+            id=entry_id, ts=ts, project="",
+            type=EntryType.DECISION, text=raw[1:].strip(), meeting=meeting,
+        )
+
+    if raw.startswith("!"):
+        rest = raw[1:].strip()
+        due = None
+        m = re.search(r"@(\S+)", rest)
+        if m:
+            due = _parse_due(m.group(1))
+            rest = (rest[: m.start()] + rest[m.end() :]).strip()
+        return Entry(
+            id=entry_id, ts=ts, project="",
+            type=EntryType.ACTION, text=rest, meeting=meeting,
+            due=due, status=EntryStatus.OPEN,
+        )
+
+    if raw.startswith(">"):
+        rest = raw[1:].strip()
+        person = None
+        m = re.search(r"@(\w+)", rest)
+        if m:
+            person = m.group(1)
+            rest = (rest[: m.start()] + rest[m.end() :]).strip()
+        return Entry(
+            id=entry_id, ts=ts, project="",
+            type=EntryType.WAITING, text=rest, meeting=meeting, person=person,
+        )
+
+    return Entry(id=entry_id, ts=ts, project="", type=EntryType.NOTE, text=raw, meeting=meeting)
+
+
+def _echo_entry(entry: Entry) -> None:
+    color = _TYPE_COLORS[entry.type]
+    label = _TYPE_LABELS[entry.type]
+    extra = ""
+    if entry.due:
+        extra += f" [dim]due {entry.due}[/dim]"
+    if entry.person:
+        extra += f" [dim]→ {entry.person}[/dim]"
+    console.print(f"  [{color}]{label:10}[/{color}] {entry.text}{extra}")
+
+
+def run_add(store: Optional[Path] = None, project: Optional[str] = None) -> None:
+    projects = get_projects(store)
+    project_session: PromptSession = PromptSession(
+        style=_STYLE, completer=FuzzyWordCompleter(projects)
+    )
+    entry_session: PromptSession = PromptSession(style=_STYLE)
+
+    console.print()
+
+    def _show_all_completions():
+        get_app().current_buffer.start_completion(select_first=False)
+
+    try:
+        project = project_session.prompt(
+            HTML("<ansiblue><b>Project: </b></ansiblue>"),
+            default=project or "",
+            pre_run=_show_all_completions,
+        ).strip()
+    except (EOFError, KeyboardInterrupt):
+        console.print("[dim]Aborted.[/dim]")
+        return
+
+    if not project:
+        console.print("[dim]Aborted.[/dim]")
+        return
+
+    try:
+        meeting_raw = entry_session.prompt(HTML("<ansicyan>Meeting (optional): </ansicyan>")).strip()
+    except (EOFError, KeyboardInterrupt):
+        console.print("[dim]Aborted.[/dim]")
+        return
+
+    meeting = meeting_raw or None
+    console.print()
+
+    saved = 0
+    while True:
+        try:
+            raw = entry_session.prompt(HTML("<b>→ </b>"), bottom_toolbar=_toolbar, key_bindings=_entry_bindings)
+        except (EOFError, KeyboardInterrupt):
+            break
+
+        if not raw.strip():
+            break
+
+        entry = parse_line(raw, meeting)
+        if entry is None:
+            continue
+
+        entry.project = project
+        append_entry(entry, store)
+        _echo_entry(entry)
+        saved += 1
+
+    if saved == 0:
+        console.print()
+        console.print("[dim]Nothing saved.[/dim]")
+        return
+
+    console.print()
+    noun = "entry" if saved == 1 else "entries"
+    console.print(f"[green]Saved {saved} {noun} to[/green] [bold cyan]{project}[/bold cyan].")

minutes_cli-0.1.0/src/minutes/cli.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from .add import parse_line, run_add
+from .display import render_logs
+from .store import (
+    append_entry,
+    filter_entries,
+    get_projects,
+    load_entries,
+    parse_since,
+)
+
+app = typer.Typer(
+    help="tgsa — project-centric meeting notes and task tracker",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def _complete_project(incomplete: str) -> list[str]:
+    try:
+        return [p for p in get_projects() if incomplete.lower() in p.lower()]
+    except Exception:
+        return []
+
+
+@app.command()
+def add(
+    text: Optional[str] = typer.Argument(None, help="Inline entry (skips interactive mode)"),
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p",
+        help="Project slug",
+        autocompletion=_complete_project,
+    ),
+    file: Optional[Path] = typer.Option(None, "--file", help="Override store path"),
+) -> None:
+    """Add entries for a project interactively, or inline with --project."""
+    if text is not None and project is not None:
+        entry = parse_line(text)
+        if entry is None:
+            console.print("[red]Could not parse entry.[/red]")
+            raise typer.Exit(1)
+        entry.project = project
+        append_entry(entry, file)
+        console.print("[green]Saved.[/green]")
+    else:
+        if text is not None and project is None:
+            console.print("[red]Inline mode requires --project.[/red]")
+            raise typer.Exit(1)
+        run_add(file, project=project)
+
+
+@app.command()
+def logs(
+    project: Optional[str] = typer.Option(
+        None, "--project", "-p",
+        help="Scope to one project",
+        autocompletion=_complete_project,
+    ),
+    since: Optional[str] = typer.Option(None, "--since", help="Restrict to entries since: 'mon', integer days back, or YYYY-MM-DD"),
+    open_only: bool = typer.Option(False, "--open", help="Show only open actions and waiting entries"),
+    show_all: bool = typer.Option(False, "--all", help="Show all fields: meeting, tags, done timestamp"),
+    file: Optional[Path] = typer.Option(None, "--file"),
+) -> None:
+    """Show entries chronologically. All entries by default, restrict with --since."""
+    since_date = parse_since(since) if since else None
+    entries = load_entries(file)
+    filtered = filter_entries(entries, since=since_date, project=project, open_only=open_only)
+    render_logs(filtered, since_date, project=project, show_all=show_all)
+
+
+def main() -> None:
+    app()

minutes_cli-0.1.0/src/minutes/display.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from datetime import date, timedelta
+from typing import Optional
+
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from .models import Entry, EntryStatus, EntryType
+
+console = Console()
+
+_DUE_SOON_DAYS = 2
+
+_BUCKET_ORDER = ["Older", "This year", "This month", "This week", "Yesterday", "Today"]
+
+
+def _date_bucket(entry_date: date, today: date) -> str:
+    if entry_date == today:
+        return "Today"
+    if entry_date == today - timedelta(days=1):
+        return "Yesterday"
+    if entry_date.isocalendar()[:2] == today.isocalendar()[:2]:
+        return "This week"
+    if entry_date.year == today.year and entry_date.month == today.month:
+        return "This month"
+    if entry_date.year == today.year:
+        return "This year"
+    return "Older"
+
+
+def _due_style(due_str: Optional[str]) -> str:
+    if due_str is None:
+        return ""
+    today = date.today()
+    d = date.fromisoformat(due_str)
+    if d < today:
+        return "bold red"
+    if d <= today + timedelta(days=_DUE_SOON_DAYS):
+        return "yellow"
+    return ""
+
+
+_TYPE_COLORS = {
+    EntryType.DECISION: "blue",
+    EntryType.ACTION: "yellow",
+    EntryType.WAITING: "magenta",
+    EntryType.NOTE: "dim",
+}
+
+_TYPE_LABELS = {
+    EntryType.DECISION: "decision",
+    EntryType.ACTION: "action",
+    EntryType.WAITING: "waiting",
+    EntryType.NOTE: "note",
+}
+
+
+def _build_parts(entry: Entry) -> tuple[Text, Text]:
+    """Return (label, content) Text objects for a single entry."""
+    color = _TYPE_COLORS[entry.type]
+    label = _TYPE_LABELS[entry.type]
+
+    if entry.type == EntryType.ACTION:
+        done = entry.status == EntryStatus.DONE
+        cancelled = entry.status == EntryStatus.CANCELLED
+        if done:
+            color = "green"
+        elif cancelled:
+            color = "dim"
+        elif entry.due:
+            color = _due_style(entry.due) or color
+        checkbox = " [x]" if done else (" [-]" if cancelled else " [ ]")
+        content = Text()
+        content.append(entry.text + checkbox, style=f"{color} strike" if done else color)
+        if entry.due and not done and not cancelled:
+            content.append(f"  due {entry.due}", style=_due_style(entry.due) or "dim")
+
+    elif entry.type == EntryType.WAITING:
+        content = Text()
+        content.append(entry.text, style=color)
+        if entry.person:
+            content.append(f"  → {entry.person}", style="dim magenta")
+
+    else:
+        content = Text(entry.text, style=color)
+
+    return Text(label, style=color), content
+
+
+def _build_meta(entry: Entry) -> tuple[Text, Text, Text]:
+    """Return (meeting, tags, updated_ts) as separate Text objects."""
+    meeting = Text(entry.meeting or "", style="dim")
+    tags = Text("  ".join(f"#{t}" for t in entry.tags), style="dim")
+    updated = Text()
+    if entry.type == EntryType.ACTION and entry.status == EntryStatus.DONE and entry.updated_ts:
+        updated = Text(entry.updated_ts[:16].replace("T", " "), style="dim")
+    return meeting, tags, updated
+
+
+def _make_table(show_all: bool) -> Table:
+    table = Table(box=None, show_header=False, padding=(0, 2, 0, 0))
+    table.add_column(no_wrap=True)   # timestamp
+    table.add_column(no_wrap=True)   # project
+    table.add_column(no_wrap=True)   # type label
+    table.add_column()               # content — wraps here
+    if show_all:
+        table.add_column(no_wrap=True)  # meeting
+        table.add_column(no_wrap=True)  # tags
+        table.add_column(no_wrap=True)  # updated_ts
+    return table
+
+
+def _add_row(table: Table, entry: Entry, show_all: bool) -> None:
+    ts = Text(entry.ts[:16].replace("T", " "), style="dim")
+    proj = Text(entry.project, style="cyan")
+    label, content = _build_parts(entry)
+    if show_all:
+        meeting, tags, updated = _build_meta(entry)
+        table.add_row(ts, proj, label, content, meeting, tags, updated)
+    else:
+        table.add_row(ts, proj, label, content)
+
+
+def render_logs(
+    entries: list[Entry],
+    since: Optional[date] = None,
+    project: Optional[str] = None,
+    show_all: bool = False,
+) -> None:
+    if not entries:
+        console.print("[dim]No entries found.[/dim]")
+        return
+
+    today = date.today()
+    sorted_entries = sorted(entries, key=lambda e: e.ts)
+
+    groups: dict[str, list[Entry]] = {b: [] for b in _BUCKET_ORDER}
+    for entry in sorted_entries:
+        bucket = _date_bucket(date.fromisoformat(entry.ts[:10]), today)
+        groups[bucket].append(entry)
+
+    first = True
+    for bucket in _BUCKET_ORDER:
+        bucket_entries = groups[bucket]
+        if not bucket_entries:
+            continue
+        if not first:
+            console.print()
+        console.rule(f"[dim]{bucket}[/dim]", style="dim")
+        table = _make_table(show_all)
+        for entry in bucket_entries:
+            _add_row(table, entry, show_all)
+        console.print(table)
+        first = False

minutes_cli-0.1.0/src/minutes/models.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+
+
+class EntryType(str, Enum):
+    NOTE = "note"
+    ACTION = "action"
+    DECISION = "decision"
+    WAITING = "waiting"
+
+
+class EntryStatus(str, Enum):
+    OPEN = "open"
+    DONE = "done"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class Entry:
+    id: str
+    ts: str
+    project: str
+    type: EntryType
+    text: str
+    meeting: Optional[str] = None
+    due: Optional[str] = None
+    status: Optional[EntryStatus] = None
+    person: Optional[str] = None
+    tags: list[str] = field(default_factory=list)
+    updated_ts: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "id": self.id,
+            "ts": self.ts,
+            "project": self.project,
+            "type": self.type.value,
+            "text": self.text,
+        }
+        if self.meeting is not None:
+            d["meeting"] = self.meeting
+        if self.due is not None:
+            d["due"] = self.due
+        if self.status is not None:
+            d["status"] = self.status.value
+        if self.person is not None:
+            d["person"] = self.person
+        if self.tags:
+            d["tags"] = self.tags
+        if self.updated_ts is not None:
+            d["updated_ts"] = self.updated_ts
+        return d
+
+    @classmethod
+    def from_dict(cls, d: dict) -> Entry:
+        return cls(
+            id=d["id"],
+            ts=d["ts"],
+            project=d["project"],
+            type=EntryType(d["type"]),
+            text=d["text"],
+            meeting=d.get("meeting"),
+            due=d.get("due"),
+            status=EntryStatus(d["status"]) if d.get("status") else None,
+            person=d.get("person"),
+            tags=d.get("tags", []),
+            updated_ts=d.get("updated_ts"),
+        )
+
+    @staticmethod
+    def make_id() -> str:
+        return uuid.uuid4().hex[:7]
+
+    @staticmethod
+    def now_ts() -> str:
+        return datetime.now().strftime("%Y-%m-%dT%H:%M")

minutes_cli-0.1.0/src/minutes/store.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+from datetime import date, timedelta
+from pathlib import Path
+from typing import Optional
+
+from .models import Entry, EntryStatus, EntryType
+
+DEFAULT_PATH = Path.home() / ".local" / "share" / "minutes" / "entries.jsonl"
+
+
+def get_store_path(override: Optional[Path] = None) -> Path:
+    p = override or DEFAULT_PATH
+    p.parent.mkdir(parents=True, exist_ok=True)
+    return p
+
+
+def append_entry(entry: Entry, store: Optional[Path] = None) -> None:
+    path = get_store_path(store)
+    with open(path, "a") as f:
+        f.write(json.dumps(entry.to_dict()) + "\n")
+
+
+def load_entries(store: Optional[Path] = None) -> list[Entry]:
+    path = get_store_path(store)
+    if not path.exists():
+        return []
+    seen: dict[str, Entry] = {}
+    with open(path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                d = json.loads(line)
+                seen[d["id"]] = Entry.from_dict(d)
+            except (json.JSONDecodeError, KeyError, ValueError):
+                continue
+    return list(seen.values())
+
+
+def get_projects(store: Optional[Path] = None) -> list[str]:
+    entries = load_entries(store)
+    projects: dict[str, str] = {}
+    for e in entries:
+        if e.project not in projects or e.ts > projects[e.project]:
+            projects[e.project] = e.ts
+    return sorted(projects.keys())
+
+
+def parse_since(value: str) -> date:
+    today = date.today()
+    if value == "mon":
+        return today - timedelta(days=today.weekday())
+    try:
+        days = int(value)
+        return today - timedelta(days=days)
+    except ValueError:
+        pass
+    return date.fromisoformat(value)
+
+
+def filter_entries(
+    entries: list[Entry],
+    since: Optional[date] = None,
+    project: Optional[str] = None,
+    entry_type: Optional[EntryType] = None,
+    open_only: bool = False,
+) -> list[Entry]:
+    result = []
+    for e in entries:
+        if since and date.fromisoformat(e.ts[:10]) < since:
+            continue
+        if project and e.project != project:
+            continue
+        if entry_type and e.type != entry_type:
+            continue
+        if open_only:
+            if e.type == EntryType.ACTION:
+                if e.status in (EntryStatus.DONE, EntryStatus.CANCELLED):
+                    continue
+            elif e.type != EntryType.WAITING:
+                continue
+        result.append(e)
+    return result
+
+
+def mark_done(
+    entry_id: str,
+    status: EntryStatus = EntryStatus.DONE,
+    store: Optional[Path] = None,
+) -> Optional[Entry]:
+    entries = load_entries(store)
+    target = next((e for e in entries if e.id == entry_id), None)
+    if target is None:
+        return None
+    target.status = status
+    target.updated_ts = Entry.now_ts()
+    append_entry(target, store)
+    return target

minutes_cli-0.1.0/tests/test_add.py

@@ -0,0 +1,101 @@
+from datetime import date, timedelta
+
+import pytest
+
+from minutes.add import parse_line, _parse_due
+from minutes.models import EntryStatus, EntryType
+
+
+class TestParseDue:
+    def test_integer_days(self):
+        today = date.today()
+        assert _parse_due("7") == (today + timedelta(days=7)).isoformat()
+        assert _parse_due("0") == today.isoformat()
+
+    def test_weekday_is_future(self):
+        result = _parse_due("fri")
+        d = date.fromisoformat(result)
+        assert d.weekday() == 4  # Friday
+        assert d >= date.today()
+
+    def test_all_weekday_abbreviations(self):
+        for abbr, wd in [("mon", 0), ("tue", 1), ("wed", 2), ("thu", 3),
+                          ("fri", 4), ("sat", 5), ("sun", 6)]:
+            result = _parse_due(abbr)
+            assert date.fromisoformat(result).weekday() == wd
+
+    def test_iso_date(self):
+        assert _parse_due("2026-12-31") == "2026-12-31"
+
+    def test_invalid_returns_none(self):
+        assert _parse_due("notadate") is None
+
+
+class TestParseLine:
+    def test_note_no_prefix(self):
+        e = parse_line("just a note")
+        assert e is not None
+        assert e.type == EntryType.NOTE
+        assert e.text == "just a note"
+
+    def test_decision_prefix(self):
+        e = parse_line("* Drop v1 endpoints")
+        assert e is not None
+        assert e.type == EntryType.DECISION
+        assert e.text == "Drop v1 endpoints"
+
+    def test_action_prefix(self):
+        e = parse_line("! Write migration guide")
+        assert e is not None
+        assert e.type == EntryType.ACTION
+        assert e.text == "Write migration guide"
+        assert e.status == EntryStatus.OPEN
+
+    def test_action_with_date(self):
+        e = parse_line("! Write migration guide @7")
+        assert e is not None
+        assert e.type == EntryType.ACTION
+        assert e.due == (date.today() + timedelta(days=7)).isoformat()
+        assert "@" not in e.text
+
+    def test_action_with_iso_date(self):
+        e = parse_line("! Write migration guide @2026-06-01")
+        assert e is not None
+        assert e.due == "2026-06-01"
+
+    def test_waiting_prefix(self):
+        e = parse_line("> v2 spec approval")
+        assert e is not None
+        assert e.type == EntryType.WAITING
+        assert e.text == "v2 spec approval"
+
+    def test_waiting_with_person(self):
+        e = parse_line("> v2 spec @Marco")
+        assert e is not None
+        assert e.person == "Marco"
+        assert "@Marco" not in e.text
+
+    def test_waiting_person_stripped_from_text(self):
+        e = parse_line("> get approval @Anna")
+        assert e is not None
+        assert e.person == "Anna"
+        assert e.text == "get approval"
+
+    def test_empty_line_returns_none(self):
+        assert parse_line("") is None
+        assert parse_line("   ") is None
+
+    def test_meeting_is_attached(self):
+        e = parse_line("* A decision", meeting="team sync")
+        assert e is not None
+        assert e.meeting == "team sync"
+
+    def test_project_is_empty_placeholder(self):
+        e = parse_line("some note")
+        assert e is not None
+        assert e.project == ""
+
+    def test_id_is_four_chars(self):
+        e = parse_line("a note")
+        assert e is not None
+        assert len(e.id) == 7

minutes_cli-0.1.0/tests/test_models.py

@@ -0,0 +1,62 @@
+from minutes.models import Entry, EntryStatus, EntryType
+
+
+def test_entry_roundtrip():
+    e = Entry(
+        id="a1b2",
+        ts="2026-05-27T14:00",
+        project="api-migration",
+        type=EntryType.ACTION,
+        text="Write migration guide",
+        due="2026-05-30",
+        status=EntryStatus.OPEN,
+    )
+    assert Entry.from_dict(e.to_dict()) == e
+
+
+def test_to_dict_omits_none_fields():
+    e = Entry(id="x", ts="2026-05-27T09:00", project="p", type=EntryType.NOTE, text="hello")
+    d = e.to_dict()
+    assert "meeting" not in d
+    assert "due" not in d
+    assert "status" not in d
+    assert "person" not in d
+    assert "tags" not in d
+
+
+def test_to_dict_includes_optional_when_set():
+    e = Entry(
+        id="x", ts="2026-05-27T09:00", project="p",
+        type=EntryType.WAITING, text="approval",
+        person="Marco", meeting="team sync",
+    )
+    d = e.to_dict()
+    assert d["person"] == "Marco"
+    assert d["meeting"] == "team sync"
+
+
+def test_make_id_length():
+    assert len(Entry.make_id()) == 7
+
+
+def test_make_id_unique():
+    ids = {Entry.make_id() for _ in range(100)}
+    assert len(ids) > 90  # allow tiny collision chance
+
+
+def test_entry_type_values():
+    assert EntryType.NOTE.value == "note"
+    assert EntryType.ACTION.value == "action"
+    assert EntryType.DECISION.value == "decision"
+    assert EntryType.WAITING.value == "waiting"
+
+
+def test_status_roundtrip():
+    e = Entry(
+        id="z", ts="2026-05-27T10:00", project="p",
+        type=EntryType.ACTION, text="do thing",
+        status=EntryStatus.DONE,
+    )
+    d = e.to_dict()
+    assert d["status"] == "done"
+    assert Entry.from_dict(d).status == EntryStatus.DONE

minutes_cli-0.1.0/tests/test_store.py

@@ -0,0 +1,142 @@
+import json
+import tempfile
+from datetime import date, timedelta
+from pathlib import Path
+
+import pytest
+
+from minutes.models import Entry, EntryStatus, EntryType
+from minutes.store import (
+    append_entry,
+    filter_entries,
+    load_entries,
+    mark_done,
+    parse_since,
+)
+
+
+@pytest.fixture
+def store(tmp_path):
+    return tmp_path / "entries.jsonl"
+
+
+def _entry(project="proj", etype=EntryType.NOTE, text="hello", **kwargs) -> Entry:
+    return Entry(
+        id=Entry.make_id(),
+        ts=kwargs.pop("ts", "2026-05-27T10:00"),
+        project=project,
+        type=etype,
+        text=text,
+        **kwargs,
+    )
+
+
+class TestAppendAndLoad:
+    def test_append_creates_file(self, store):
+        e = _entry()
+        append_entry(e, store)
+        assert store.exists()
+
+    def test_load_roundtrip(self, store):
+        e = _entry(text="test note")
+        append_entry(e, store)
+        loaded = load_entries(store)
+        assert len(loaded) == 1
+        assert loaded[0].text == "test note"
+
+    def test_load_last_write_wins(self, store):
+        e = _entry(etype=EntryType.ACTION, status=EntryStatus.OPEN)
+        append_entry(e, store)
+        e.status = EntryStatus.DONE
+        e.updated_ts = "2026-05-27T15:00"
+        append_entry(e, store)
+        loaded = load_entries(store)
+        assert len(loaded) == 1
+        assert loaded[0].status == EntryStatus.DONE
+
+    def test_load_empty_store(self, store):
+        assert load_entries(store) == []
+
+    def test_load_skips_malformed_lines(self, store):
+        store.parent.mkdir(parents=True, exist_ok=True)
+        store.write_text('not json\n{"id":"x","ts":"2026-05-27T10:00","project":"p","type":"note","text":"ok"}\n')
+        loaded = load_entries(store)
+        assert len(loaded) == 1
+        assert loaded[0].text == "ok"
+
+
+class TestParseSince:
+    def test_mon_returns_monday(self):
+        d = parse_since("mon")
+        assert d.weekday() == 0
+
+    def test_integer_days_back(self):
+        today = date.today()
+        assert parse_since("7") == today - timedelta(days=7)
+        assert parse_since("0") == today
+
+    def test_iso_date(self):
+        assert parse_since("2026-01-15") == date(2026, 1, 15)
+
+    def test_invalid_raises(self):
+        with pytest.raises(ValueError):
+            parse_since("notadate")
+
+
+class TestFilterEntries:
+    def _entries(self):
+        return [
+            _entry(project="alpha", etype=EntryType.NOTE, ts="2026-05-26T09:00"),
+            _entry(project="beta", etype=EntryType.ACTION, ts="2026-05-27T10:00",
+                   status=EntryStatus.OPEN),
+            _entry(project="alpha", etype=EntryType.DECISION, ts="2026-05-27T11:00"),
+            _entry(project="beta", etype=EntryType.ACTION, ts="2026-05-27T12:00",
+                   status=EntryStatus.DONE),
+        ]
+
+    def test_filter_by_project(self):
+        result = filter_entries(self._entries(), project="alpha")
+        assert all(e.project == "alpha" for e in result)
+        assert len(result) == 2
+
+    def test_filter_by_since(self):
+        result = filter_entries(self._entries(), since=date(2026, 5, 27))
+        assert all(e.ts >= "2026-05-27" for e in result)
+        assert len(result) == 3
+
+    def test_filter_by_type(self):
+        result = filter_entries(self._entries(), entry_type=EntryType.ACTION)
+        assert all(e.type == EntryType.ACTION for e in result)
+        assert len(result) == 2
+
+    def test_open_only_excludes_done_actions(self):
+        result = filter_entries(self._entries(), open_only=True)
+        assert all(e.status != EntryStatus.DONE for e in result if e.type == EntryType.ACTION)
+
+    def test_open_only_excludes_notes_and_decisions(self):
+        result = filter_entries(self._entries(), open_only=True)
+        assert all(e.type in (EntryType.ACTION, EntryType.WAITING) for e in result)
+
+    def test_no_filters_returns_all(self):
+        entries = self._entries()
+        assert filter_entries(entries) == entries
+
+
+class TestMarkDone:
+    def test_marks_existing_action_done(self, store):
+        e = _entry(etype=EntryType.ACTION, status=EntryStatus.OPEN)
+        append_entry(e, store)
+        result = mark_done(e.id, store=store)
+        assert result is not None
+        assert result.status == EntryStatus.DONE
+        loaded = load_entries(store)
+        assert loaded[0].status == EntryStatus.DONE
+
+    def test_returns_none_for_unknown_id(self, store):
+        assert mark_done("zzzz", store=store) is None
+
+    def test_sets_updated_ts(self, store):
+        e = _entry(etype=EntryType.ACTION, status=EntryStatus.OPEN)
+        append_entry(e, store)
+        result = mark_done(e.id, store=store)
+        assert result.updated_ts is not None