minutes-cli 0.1.0__py3-none-any.whl

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.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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+minutes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+minutes/add.py,sha256=I94jqOlquhzMFspxabgc6Vka0xaSX9_pHRBYi9JjF9g,5827
+minutes/cli.py,sha256=8bKwDGOKpeCEmrGKKlTJW0CK5pNBUjE1ZJHirvCmCG8,2580
+minutes/display.py,sha256=5cBsSQgJOgArcwIHaizY62fNuY0tsSMoK5CMFy8yaV0,4932
+minutes/models.py,sha256=PKPV0t2CcG1DG0T2V5Q_GuVNxEE9BDnGm6j0zDUePFk,2066
+minutes/store.py,sha256=GhMPKSLa09_LVC3efRdV3X89OjB_RG0Dp9JLdJTNarc,2872
+minutes_cli-0.1.0.dist-info/METADATA,sha256=6raV0_Qzy_LeL_YUUlhBMyEy0EzkT5Ghni0ByhN062g,1926
+minutes_cli-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+minutes_cli-0.1.0.dist-info/entry_points.txt,sha256=LiEuklupxywa7IutS97I3nh5QvoCxjLmmIdXOpgWvdM,45
+minutes_cli-0.1.0.dist-info/RECORD,,

minutes_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

minutes_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+minutes = minutes.cli:main