remoro 0.1.0__py3-none-any.whl

remo/__init__.py

@@ -0,0 +1,5 @@
+"""remo — Project-aware terminal companion for developers."""
+
+__version__ = "0.1.0"
+__author__ = "Nikhil"
+__license__ = "MIT"

remo/_reminder_worker.py

@@ -0,0 +1,32 @@
+"""Detached reminder worker — run as a subprocess, sleep, then notify.
+
+Usage (internal — spawned by remo remind):
+    python -m remo._reminder_worker <seconds> <message> [project_name]
+"""
+
+import sys
+import time
+
+
+def main() -> None:
+    """Sleep for the specified duration then fire a notification."""
+    if len(sys.argv) < 3:
+        sys.exit(1)
+
+    try:
+        seconds = int(sys.argv[1])
+    except ValueError:
+        sys.exit(1)
+
+    message = sys.argv[2]
+    project_name = sys.argv[3] if len(sys.argv) > 3 else "remo"
+
+    time.sleep(seconds)
+
+    title = f"remo · {project_name}"
+    from remo.notifications.dispatcher import notify
+    notify(title, message)
+
+
+if __name__ == "__main__":
+    main()

remo/checks/__init__.py

@@ -0,0 +1 @@
+"""Checks sub-package."""

remo/checks/cmd_check.py

@@ -0,0 +1,66 @@
+"""Check a shell command's exit code."""
+
+import subprocess
+from typing import NamedTuple, Optional
+
+
+class CmdCheckResult(NamedTuple):
+    """Result of a command exit-code check."""
+
+    status: str  # "pass" | "fail"
+    cmd: str
+    label: str
+    exit_code: Optional[int]
+    message: str
+
+
+def run_cmd_check(cmd: str, label: Optional[str] = None) -> CmdCheckResult:
+    """Run a shell command and check that it exits with code 0.
+
+    Args:
+        cmd: Shell command string to execute.
+        label: Human-readable label for display (defaults to cmd).
+
+    Returns:
+        CmdCheckResult with status and exit code.
+    """
+    display_label = label or cmd
+
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            timeout=15,
+        )
+        if result.returncode == 0:
+            return CmdCheckResult(
+                status="pass",
+                cmd=cmd,
+                label=display_label,
+                exit_code=0,
+                message="running (exit 0)",
+            )
+        return CmdCheckResult(
+            status="fail",
+            cmd=cmd,
+            label=display_label,
+            exit_code=result.returncode,
+            message=f"exited with code {result.returncode}",
+        )
+    except subprocess.TimeoutExpired:
+        return CmdCheckResult(
+            status="fail",
+            cmd=cmd,
+            label=display_label,
+            exit_code=None,
+            message="command timed out after 15s",
+        )
+    except Exception as exc:
+        return CmdCheckResult(
+            status="fail",
+            cmd=cmd,
+            label=display_label,
+            exit_code=None,
+            message=f"error running command: {exc}",
+        )

remo/checks/env_check.py

@@ -0,0 +1,90 @@
+"""Check .env file against .env.example — report missing keys."""
+
+from pathlib import Path
+from typing import Dict, List, NamedTuple
+
+
+class EnvCheckResult(NamedTuple):
+    """Result of an .env check."""
+
+    status: str  # "pass" | "fail" | "skip"
+    missing_keys: List[str]
+    present_count: int
+    total_count: int
+    message: str
+
+
+def _parse_env_keys(path: Path) -> List[str]:
+    """Parse key names from a .env-style file (ignores comments and blanks)."""
+    keys: List[str] = []
+    with open(path, "r", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key = line.split("=", 1)[0].strip()
+                if key:
+                    keys.append(key)
+    return keys
+
+
+def run_env_check(
+    example_file: str,
+    env_file: str = ".env",
+    base_dir: Path = Path("."),
+) -> EnvCheckResult:
+    """Compare .env against .env.example and report missing keys.
+
+    Args:
+        example_file: Path to the .env.example file (relative to base_dir).
+        env_file: Path to the .env file (relative to base_dir).
+        base_dir: Directory to resolve paths against.
+
+    Returns:
+        EnvCheckResult with status, missing keys, and counts.
+    """
+    example_path = base_dir / example_file
+    env_path = base_dir / env_file
+
+    if not example_path.exists():
+        return EnvCheckResult(
+            status="skip",
+            missing_keys=[],
+            present_count=0,
+            total_count=0,
+            message=f"{example_file} not found — skipping env check",
+        )
+
+    example_keys = _parse_env_keys(example_path)
+    total = len(example_keys)
+
+    if not env_path.exists():
+        return EnvCheckResult(
+            status="fail",
+            missing_keys=example_keys,
+            present_count=0,
+            total_count=total,
+            message=f".env not found — all {total} keys missing",
+        )
+
+    env_keys = set(_parse_env_keys(env_path))
+    missing = [k for k in example_keys if k not in env_keys]
+    present = total - len(missing)
+
+    if missing:
+        return EnvCheckResult(
+            status="fail",
+            missing_keys=missing,
+            present_count=present,
+            total_count=total,
+            message=f"missing keys: {', '.join(missing)}",
+        )
+
+    return EnvCheckResult(
+        status="pass",
+        missing_keys=[],
+        present_count=total,
+        total_count=total,
+        message=f"all {total} keys present",
+    )

remo/checks/file_check.py

@@ -0,0 +1,40 @@
+"""Check that a required file exists on disk."""
+
+from pathlib import Path
+from typing import NamedTuple
+
+
+class FileCheckResult(NamedTuple):
+    """Result of a file existence check."""
+
+    status: str  # "pass" | "fail"
+    path: str
+    message: str
+
+
+def run_file_check(path: str, base_dir: Path = Path(".")) -> FileCheckResult:
+    """Assert that a file exists.
+
+    Args:
+        path: File path to check (relative to base_dir or absolute).
+        base_dir: Directory to resolve relative paths against.
+
+    Returns:
+        FileCheckResult with status and message.
+    """
+    target = Path(path)
+    if not target.is_absolute():
+        target = base_dir / path
+
+    if target.exists():
+        return FileCheckResult(
+            status="pass",
+            path=str(path),
+            message="exists",
+        )
+
+    return FileCheckResult(
+        status="fail",
+        path=str(path),
+        message=f"file not found: {target}",
+    )

remo/checks/version_check.py

@@ -0,0 +1,110 @@
+"""Check that a tool meets a minimum version requirement."""
+
+import re
+import shutil
+import subprocess
+from typing import List, NamedTuple, Optional, Tuple
+
+
+class VersionCheckResult(NamedTuple):
+    """Result of a version check."""
+
+    status: str  # "pass" | "fail" | "missing"
+    tool: str
+    required: str
+    found: Optional[str]
+    message: str
+
+
+def _parse_version(version_str: str) -> Optional[Tuple[int, ...]]:
+    """Parse a version string like '3.11.2' into a tuple of ints."""
+    match = re.search(r"(\d+)(?:\.(\d+))?(?:\.(\d+))?", version_str)
+    if not match:
+        return None
+    parts = [int(g) for g in match.groups() if g is not None]
+    return tuple(parts)
+
+
+def _get_tool_version(tool: str) -> Optional[str]:
+    """Run `tool --version` and return the output, or None if not found."""
+    if shutil.which(tool) is None:
+        return None
+
+    # Some tools use `--version`, some use `version`, some use `-v`
+    for flag in ["--version", "-v", "version"]:
+        try:
+            result = subprocess.run(
+                [tool, flag],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            output = (result.stdout + result.stderr).strip()
+            if output:
+                return output
+        except (subprocess.TimeoutExpired, OSError):
+            continue
+
+    return None
+
+
+def _compare_versions(found: Tuple[int, ...], required: Tuple[int, ...]) -> bool:
+    """Return True if found >= required."""
+    # Pad shorter tuple with zeros
+    max_len = max(len(found), len(required))
+    found_padded = found + (0,) * (max_len - len(found))
+    req_padded = required + (0,) * (max_len - len(required))
+    return found_padded >= req_padded
+
+
+def run_version_check(tool: str, min_version: str) -> VersionCheckResult:
+    """Check that `tool` is installed and meets the minimum version.
+
+    Args:
+        tool: The tool name (e.g., "python", "node").
+        min_version: Minimum required version string (e.g., "3.11").
+
+    Returns:
+        VersionCheckResult with status and details.
+    """
+    version_output = _get_tool_version(tool)
+
+    if version_output is None:
+        return VersionCheckResult(
+            status="missing",
+            tool=tool,
+            required=min_version,
+            found=None,
+            message=f"{tool} not found in PATH",
+        )
+
+    found_version = _parse_version(version_output)
+    req_version = _parse_version(min_version)
+
+    if found_version is None or req_version is None:
+        return VersionCheckResult(
+            status="fail",
+            tool=tool,
+            required=min_version,
+            found=version_output,
+            message=f"could not parse version from output: {version_output!r}",
+        )
+
+    found_str = ".".join(str(x) for x in found_version)
+
+    if _compare_versions(found_version, req_version):
+        return VersionCheckResult(
+            status="pass",
+            tool=tool,
+            required=min_version,
+            found=found_str,
+            message=f"found {found_str} (>= {min_version})",
+        )
+
+    return VersionCheckResult(
+        status="fail",
+        tool=tool,
+        required=min_version,
+        found=found_str,
+        message=f"need >= {min_version}, found {found_str}",
+    )

remo/cli.py

@@ -0,0 +1,34 @@
+"""CLI entry point — registers all remo commands."""
+
+import click
+from remo import __version__
+from remo.commands.startup import show_startup
+from remo.commands.init import init
+from remo.commands.remind import remind
+from remo.commands.check import check
+from remo.commands.log import log
+from remo.commands.run import run, shortcuts
+from remo.commands.snooze import snooze
+from remo.commands.status import status
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="remo")
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """remo — Project-aware terminal companion for developers.
+
+    Run without arguments to show the startup panel for the current project.
+    """
+    if ctx.invoked_subcommand is None:
+        show_startup()
+
+
+main.add_command(init)
+main.add_command(remind)
+main.add_command(check)
+main.add_command(log)
+main.add_command(run)
+main.add_command(shortcuts)
+main.add_command(snooze)
+main.add_command(status)

remo/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands sub-package."""

remo/commands/check.py

@@ -0,0 +1,146 @@
+"""remo check — run all environment checks defined in .remo config."""
+
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+import click
+from rich.console import Console
+from rich.rule import Rule
+
+from remo.ui.colors import COLORS
+
+console = Console()
+
+
+def _run_single_check(check_def: Dict[str, Any], base_dir: Path) -> None:
+    """Run a single check definition and print the result."""
+    check_type = check_def.get("type")
+
+    if check_type == "env":
+        from remo.checks.env_check import run_env_check
+        example_file = check_def.get("file", ".env.example")
+        result = run_env_check(example_file, base_dir=base_dir)
+        label = ".env"
+        if result.status == "pass":
+            console.print(
+                f"  [{COLORS['success']}]✓[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+        elif result.status == "skip":
+            console.print(
+                f"  [{COLORS['warning']}]![/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+        else:
+            console.print(
+                f"  [{COLORS['error']}]✗[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+
+    elif check_type == "version":
+        from remo.checks.version_check import run_version_check
+        tool = check_def.get("tool", "")
+        min_ver = check_def.get("min", "0")
+        result = run_version_check(tool, min_ver)
+
+        if result.status == "pass":
+            console.print(
+                f"  [{COLORS['success']}]✓[/]  [bold]{tool}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+        elif result.status == "missing":
+            console.print(
+                f"  [{COLORS['warning']}]![/]  [bold]{tool}[/]"
+                f"      [dim]not found (shortcuts using {tool} will fail)[/]"
+            )
+        else:
+            console.print(
+                f"  [{COLORS['error']}]✗[/]  [bold]{tool}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+
+    elif check_type == "file":
+        from remo.checks.file_check import run_file_check
+        path = check_def.get("path", "")
+        result = run_file_check(path, base_dir=base_dir)
+        label = path
+
+        if result.status == "pass":
+            console.print(
+                f"  [{COLORS['success']}]✓[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+        else:
+            console.print(
+                f"  [{COLORS['error']}]✗[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+
+    elif check_type == "cmd":
+        from remo.checks.cmd_check import run_cmd_check
+        cmd = check_def.get("cmd", "")
+        label = check_def.get("label", cmd)
+        result = run_cmd_check(cmd, label=label)
+
+        if result.status == "pass":
+            console.print(
+                f"  [{COLORS['success']}]✓[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+        else:
+            console.print(
+                f"  [{COLORS['error']}]✗[/]  [bold]{label}[/]"
+                f"      [dim]{result.message}[/]"
+            )
+    else:
+        console.print(f"  [dim]?  unknown check type: {check_type!r}[/]")
+
+
+@click.command()
+@click.option(
+    "--env-only",
+    is_flag=True,
+    default=False,
+    help="Only run the .env vs .env.example check.",
+)
+def check(env_only: bool) -> None:
+    """Run all environment checks defined in .remo config."""
+    from remo.config.loader import load_config, ConfigError
+
+    try:
+        config, config_dir = load_config()
+    except ConfigError as exc:
+        console.print(f"[red]✗ Error:[/red] {exc}")
+        if exc.hint:
+            console.print(f"[dim]  Hint: {exc.hint}[/dim]")
+        sys.exit(1)
+
+    checks = config.get("checks", [])
+
+    if env_only:
+        checks = [c for c in checks if c.get("type") == "env"]
+        if not checks:
+            console.print(
+                f"[{COLORS['warning']}]![/] No env checks defined in .remo."
+            )
+            return
+
+    project_name = config.get("project", "Project")
+    console.print()
+    console.print(Rule(
+        f"  [{COLORS['header']}]Environment Check — {project_name}[/]  ",
+        style=COLORS["dim"],
+    ))
+
+    if not checks:
+        console.print(
+            f"  [dim]No checks defined in .remo. "
+            "Add a 'checks' section to get started.[/]"
+        )
+        return
+
+    for check_def in checks:
+        _run_single_check(check_def, config_dir)
+
+    console.print()