rumo-cli 0.1.0__py3-none-any.whl

rumo/app.py

@@ -0,0 +1,496 @@
+"""The `rumo` TUI: a Timeline (Past / Now / Later) on the left, the selected item on the right."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+from collections.abc import Callable
+from datetime import date, datetime
+from pathlib import Path
+
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, ListItem, ListView, Markdown, OptionList, SelectionList, Static
+from textual.widgets.option_list import Option
+
+from rumo import config, items
+from rumo.items import Item, WriteConflict
+
+STATUS_STYLE = {"idea": "cyan", "doing": "green", "waiting": "yellow", "paused": "grey50", "done": "blue"}
+NEW_GROUP = "+new"
+NO_GROUP = "-none"
+
+KEYS = Text.assemble(
+    *(
+        part
+        for key, label in [
+            ("s", "status"), ("g", "group"), ("t", "tags"), ("n", "new idea"), ("e", "edit"),
+            ("space", "step"), ("c", "copy resume"), ("/", "filter"), ("q", "quit"),
+        ]
+        for part in ((key, "bold"), (f" {label}   ", "dim"))
+    )
+)
+
+
+MONTHS = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split()
+
+
+def short_date(stamp: str) -> str:
+    """`2026-10-06 17:00` -> `Oct 06`: unambiguous in any country, unlike 10/06."""
+    try:
+        return f"{MONTHS[int(stamp[5:7]) - 1]} {stamp[8:10]}"
+    except (ValueError, IndexError):
+        return stamp[:10]
+
+
+# ---------- pickers ----------
+
+
+class ChoiceScreen(ModalScreen[str | None]):
+    """Pick one value; digits 1-9 pick directly, Esc cancels."""
+
+    BINDINGS = [Binding("escape", "dismiss(None)", "cancel")]
+
+    def __init__(self, title: str, choices: list[tuple[str, Text]], current: str | None = None) -> None:
+        super().__init__()
+        self.title_text = title
+        self.choices = choices
+        self.current = current
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label(self.title_text, classes="dialog-title")
+            options = []
+            for n, (value, label) in enumerate(self.choices, start=1):
+                prefix = f"{n}  " if n <= 9 else "   "
+                options.append(Option(Text.assemble((prefix, "dim"), label), id=value))
+            yield OptionList(*options)
+
+    def on_mount(self) -> None:
+        option_list = self.query_one(OptionList)
+        values = [v for v, _ in self.choices]
+        if self.current in values:
+            option_list.highlighted = values.index(self.current)
+        option_list.focus()
+
+    def on_key(self, event) -> None:
+        if event.character and event.character.isdigit() and event.character != "0":
+            n = int(event.character)
+            if n <= len(self.choices):
+                event.stop()
+                self.dismiss(self.choices[n - 1][0])
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        self.dismiss(event.option.id)
+
+
+class TextScreen(ModalScreen[str | None]):
+    BINDINGS = [Binding("escape", "dismiss(None)", "cancel")]
+
+    def __init__(self, title: str, placeholder: str = "") -> None:
+        super().__init__()
+        self.title_text = title
+        self.placeholder = placeholder
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label(self.title_text, classes="dialog-title")
+            yield Input(placeholder=self.placeholder)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value.strip() or None)
+
+
+class TagScreen(ModalScreen[list[str] | None]):
+    """Space toggles a tag, Enter applies, Esc cancels."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss(None)", "cancel"),
+        Binding("enter", "apply", "apply", priority=True),
+    ]
+
+    def __init__(self, tags: list[str], selected: list[str]) -> None:
+        super().__init__()
+        self.tags = tags
+        self.selected = selected
+
+    def compose(self) -> ComposeResult:
+        with Vertical(classes="dialog"):
+            yield Label("Tags  (space toggles, enter applies)", classes="dialog-title")
+            yield SelectionList[str](*((t, t, t in self.selected) for t in self.tags))
+
+    def action_apply(self) -> None:
+        chosen = set(self.query_one(SelectionList).selected)
+        self.dismiss([t for t in self.tags if t in chosen])
+
+
+class StepList(ListView):
+    BINDINGS = [Binding("space", "app.toggle_step", "toggle step")]
+
+
+# ---------- app ----------
+
+
+class RumoApp(App):
+    TITLE = "rumo"
+    CSS = """
+    Screen { layout: vertical; }
+    #filter { display: none; }
+    #filter.on { display: block; }
+    #main { height: 1fr; }
+    #timeline { width: 45%; height: 1fr; border: round $primary-darken-1; }
+    #timeline:focus { border: round $primary; }
+    #detail { border: round $secondary-darken-1; padding: 0 1; }
+    #header { margin-bottom: 1; }
+    .section { text-style: bold; color: $accent; margin-top: 1; }
+    #steps, #sessions { height: auto; max-height: 12; }
+    Markdown { margin: 0; padding: 0; }
+    #legend, #keys { height: auto; padding: 0 1; }
+    ModalScreen { align: center middle; }
+    .dialog { width: 60; height: auto; max-height: 80%; border: round $primary; background: $surface; padding: 0 1; }
+    .dialog-title { text-style: bold; margin-bottom: 1; }
+    .dialog OptionList, .dialog SelectionList { height: auto; max-height: 20; }
+    """
+    BINDINGS = [
+        Binding("q", "quit", "quit"),
+        Binding("s", "status", "status"),
+        Binding("g", "group", "group"),
+        Binding("t", "tags", "tags"),
+        Binding("n", "new_idea", "new idea"),
+        Binding("e", "edit", "edit"),
+        Binding("c", "copy_resume", "copy resume"),
+        Binding("slash", "filter", "filter"),
+        Binding("escape", "clear_filter", "clear filter", show=False),
+    ]
+
+    def __init__(self, config_path: Path | None = None, today: date | None = None) -> None:
+        super().__init__()
+        self.config_path = config_path or config.default_path()
+        self.cfg = config.load(self.config_path)
+        self.today = today
+        self.items: dict[str, Item] = {}
+        self.current: str | None = None
+        self.filter_text = ""
+        self.show_older = False
+        self.mtimes: dict[str, float] = {}
+
+    def compose(self) -> ComposeResult:
+        yield Input(placeholder="filter by title, tag, group or text (Esc clears)", id="filter")
+        with Horizontal(id="main"):
+            yield OptionList(id="timeline")
+            with VerticalScroll(id="detail"):
+                yield Static(id="header")
+                yield Markdown(id="body")
+                yield Label("Steps", classes="section")
+                yield StepList(id="steps")
+                yield Label("Sessions  (c copies the resume command)", classes="section")
+                yield ListView(id="sessions")
+        yield Static(id="legend")
+        yield Static(KEYS, id="keys")
+
+    def on_mount(self) -> None:
+        self.cfg.folder.mkdir(parents=True, exist_ok=True)
+        if not self.cfg.error:
+            config.ensure_file(self.config_path, self.cfg.folder, self.cfg.language)
+        self.reload()
+        self.query_one("#timeline", OptionList).focus()
+        self.set_interval(2.0, self.check_changes)
+
+    # ---------- data ----------
+
+    def read_mtimes(self) -> dict[str, float]:
+        files = list(self.cfg.folder.glob("*.md"))
+        if self.config_path.exists():
+            files.append(self.config_path)
+        mtimes = {}
+        for path in files:
+            try:
+                mtimes[str(path)] = path.stat().st_mtime
+            except OSError:
+                continue
+        return mtimes
+
+    def check_changes(self) -> None:
+        if self.read_mtimes() != self.mtimes:
+            self.reload()
+
+    def reload(self) -> None:
+        self.cfg = config.load(self.config_path)
+        self.mtimes = self.read_mtimes()
+        self.items = {i.slug: i for i in items.list_items(self.cfg.folder)}
+        self.build_timeline()
+        self.show_detail()
+        self.query_one("#legend", Static).update(self.legend())
+
+    def group_style(self, item: Item) -> str:
+        group = self.cfg.groups.get(item.group)
+        return config.PALETTE.get(group.color, "") if group else ""
+
+    def matches(self, item: Item) -> bool:
+        term = self.filter_text.lower().strip()
+        if not term:
+            return True
+        group = self.cfg.groups.get(item.group)
+        haystack = [item.title, item.slug, item.status, item.group, group.name if group else "", *item.tags]
+        haystack += item.sections.values()
+        return term in " ".join(haystack).lower()
+
+    def write(self, operation: Callable[[], object]) -> None:
+        try:
+            operation()
+        except WriteConflict:
+            self.notify("The item just changed on disk. Reloaded; try again.", severity="warning")
+        self.reload()
+
+    # ---------- timeline ----------
+
+    def build_timeline(self) -> None:
+        timeline = self.query_one("#timeline", OptionList)
+        visible = [i for i in self.items.values() if self.matches(i)]
+        tl = items.timeline(visible, today=self.today, show_older=self.show_older)
+
+        options: list[Option] = []
+        if not self.items:
+            options.append(Option(Text(
+                "No items yet. Press n to capture an idea, or run /rumo new in an agent session.", "dim"
+            ), id="empty", disabled=True))
+        if tl.past or tl.older:
+            options.append(self.header("Past", f"last {items.PAST_WINDOW_DAYS} days" if not self.show_older else "all", "past"))
+            if tl.older:
+                options.append(Option(Text(f"  … {tl.older} older (enter to show)", "dim italic"), id="older"))
+            options += [Option(self.row(i, short_date(i.done_at)), id=f"item:{i.slug}") for i in tl.past]
+        if tl.now:
+            options.append(self.header("Now", str(len(tl.now)), "now"))
+            options += [Option(self.row(i, i.status, next_step=True), id=f"item:{i.slug}") for i in tl.now]
+        if tl.later:
+            options.append(self.header("Later", str(len(tl.later)), "later"))
+            options += [Option(self.row(i, i.status), id=f"item:{i.slug}") for i in tl.later]
+
+        timeline.clear_options()
+        timeline.add_options(options)
+
+        ids = [o.id for o in options]
+        target = f"item:{self.current}" if self.current else None
+        if target not in ids:
+            first_now = f"item:{tl.now[0].slug}" if tl.now else None
+            first_any = next((i for i in ids if i and i.startswith("item:")), None)
+            target = first_now or first_any
+        self.current = target.removeprefix("item:") if target else None
+        if target:
+            timeline.highlighted = ids.index(target)
+
+    @staticmethod
+    def header(name: str, note: str, key: str) -> Option:
+        return Option(Text.assemble((name, "bold"), (f"  {note}", "dim")), id=f"header:{key}", disabled=True)
+
+    def row(self, item: Item, prefix: str, next_step: bool = False) -> Text:
+        text = Text.assemble((f"{prefix:<8}", STATUS_STYLE.get(prefix, "dim")), (item.title, self.group_style(item)))
+        if item.steps:
+            done = sum(s.done for s in item.steps)
+            text.append(f"  {done}/{len(item.steps)}", "dim")
+        if next_step and (step := item.next_step):
+            text.append(f"\n        ↳ {step.text}", "dim")
+        return text
+
+    def legend(self) -> Text:
+        text = Text()
+        if self.cfg.error:
+            text.append(f"Config error, using defaults: {self.cfg.error}\n", "bold red")
+        if not self.cfg.groups:
+            return text.append("No groups yet. Press g on an item to create one.", "dim")
+        for group in self.cfg.groups.values():
+            text.append("● ", config.PALETTE.get(group.color, ""))
+            text.append(group.name + "    ")
+        return text
+
+    def on_option_list_option_highlighted(self, event: OptionList.OptionHighlighted) -> None:
+        if event.option_list.id != "timeline":
+            return
+        option_id = event.option.id or ""
+        if option_id.startswith("item:") and option_id.removeprefix("item:") != self.current:
+            self.current = option_id.removeprefix("item:")
+            self.show_detail()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        if event.option_list.id == "timeline" and event.option.id == "older":
+            self.show_older = True
+            self.build_timeline()
+
+    # ---------- detail ----------
+
+    def current_item(self) -> Item | None:
+        return self.items.get(self.current) if self.current else None
+
+    def show_detail(self) -> None:
+        item = self.current_item()
+        header = self.query_one("#header", Static)
+        body = self.query_one("#body", Markdown)
+        steps = self.query_one("#steps", ListView)
+        sessions = self.query_one("#sessions", ListView)
+        step_index, session_index = steps.index, sessions.index
+        steps.clear()
+        sessions.clear()
+        if item is None:
+            header.update(Text("Nothing selected.", "dim"))
+            body.update("")
+            return
+
+        line = Text.assemble((item.title, f"bold {self.group_style(item)}"), "\n", (item.status, STATUS_STYLE[item.status]))
+        if group := self.cfg.groups.get(item.group):
+            line.append("   group ", "dim")
+            line.append(group.name, config.PALETTE.get(group.color, ""))
+        if item.tags:
+            line.append("   tags ", "dim")
+            for tag in item.tags:
+                line.append(tag + " ", "" if tag in self.cfg.tags else "dim")
+        if updated := item.meta.get("updated"):
+            line.append(f"   updated {updated}", "dim")
+        header.update(line)
+
+        parts = []
+        for name in ("left off", "context"):
+            if content := item.sections.get(name):
+                parts.append(f"**{name.capitalize()}**\n\n{content}")
+        body.update("\n\n".join(parts))
+
+        steps.extend(ListItem(Label(self.step_label(s))) for s in item.steps)
+        sessions.extend(
+            ListItem(Label(Text.assemble((s.when, "dim"), "  ", s.repo, "  ", (s.id[:8], "cyan"), (" closed" if s.closed else "", "dim"))))
+            for s in reversed(item.sessions)
+        )
+        if item.steps:
+            steps.index = min(step_index or 0, len(item.steps) - 1)
+        if item.sessions:
+            sessions.index = min(session_index or 0, len(item.sessions) - 1)
+
+    @staticmethod
+    def step_label(step: items.Step) -> Text:
+        kind = f"[{step.kind}] " if step.kind else ""
+        if step.done:
+            return Text(f"[x] {kind}{step.text}", "dim strike")
+        return Text.assemble("[ ] ", (kind, "yellow" if step.kind == "manual" else "dim"), step.text)
+
+    # ---------- actions ----------
+
+    def action_toggle_step(self) -> None:
+        item = self.current_item()
+        index = self.query_one("#steps", ListView).index
+        if item is None or index is None or index >= len(item.steps):
+            return
+        step = item.steps[index]
+        self.write(lambda: items.toggle_step(item, step))
+
+    def action_status(self) -> None:
+        item = self.current_item()
+        if item is None:
+            return
+        choices = [(s, Text(s, STATUS_STYLE[s])) for s in items.STATUSES]
+
+        def chosen(status: str | None) -> None:
+            if status and status != item.status:
+                self.write(lambda: items.set_status(item, status))
+
+        self.push_screen(ChoiceScreen(f"Status of “{item.title}”", choices, item.status), chosen)
+
+    def action_group(self) -> None:
+        item = self.current_item()
+        if item is None:
+            return
+        choices = [
+            (g.key, Text(g.name, config.PALETTE.get(g.color, ""))) for g in self.cfg.groups.values()
+        ]
+        choices += [(NO_GROUP, Text("no group", "dim")), (NEW_GROUP, Text("+ new group…", "italic"))]
+
+        def chosen(key: str | None) -> None:
+            if key == NEW_GROUP:
+                self.new_group(item)
+            elif key is not None:
+                self.write(lambda: items.set_group(item, None if key == NO_GROUP else key))
+
+        self.push_screen(ChoiceScreen(f"Group of “{item.title}”", choices, item.group or NO_GROUP), chosen)
+
+    def new_group(self, item: Item) -> None:
+        def named(name: str | None) -> None:
+            if not name:
+                return
+            colors = [(c, Text(f"● {c}", hex_)) for c, hex_ in config.PALETTE.items()]
+
+            def colored(color: str | None) -> None:
+                if color:
+                    key = config.add_group(self.config_path, name, color)
+                    self.write(lambda: items.set_group(item, key))
+
+            self.push_screen(ChoiceScreen(f"Color for “{name}”", colors), colored)
+
+        self.push_screen(TextScreen("New group name", "e.g. Auth migration"), named)
+
+    def action_tags(self) -> None:
+        item = self.current_item()
+        if item is None:
+            return
+        tags = list(self.cfg.tags) + [t for t in item.tags if t not in self.cfg.tags]
+
+        def chosen(selected: list[str] | None) -> None:
+            if selected is not None and selected != item.tags:
+                self.write(lambda: items.set_tags(item, selected))
+
+        self.push_screen(TagScreen(tags, item.tags), chosen)
+
+    def action_new_idea(self) -> None:
+        def created(title: str | None) -> None:
+            if title:
+                path = items.create_idea(self.cfg.folder, title, now=datetime.now())
+                self.current = path.stem
+                self.reload()
+
+        self.push_screen(TextScreen("New idea", "a short title"), created)
+
+    def action_edit(self) -> None:
+        item = self.current_item()
+        if item is None:
+            return
+        editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or ("notepad" if os.name == "nt" else "vi")
+        with self.suspend():
+            subprocess.run([*shlex.split(editor, posix=os.name != "nt"), str(item.path)], check=False)
+        self.reload()
+
+    def action_copy_resume(self) -> None:
+        item = self.current_item()
+        if item is None or not item.sessions:
+            self.notify("This item has no sessions.", severity="warning")
+            return
+        sessions = self.query_one("#sessions", ListView)
+        recent = list(reversed(item.sessions))
+        index = sessions.index if sessions.has_focus and sessions.index is not None else 0
+        command = recent[index].resume_command
+        if shutil.which("pbcopy"):
+            subprocess.run(["pbcopy"], input=command.encode(), check=False)
+        else:
+            self.copy_to_clipboard(command)  # OSC 52: works in most terminals outside macOS
+        self.notify(f"Copied: {command}")
+
+    def action_filter(self) -> None:
+        field = self.query_one("#filter", Input)
+        field.add_class("on")
+        field.focus()
+
+    def action_clear_filter(self) -> None:
+        field = self.query_one("#filter", Input)
+        field.value = ""
+        field.remove_class("on")
+        self.query_one("#timeline", OptionList).focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "filter":
+            self.filter_text = event.value
+            self.build_timeline()
+            self.show_detail()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "filter":
+            self.query_one("#timeline", OptionList).focus()

rumo/cli.py

@@ -0,0 +1,77 @@
+"""The `rumo` command: opens the Timeline.
+
+Other subcommands exist for the agent and the hook, and are kept out of
+the help on purpose: `hook`, `index`, `path`, `group-add`, `--version`.
+"""
+
+from __future__ import annotations
+
+import sys
+
+USAGE = """rumo: your work, past, now and later.
+
+  rumo        open the Timeline
+
+Inside an AI agent session, type /rumo for the agent commands.
+"""
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = sys.argv[1:] if argv is None else argv
+    command = args[0] if args else ""
+
+    # Late imports: `rumo hook` runs on every prompt and must not pay for Textual.
+    if command == "":
+        from rumo.app import RumoApp
+
+        RumoApp().run()
+    elif command == "hook":
+        from rumo.hook import main as hook
+
+        hook()
+    elif command == "path":
+        from rumo import config
+
+        print(config.load().folder)
+    elif command == "index":
+        _index()
+    elif command == "group-add":
+        _group_add(args[1:])
+    elif command in ("-V", "--version"):
+        from importlib.metadata import version
+
+        print(f"rumo {version('rumo-cli')}")
+    elif command in ("-h", "--help", "help"):
+        print(USAGE, end="")
+    else:
+        print(USAGE, end="", file=sys.stderr)
+        raise SystemExit(2)
+
+
+def _index() -> None:
+    """Everything the agent needs in one call: where items live, the content language, tags, groups and items."""
+    from rumo import config, items
+
+    cfg = config.load()
+    print(f"# folder: {cfg.folder}")
+    print(f"# config: {cfg.path}")
+    print(f"# language: {cfg.language}")
+    print(f"# tags: {', '.join(cfg.tags)}")
+    print(f"# groups: {', '.join(f'{g.key} ({g.name}, {g.color})' for g in cfg.groups.values()) or '-'}")
+    print(f"# colors: {', '.join(config.PALETTE)}")
+    if listing := items.index(items.list_items(cfg.folder)):
+        print(listing)
+
+
+def _group_add(rest: list[str]) -> None:
+    """`rumo group-add "<name>" <color>`: append a group to the config and print its key."""
+    from rumo import config
+
+    if len(rest) != 2 or not rest[0].strip() or rest[1] not in config.PALETTE:
+        print(f'usage: rumo group-add "<name>" <{"|".join(config.PALETTE)}>', file=sys.stderr)
+        raise SystemExit(2)
+    print(config.add_group(config.load().path, rest[0].strip(), rest[1]))
+
+
+if __name__ == "__main__":
+    main()

rumo/config.py

@@ -0,0 +1,147 @@
+"""User config: config.toml in the place each system expects (see `default_path`), or $RUMO_CONFIG.
+
+    folder = "~/rumo"
+    language = "pt-BR"            # language of the content the agent writes
+    tags = ["bug", "feature"]     # fixed list the agent picks from
+
+    [groups.auth]
+    name = "Migração auth"        # content: any language
+    color = "blue"                # one of PALETTE
+
+A missing file means defaults; a malformed one means defaults plus `error`, never a crash.
+Stdlib only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import tomllib
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from rumo.items import slugify
+
+# Named colors that read well on dark and light terminals.
+PALETTE = {
+    "blue": "#5b8cff",
+    "green": "#3fbf7f",
+    "yellow": "#d9a520",
+    "orange": "#ec8a3c",
+    "red": "#e05d5d",
+    "magenta": "#d561b5",
+    "purple": "#a77ee8",
+    "cyan": "#2fb8c8",
+}
+
+DEFAULT_TAGS = [
+    "bug", "feature", "refactor", "research", "spike", "review",
+    "infra", "deploy", "meeting", "docs", "support", "tech-debt",
+]
+
+
+@dataclass
+class Group:
+    key: str
+    name: str
+    color: str  # a PALETTE name; anything else renders in the default color
+
+
+@dataclass
+class Config:
+    path: Path
+    folder: Path
+    language: str = "en"
+    tags: list[str] = field(default_factory=lambda: list(DEFAULT_TAGS))
+    groups: dict[str, Group] = field(default_factory=dict)
+    error: str | None = None
+
+
+def default_path(env: Mapping[str, str] | None = None, windows: bool | None = None) -> Path:
+    """$RUMO_CONFIG, else %APPDATA%\\rumo on Windows, else $XDG_CONFIG_HOME/rumo (default ~/.config/rumo)."""
+    env = os.environ if env is None else env
+    windows = os.name == "nt" if windows is None else windows
+    if override := env.get("RUMO_CONFIG"):
+        return Path(override).expanduser()
+    if windows:
+        base = Path(env["APPDATA"]) if env.get("APPDATA") else Path.home() / "AppData" / "Roaming"
+    else:
+        base = Path(env["XDG_CONFIG_HOME"]) if env.get("XDG_CONFIG_HOME") else Path.home() / ".config"
+    return base / "rumo" / "config.toml"
+
+
+def load(path: Path | None = None) -> Config:
+    path = path or default_path()
+    data: dict = {}
+    error = None
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        pass
+    except (OSError, UnicodeDecodeError, tomllib.TOMLDecodeError) as e:
+        error = f"{path}: {e}"
+
+    folder = os.environ.get("RUMO_DIR") or data.get("folder") or "~/rumo"
+    cfg = Config(path=path, folder=Path(str(folder)).expanduser(), language=language_from_env(), error=error)
+    if isinstance(language := data.get("language"), str) and language.strip():
+        cfg.language = language.strip()
+    if isinstance(tags := data.get("tags"), list):
+        cfg.tags = [str(t) for t in tags]
+    groups = data.get("groups")
+    for key, value in (groups.items() if isinstance(groups, dict) else []):
+        if isinstance(value, dict):
+            cfg.groups[key] = Group(key, str(value.get("name") or key), str(value.get("color", "")))
+    return cfg
+
+
+def language_from_env(env: Mapping[str, str] | None = None) -> str:
+    """The system language as a tag: `pt_BR.UTF-8` -> `pt-BR`; anything unusable -> `en`."""
+    env = os.environ if env is None else env
+    value = env.get("LC_ALL") or env.get("LANG") or ""
+    m = re.match(r"^([a-z]{2})(?:_([A-Z]{2}))?", value)
+    if not m:
+        return "en"
+    return f"{m.group(1)}-{m.group(2)}" if m.group(2) else m.group(1)
+
+
+def ensure_file(path: Path, folder: Path, language: str) -> None:
+    """Write a default config the first time, so there is a file to edit. Never overwrites."""
+    if path.exists():
+        return
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(default_text(folder, language), encoding="utf-8")
+
+
+def add_group(path: Path, name: str, color: str) -> str:
+    """Append a [groups.<key>] block as text (no TOML writer needed) and return the new key."""
+    existing = load(path).groups
+    base = slugify(name)
+    key, n = base, 2
+    while key in existing:
+        key, n = f"{base}-{n}", n + 1
+    text = path.read_text(encoding="utf-8") if path.exists() else ""
+    block = f'\n[groups.{key}]\nname = {toml_str(name)}\ncolor = {toml_str(color)}\n'
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text.rstrip("\n") + "\n" + block if text.strip() else block.lstrip("\n"), encoding="utf-8")
+    return key
+
+
+def default_text(folder: Path, language: str) -> str:
+    tags = ", ".join(toml_str(t) for t in DEFAULT_TAGS)
+    return (
+        "# rumo config. Colors: " + ", ".join(PALETTE) + "\n"
+        f"folder = {toml_str(str(folder))}\n"
+        f"language = {toml_str(language)}\n"
+        f"tags = [{tags}]\n"
+        "\n"
+        "# Groups connect related items; the title takes the group color.\n"
+        "# [groups.auth]\n"
+        '# name = "Auth migration"\n'
+        '# color = "blue"\n'
+    )
+
+
+def toml_str(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)  # a JSON string is a valid TOML basic string

rumo/hook.py

@@ -0,0 +1,47 @@
+"""Claude Code `UserPromptSubmit` hook: remind a linked session to keep its item up to date.
+
+The link is the session id written in an item's Sessions section (by `/rumo new` or
+`/rumo link`). A line ending in `| closed` (from park/unlink) no longer links, and after
+`/clear` the id changes, so the reminder stops on its own.
+
+The reminder carries the update rules, so they reach the agent exactly when they matter and
+nothing has to be added to the user's global instructions.
+Runs on every prompt: stdlib only, UTF-8 regardless of the console, silent on anything unexpected.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+from rumo import config, items
+
+RULES = (
+    "When you finish this response, if anything changed (step done, new step, change of direction, "
+    "blocker), update the item with the Edit tool: rewrite Left off (the next concrete action), check "
+    "or add Steps (`- [ ] [agent] ...` or `- [ ] [manual] ...` for work done outside the agent; work "
+    "with more than one stage and anything not done now becomes a step) and set `updated`. "
+    "Conversation-only replies need no update. Write content in the configured language (`rumo index`); "
+    "keep keys, sections, statuses and tags in English. Never set `done` without every step checked and "
+    "the user's confirmation. To stop updating from this session, append `| closed` to its line in Sessions."
+)
+
+
+def main() -> None:
+    try:
+        payload = json.loads(sys.stdin.buffer.read().decode("utf-8"))
+        session_id = payload.get("session_id", "")
+    except (ValueError, OSError, AttributeError):
+        return
+    if not session_id:
+        return
+
+    linked = []
+    for item in items.list_items(config.load().folder):
+        if any(s.id == session_id and not s.closed for s in item.sessions):
+            linked.append(f"{item.path} (status: {item.status})")
+
+    if linked:
+        message = "This session is linked to rumo item(s): " + "; ".join(linked) + ". " + RULES + "\n"
+        sys.stdout.buffer.write(message.encode("utf-8"))
+        sys.stdout.flush()

rumo/items.py

@@ -0,0 +1,305 @@
+"""Items: one Markdown file per piece of work, in a single local folder.
+
+There is no index or database. Every reader (the TUI, the hook, the agent) reads the
+folder, and every write checks that the file did not change since it was read, so a
+human in the TUI and an agent session never overwrite each other.
+
+Stdlib only: the hook imports this module on every prompt.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+import unicodedata
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from datetime import date, datetime, timedelta
+from pathlib import Path
+
+STATUSES = ("idea", "doing", "waiting", "paused", "done")
+
+TIME_FORMAT = "%Y-%m-%d %H:%M"
+PAST_WINDOW_DAYS = 14
+
+_STEP_RE = re.compile(r"^- \[( |x|X)\] (?:\[(agent|manual)\] )?(.*)$")
+_SECTION_RE = re.compile(r"^## (.+?)\s*$")
+
+
+class WriteConflict(Exception):
+    """The file changed on disk after it was read."""
+
+
+@dataclass
+class Step:
+    done: bool
+    kind: str  # "agent", "manual" or "" when the line has no marker
+    text: str
+    line: int  # index of the line in the file
+
+
+@dataclass
+class Session:
+    when: str
+    repo: str
+    id: str
+    folder: str
+    closed: bool
+
+    @property
+    def resume_command(self) -> str:
+        return self.resume_command_for(windows=os.name == "nt")
+
+    def resume_command_for(self, windows: bool) -> str:
+        """A command that reopens the agent session from its original folder, in the user's shell."""
+        if windows:  # PowerShell, where `&&` is missing before 7 and single quotes differ
+            return f'cd "{self.folder}"; claude --resume {self.id}'
+        return f"cd {shlex.quote(self.folder)} && claude --resume {self.id}"
+
+
+@dataclass
+class Item:
+    path: Path
+    mtime: float
+    meta: dict[str, str]
+    sections: dict[str, str]
+    steps: list[Step] = field(default_factory=list)
+    sessions: list[Session] = field(default_factory=list)
+
+    @property
+    def slug(self) -> str:
+        return self.path.stem
+
+    @property
+    def title(self) -> str:
+        return self.meta.get("title") or self.slug
+
+    @property
+    def status(self) -> str:
+        status = self.meta.get("status", "")
+        return status if status in STATUSES else "doing"
+
+    @property
+    def group(self) -> str:
+        return self.meta.get("group", "")
+
+    @property
+    def tags(self) -> list[str]:
+        return _parse_list(self.meta.get("tags", ""))
+
+    @property
+    def done_at(self) -> str:
+        """When the item was finished; hand-edited done items without `done:` fall back to `updated`."""
+        return self.meta.get("done") or self.meta.get("updated", "")
+
+    @property
+    def next_step(self) -> Step | None:
+        return next((s for s in self.steps if not s.done), None)
+
+
+def load(path: Path) -> Item:
+    mtime = path.stat().st_mtime
+    lines = path.read_text(encoding="utf-8").splitlines()
+    meta, body_start = _read_frontmatter(lines)
+
+    sections: dict[str, list[str]] = {}
+    steps: list[Step] = []
+    sessions: list[Session] = []
+    current = ""
+    for i in range(body_start, len(lines)):
+        line = lines[i]
+        if m := _SECTION_RE.match(line):
+            current = m.group(1).strip().lower()
+            sections[current] = []
+            continue
+        if not current:
+            continue
+        sections[current].append(line)
+        if current == "steps" and (m := _STEP_RE.match(line)):
+            steps.append(Step(m.group(1) != " ", m.group(2) or "", m.group(3), i))
+        elif current == "sessions" and line.startswith("- "):
+            parts = [p.strip() for p in line[2:].split("|")]
+            if len(parts) >= 4:
+                closed = len(parts) >= 5 and parts[4].lower() == "closed"
+                sessions.append(Session(parts[0], parts[1], parts[2], parts[3], closed))
+
+    return Item(
+        path=path,
+        mtime=mtime,
+        meta=meta,
+        sections={k: "\n".join(v).strip() for k, v in sections.items()},
+        steps=steps,
+        sessions=sessions,
+    )
+
+
+@dataclass
+class Timeline:
+    past: list[Item]  # done, oldest first so the list flows into Now
+    older: int  # done items hidden by the Past window
+    now: list[Item]  # doing, then waiting
+    later: list[Item]  # paused, then ideas
+
+
+def timeline(all_items: list[Item], today: date | None = None, show_older: bool = False) -> Timeline:
+    cutoff = ((today or date.today()) - timedelta(days=PAST_WINDOW_DAYS)).isoformat()
+    done = sorted((i for i in all_items if i.status == "done"), key=lambda i: i.done_at)
+    past = done if show_older else [i for i in done if i.done_at[:10] >= cutoff]
+
+    def by_status(order: tuple[str, ...]) -> list[Item]:
+        chosen = sorted((i for i in all_items if i.status in order), key=lambda i: i.meta.get("updated", ""), reverse=True)
+        return sorted(chosen, key=lambda i: order.index(i.status))  # stable: keeps recency inside each status
+
+    return Timeline(past, len(done) - len(past), by_status(("doing", "waiting")), by_status(("paused", "idea")))
+
+
+def index(all_items: list[Item]) -> str:
+    """One line per item, for an agent to judge similarity without opening every file."""
+    lines = []
+    for item in all_items:
+        parts = [item.slug, item.status, item.title]
+        if item.group:
+            parts.append(f"group: {item.group}")
+        if item.tags:
+            parts.append(f"tags: {', '.join(item.tags)}")
+        if left_off := item.sections.get("left off", "").split("\n")[0].strip():
+            parts.append(f"left off: {left_off[:120]}")
+        lines.append(" | ".join(parts))
+    return "\n".join(lines)
+
+
+def list_items(folder: Path) -> list[Item]:
+    found = []
+    for path in sorted(folder.glob("*.md")) if folder.is_dir() else []:
+        try:
+            found.append(load(path))
+        except (OSError, UnicodeDecodeError):
+            continue  # being written or unreadable: it shows up on the next read
+    return found
+
+
+def slugify(title: str) -> str:
+    ascii_title = unicodedata.normalize("NFKD", title).encode("ascii", "ignore").decode()
+    return re.sub(r"[^a-z0-9]+", "-", ascii_title.lower()).strip("-") or "item"
+
+
+def create_idea(folder: Path, title: str, now: datetime | None = None) -> Path:
+    """Create a small item with status `idea`; it grows into a full item when work starts."""
+    stamp = _stamp(now)
+    base = f"{stamp[:10]}-{slugify(title)}"
+    folder.mkdir(parents=True, exist_ok=True)
+    path, n = folder / f"{base}.md", 2
+    while path.exists():
+        path, n = folder / f"{base}-{n}.md", n + 1
+    text = f"---\ntitle: {title.strip()}\nstatus: idea\ntags: []\ncreated: {stamp}\nupdated: {stamp}\n---\n"
+    with path.open("x", encoding="utf-8") as f:  # "x": never overwrite a file created meanwhile
+        f.write(text)
+    return path
+
+
+def set_status(item: Item, status: str, now: datetime | None = None) -> None:
+    if status not in STATUSES:
+        raise ValueError(f"unknown status: {status}")
+    stamp = _stamp(now)
+
+    def edit(lines: list[str], _: int) -> None:
+        _set_meta(lines, "status", status)
+        _set_meta(lines, "done", stamp if status == "done" else None)
+
+    _save(item, edit, stamp)
+
+
+def set_group(item: Item, group: str | None, now: datetime | None = None) -> None:
+    _save(item, lambda lines, _: _set_meta(lines, "group", group or None), _stamp(now))
+
+
+def set_tags(item: Item, tags: list[str], now: datetime | None = None) -> None:
+    _save(item, lambda lines, _: _set_meta(lines, "tags", f"[{', '.join(tags)}]"), _stamp(now))
+
+
+def toggle_step(item: Item, step: Step, now: datetime | None = None) -> None:
+    def edit(lines: list[str], offset: int) -> None:
+        i = step.line + offset
+        m = _STEP_RE.match(lines[i]) if i < len(lines) else None
+        if not m or m.group(3) != step.text:
+            raise WriteConflict(item.path.name)
+        mark = " " if m.group(1) != " " else "x"
+        lines[i] = f"- [{mark}] " + lines[i][6:]
+
+    _save(item, edit, _stamp(now))
+
+
+def _stamp(now: datetime | None) -> str:
+    return (now or datetime.now()).strftime(TIME_FORMAT)
+
+
+def _save(item: Item, edit: Callable[[list[str], int], None], stamp: str) -> None:
+    """Apply `edit` to the file's lines and bump `updated`, unless the file changed since it was read.
+
+    `edit` gets the offset to add to body line numbers recorded at load time: a file without
+    frontmatter gets one prepended, and an unclosed one gets its closing `---` inserted.
+    """
+    if item.path.stat().st_mtime != item.mtime:
+        raise WriteConflict(item.path.name)
+    lines = item.path.read_text(encoding="utf-8").splitlines()
+    offset = 0
+    if not lines or lines[0].strip() != "---":
+        lines[:0] = ["---", "---"]
+        offset = 2
+    else:
+        end, closed = _frontmatter_end(lines)
+        if not closed:
+            lines.insert(end, "---")
+            offset = 1
+    edit(lines, offset)
+    _set_meta(lines, "updated", stamp)
+    tmp = item.path.with_name(item.path.name + ".tmp")
+    tmp.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    os.replace(tmp, item.path)
+
+
+def _frontmatter_end(lines: list[str]) -> tuple[int, bool]:
+    """Index of the line that ends the frontmatter (which starts at line 0) and whether it is a real `---`.
+
+    A hand edit may drop the closing `---`; then the frontmatter ends at the first line that
+    cannot be a `key: value` (a blank line or a section heading).
+    """
+    for i in range(1, len(lines)):
+        line = lines[i].strip()
+        if line == "---":
+            return i, True
+        if not line or line.startswith("#") or ":" not in line:
+            return i, False
+    return len(lines), False
+
+
+def _set_meta(lines: list[str], key: str, value: str | None) -> None:
+    """Set (or remove, when value is None) a frontmatter key, keeping every other line."""
+    end, _ = _frontmatter_end(lines)
+    for i in range(1, end):
+        if lines[i].partition(":")[0].strip() == key:
+            if value is None:
+                del lines[i]
+            else:
+                lines[i] = f"{key}: {value}"
+            return
+    if value is not None:
+        lines.insert(end, f"{key}: {value}")
+
+
+def _parse_list(value: str) -> list[str]:
+    value = value.strip().removeprefix("[").removesuffix("]")
+    return [v.strip() for v in value.split(",") if v.strip()]
+
+
+def _read_frontmatter(lines: list[str]) -> tuple[dict[str, str], int]:
+    if not lines or lines[0].strip() != "---":
+        return {}, 0
+    end, closed = _frontmatter_end(lines)
+    meta: dict[str, str] = {}
+    for line in lines[1:end]:
+        key, sep, value = line.partition(":")
+        if sep:
+            meta[key.strip()] = value.strip()
+    return meta, end + 1 if closed else end

rumo_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.5
+Name: rumo-cli
+Version: 0.1.0
+Summary: Your dev work, past, now and later: Markdown files, a terminal Timeline, and AI agents that keep it current
+Project-URL: Homepage, https://github.com/pedrobuzzi/rumo
+Project-URL: Issues, https://github.com/pedrobuzzi/rumo/issues
+Author: Pedro Buzzi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude-code,markdown,productivity,tasks,todo,tui,worklog
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Scheduling
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: textual>=1.0
+Description-Content-Type: text/markdown
+
+# rumo
+
+**Your work, past, now and later.** rumo is a local, file-based organizer for a developer's own
+work. Every piece of work is a Markdown file on your machine. Run `rumo` to see it all as a
+Timeline, and let your AI agent sessions keep it up to date while you work.
+
+![rumo Timeline](docs/timeline.svg)
+
+- **Now**: what you are doing or waiting on, with the next step of each item.
+- **Past**: what you finished in the last two weeks (answers "what did I do?" for a standup).
+- **Later**: ideas and paused work, so nothing you meant to do gets lost.
+
+Items can belong to a **group** (an initiative): the title takes the group color and the footer
+shows a legend. The interface is in English; the content (titles, notes, steps) is in your own
+language.
+
+Nothing leaves your machine. There is no server, no database and no sync with Jira or ClickUp
+(ask your agent to update those if you want).
+
+## Install
+
+**1. The `rumo` command** (pick one):
+
+```bash
+uv tool install rumo-cli            # macOS, Linux, Windows (https://docs.astral.sh/uv/)
+pipx install rumo-cli               # macOS, Linux, Windows
+brew install pedrobuzzi/tap/rumo    # macOS, Linux
+```
+
+Then run `rumo`. The first run creates `~/rumo/` for your items and a config file with your
+system language.
+
+**2. Your AI agent** (optional, but this is where rumo shines):
+
+- **Claude Code**, full experience (the agent keeps linked items up to date):
+
+  ```
+  /plugin marketplace add pedrobuzzi/rumo
+  /plugin install rumo@rumo
+  ```
+
+- **Codex, Gemini CLI, Cursor, GitHub Copilot and other agents** that read `SKILL.md` files,
+  simple mode (create items and ideas, list and search them; no automatic updates):
+
+  ```bash
+  npx skills add pedrobuzzi/rumo
+  ```
+
+**Update**: `uv tool upgrade rumo-cli` (or `pipx upgrade rumo-cli`, `brew upgrade rumo`), and
+`/plugin marketplace update rumo` in Claude Code.
+
+**Uninstall**: `/plugin uninstall rumo@rumo`, then `uv tool uninstall rumo-cli` (or
+`pipx uninstall rumo-cli`, `brew uninstall rumo`). Your items in `~/rumo/` are never touched.
+
+## Use
+
+**In the terminal**: `rumo` opens the Timeline.
+
+| Key | Action |
+|---|---|
+| ↑ ↓ | move through the Timeline |
+| Tab | switch between Timeline, steps and sessions |
+| `s` | change status (1-5 picks directly) |
+| `g` | set the group, or create a new one with a color |
+| `t` | toggle tags |
+| `n` | capture a new idea |
+| `e` | open the item in `$EDITOR` |
+| space | check or uncheck the selected step |
+| `c` | copy the command that resumes the selected agent session |
+| `/` | filter by title, tag, group or text (Esc clears) |
+| `q` | quit |
+
+**In an agent session**: type `/rumo` for a menu that fits the moment, or go straight to:
+
+| Command | What it does |
+|---|---|
+| `/rumo new` | Track this session's work as an item. Looks for a similar idea first and offers to promote it. |
+| `/rumo idea <text>` | Note something for later without leaving the topic. |
+| `/rumo link [item]` | Continue an existing item in this session. |
+| `/rumo now` | List what is in progress, with the next step of each. |
+| `/rumo find <text>` | Search past, current and future items. |
+| `/rumo status` | Show where you left off on the linked item. |
+| `/rumo step <text>` | Add a step to the linked item. |
+| `/rumo park [reason]` | Pause the item with an accurate "Left off" and stop updating it here. |
+| `/rumo done` | Finish the item (checks the steps, asks first). |
+| `/rumo unlink` | Stop updating the item from this session. |
+
+`link`, `status`, `step`, `park` and `unlink` need Claude Code with the plugin, because they rely on
+its session id and hook. Other agents get the rest.
+
+When you create an item or an idea, the agent checks whether it belongs to an existing group. If
+other ungrouped items look like the same initiative, it suggests a new group (name and color) and
+applies it only if you agree.
+
+While a session is linked, the agent updates the item after every response in which something
+changed. `/clear` starts a new, unlinked session; `claude --resume <id>` picks the old one up again.
+
+## Item format
+
+```markdown
+---
+title: Redirect after logout
+status: doing
+group: auth
+tags: [bug, frontend]
+created: 2026-10-11 10:08
+updated: 2026-10-11 16:30
+---
+
+## Left off
+Point the redirect to the home page; the e2e test is still missing.
+
+## Context
+Users land on a protected page after logging out.
+
+## Steps
+- [x] [agent] Fix the logout handler
+- [ ] [manual] Ask for a PR review
+- [ ] [agent] e2e test for logout
+
+## Sessions
+- 2026-10-11 10:08 | web-app (main) | 7134aad0-4ba6-4583-9503-c08e98d28270 | /Users/you/repo/web-app
+```
+
+- Statuses: `idea`, `doing`, `waiting`, `paused`, `done`. `done: <date>` is set when an item is finished.
+- Steps are `[agent]` (the AI can do it) or `[manual]` (you or someone else does it).
+- An idea can be just the frontmatter; it grows when you start working on it.
+- A session line ending in `| closed` no longer updates the item.
+
+## Config
+
+`config.toml` lives in `~/.config/rumo/` on macOS and Linux (or `$XDG_CONFIG_HOME/rumo/`) and in
+`%APPDATA%\rumo\` on Windows. `rumo index` prints its path.
+
+```toml
+folder = "~/rumo"
+language = "pt-BR"     # language of the content the agent writes; defaults to your system language
+tags = ["bug", "feature", "refactor", "research", "spike", "review",
+        "infra", "deploy", "meeting", "docs", "support", "tech-debt"]
+
+[groups.auth]
+name = "Auth migration"
+color = "blue"         # blue, green, yellow, orange, red, magenta, purple, cyan
+```
+
+`RUMO_DIR` and `RUMO_CONFIG` override the folder and the config path.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the layout, tests, trying the plugin locally and how
+releases work.
+
+## License
+
+[MIT](LICENSE)

rumo_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+rumo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rumo/app.py,sha256=kmPIdwlb1JLdvbgzw9B6QmWLTAKGizs914QyLiP1kIQ,19713
+rumo/cli.py,sha256=ABnKtx_lSKdrGMHs6_15f_44heJmB_trf-JW3YEBwuY,2361
+rumo/config.py,sha256=u4szi5GT0Sw1JhaSytaSfglMGMMrdVG6kGfExKrOLn8,5182
+rumo/hook.py,sha256=6iXvUc3xtAUaM0VVZ78e_A4cZVnATu9hIyEInkeJxQw,2082
+rumo/items.py,sha256=PqcvrFO3x-yuJMAv3hitEYjw86LaEzbmlJo2mjg5Lo4,10722
+rumo_cli-0.1.0.dist-info/METADATA,sha256=dXYdMRgXERaw1AdM8pJGRksHZ-x_ULr8Dy7z4i493Do,6554
+rumo_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+rumo_cli-0.1.0.dist-info/entry_points.txt,sha256=dgLTBmdLBqXNofuG0FF6vxkht27rMqF4R5Kg7R_Lve8,39
+rumo_cli-0.1.0.dist-info/licenses/LICENSE,sha256=NJ_6PjU8Tz0ohCibbfwKuUgfqouLxiLbET5q27TyYfQ,1074
+rumo_cli-0.1.0.dist-info/RECORD,,

rumo_cli-0.1.0.dist-info/WHEEL

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

rumo_cli-0.1.0.dist-info/entry_points.txt

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

rumo_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Buzzi Filho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.