trigr 0.1.0__tar.gz

trigr-0.1.0/CLAUDE.md

@@ -0,0 +1,44 @@
+# trigr
+
+Lightweight CLI that compiles task specs (TOML) into native macOS `launchd` plists. No daemon — launchd *is* the scheduler.
+
+## Architecture
+
+```
+TOML task → trigr add → launchd plist → launchd fires → trigr run → execute → log + notify
+```
+
+## Key Paths
+
+- Config: `~/.config/trigr/`
+- Tasks: `~/.config/trigr/tasks/*.toml`
+- Logs: `~/.config/trigr/logs/`
+- DB: `~/.config/trigr/history.db`
+- Plists: `~/Library/LaunchAgents/com.trigr.*.plist`
+
+## Commands
+
+- `trigr init` — create dirs, capture env
+- `trigr add <file.toml>` — register + load
+- `trigr remove <name>` — unload + delete
+- `trigr enable/disable <name>` — load/unload in launchd
+- `trigr list [--json]` — show all tasks
+- `trigr show <name> [--json]` — show config
+- `trigr logs [name] [-n 20] [--json]` — run history
+- `trigr run <name>` — execute immediately
+- `trigr edit <name>` — edit in $EDITOR
+
+## Dev
+
+```bash
+uv sync
+uv run pytest
+uv tool install .  # installs `trigr` globally
+```
+
+## Notes
+
+- Uses `plistlib` (stdlib) for plist generation
+- `fcntl.flock` for run locking (skip if already running)
+- SQLite for run history, osascript for notifications
+- Env captured at `trigr init` time and baked into plists

trigr-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: trigr
+Version: 0.1.0
+Summary: Lightweight CLI that compiles task specs into launchd schedules
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.11.0
+Requires-Dist: rich>=14.0.0
+Requires-Dist: typer>=0.16.0

trigr-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "trigr"
+version = "0.1.0"
+description = "Lightweight CLI that compiles task specs into launchd schedules"
+requires-python = ">=3.12"
+dependencies = [
+    "typer>=0.16.0",
+    "pydantic>=2.11.0",
+    "rich>=14.0.0",
+]
+
+[project.scripts]
+trigr = "trigr.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = ["pytest>=8.4.0", "ruff>=0.11.0"]

trigr-0.1.0/src/trigr/__init__.py

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

trigr-0.1.0/src/trigr/cli.py

@@ -0,0 +1,333 @@
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import tomllib
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from trigr.config import TASKS_DIR, ensure_init, init
+from trigr.models import TaskConfig
+from trigr.plist import is_loaded, load_plist, plist_path, remove_plist, unload_plist, write_plist
+from trigr.runner import run_task
+from trigr.store import get_runs
+
+app = typer.Typer(help="Compile task specs into launchd schedules.", no_args_is_help=True)
+console = Console()
+
+
+def _load_task_from_file(path: Path) -> TaskConfig:
+    """Load and validate a task config from a TOML file."""
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+    return TaskConfig(**data)
+
+
+def _all_tasks() -> list[TaskConfig]:
+    """Load all task configs from the tasks directory."""
+    tasks: list[TaskConfig] = []
+    for toml_file in sorted(TASKS_DIR.glob("*.toml")):
+        try:
+            tasks.append(_load_task_from_file(toml_file))
+        except Exception:
+            pass
+    return tasks
+
+
+@app.command(name="init")
+def init_cmd() -> None:
+    """Initialize trigr: create dirs, capture env, init database."""
+    init()
+    console.print("Initialized trigr.", style="green")
+
+
+@app.command()
+def add(file: Path) -> None:
+    """Register a task from a TOML file, generate plist, and load into launchd."""
+    ensure_init()
+    if not file.exists():
+        console.print(f"File not found: {file}", style="red")
+        raise typer.Exit(1)
+
+    task = _load_task_from_file(file)
+
+    # Copy TOML to tasks dir
+    dest = TASKS_DIR / f"{task.name}.toml"
+    if dest.exists():
+        console.print(f"Task '{task.name}' already exists. Use 'trigr remove' first.", style="red")
+        raise typer.Exit(1)
+
+    shutil.copy2(file, dest)
+
+    # Generate and write plist
+    plist_file = write_plist(task)
+
+    # Load into launchd if enabled
+    if task.enabled:
+        load_plist(task.name)
+        console.print(f"Added and loaded task '{task.name}'.", style="green")
+    else:
+        console.print(f"Added task '{task.name}' (disabled).", style="yellow")
+
+    console.print(f"  TOML: {dest}")
+    console.print(f"  Plist: {plist_file}")
+
+
+@app.command()
+def remove(name: str) -> None:
+    """Unload and remove a task (plist + task file)."""
+    ensure_init()
+    task_file = TASKS_DIR / f"{name}.toml"
+
+    if not task_file.exists():
+        console.print(f"Task '{name}' not found.", style="red")
+        raise typer.Exit(1)
+
+    # Unload from launchd
+    unload_plist(name)
+    remove_plist(name)
+    task_file.unlink()
+    console.print(f"Removed task '{name}'.", style="green")
+
+
+@app.command()
+def enable(name: str) -> None:
+    """Load a task into launchd."""
+    ensure_init()
+    task_file = TASKS_DIR / f"{name}.toml"
+    if not task_file.exists():
+        console.print(f"Task '{name}' not found.", style="red")
+        raise typer.Exit(1)
+
+    # Regenerate plist in case it's missing
+    task = _load_task_from_file(task_file)
+    write_plist(task)
+
+    if load_plist(name):
+        console.print(f"Enabled task '{name}'.", style="green")
+    else:
+        console.print(f"Failed to enable task '{name}'.", style="red")
+        raise typer.Exit(1)
+
+
+@app.command()
+def disable(name: str) -> None:
+    """Unload a task from launchd."""
+    ensure_init()
+    if unload_plist(name):
+        console.print(f"Disabled task '{name}'.", style="green")
+    else:
+        console.print(f"Failed to disable task '{name}'.", style="red")
+        raise typer.Exit(1)
+
+
+@app.command(name="list")
+def list_cmd(
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    """List all tasks with status and last run info."""
+    ensure_init()
+    tasks = _all_tasks()
+
+    if as_json:
+        output = []
+        for task in tasks:
+            runs = get_runs(task.name, limit=1)
+            last_run = runs[0] if runs else None
+            output.append({
+                "name": task.name,
+                "description": task.description,
+                "trigger": task.trigger.type.value,
+                "action": task.action.type,
+                "enabled": task.enabled,
+                "loaded": is_loaded(task.name),
+                "last_run": last_run,
+            })
+        typer.echo(json.dumps(output, indent=2))
+        return
+
+    if not tasks:
+        console.print("No tasks registered.", style="yellow")
+        return
+
+    table = Table(title="Scheduled Tasks")
+    table.add_column("Name", style="cyan")
+    table.add_column("Trigger")
+    table.add_column("Action")
+    table.add_column("Status")
+    table.add_column("Last Run")
+
+    for task in tasks:
+        loaded = is_loaded(task.name)
+        status = "[green]loaded[/green]" if loaded else "[yellow]unloaded[/yellow]"
+
+        runs = get_runs(task.name, limit=1)
+        if runs:
+            last = runs[0]
+            code = last["exit_code"]
+            color = "green" if code == 0 else "red"
+            last_run = f"[{color}]exit {code}[/{color}] @ {last['finished_at'][:19]}"
+        else:
+            last_run = "[dim]never[/dim]"
+
+        table.add_row(
+            task.name,
+            task.trigger.type.value,
+            task.action.type,
+            status,
+            last_run,
+        )
+
+    console.print(table)
+
+
+@app.command()
+def show(
+    name: str,
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    """Show full task configuration."""
+    ensure_init()
+    task_file = TASKS_DIR / f"{name}.toml"
+    if not task_file.exists():
+        console.print(f"Task '{name}' not found.", style="red")
+        raise typer.Exit(1)
+
+    task = _load_task_from_file(task_file)
+
+    if as_json:
+        typer.echo(task.model_dump_json(indent=2))
+        return
+
+    console.print(f"[bold cyan]{task.name}[/bold cyan]")
+    if task.description:
+        console.print(f"  {task.description}")
+    console.print(f"  Trigger: {task.trigger.type.value}")
+    console.print(f"  Action:  {task.action.type}")
+    console.print(f"  Timeout: {task.action.timeout}s")
+    console.print(f"  Loaded:  {is_loaded(name)}")
+    console.print(f"  Plist:   {plist_path(name)}")
+    console.print(f"  TOML:    {task_file}")
+
+
+@app.command()
+def logs(
+    name: str | None = typer.Argument(None, help="Task name (all tasks if omitted)"),
+    n: int = typer.Option(20, "-n", help="Number of entries"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    """Show run history from SQLite."""
+    ensure_init()
+    runs = get_runs(name, limit=n)
+
+    if as_json:
+        typer.echo(json.dumps(runs, indent=2))
+        return
+
+    if not runs:
+        console.print("No runs recorded.", style="yellow")
+        return
+
+    table = Table(title="Run History")
+    table.add_column("ID", style="dim")
+    table.add_column("Task", style="cyan")
+    table.add_column("Started")
+    table.add_column("Duration")
+    table.add_column("Exit")
+
+    for run in runs:
+        code = run["exit_code"]
+        exit_style = "green" if code == 0 else "red"
+
+        started = run["started_at"][:19]
+        # Compute duration
+        if run["finished_at"] and run["started_at"]:
+            from datetime import datetime
+            try:
+                s = datetime.fromisoformat(run["started_at"])
+                f = datetime.fromisoformat(run["finished_at"])
+                dur = f"{(f - s).total_seconds():.1f}s"
+            except Exception:
+                dur = "?"
+        else:
+            dur = "?"
+
+        table.add_row(
+            str(run["id"]),
+            run["task_name"],
+            started,
+            dur,
+            f"[{exit_style}]{code}[/{exit_style}]",
+        )
+
+    console.print(table)
+
+
+@app.command()
+def run(name: str) -> None:
+    """Execute a task immediately (runner entrypoint for launchd)."""
+    ensure_init()
+    exit_code = run_task(name)
+    raise typer.Exit(exit_code)
+
+
+@app.command()
+def edit(name: str) -> None:
+    """Open task TOML in $EDITOR, re-validate and regenerate plist on save."""
+    ensure_init()
+    task_file = TASKS_DIR / f"{name}.toml"
+    if not task_file.exists():
+        console.print(f"Task '{name}' not found.", style="red")
+        raise typer.Exit(1)
+
+    editor = os.environ.get("EDITOR", "nano")
+
+    # Copy to temp file for editing
+    content_before = task_file.read_text()
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as tmp:
+        tmp.write(content_before)
+        tmp_path = tmp.name
+
+    try:
+        subprocess.run([editor, tmp_path], check=True)
+        content_after = Path(tmp_path).read_text()
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+    if content_after == content_before:
+        console.print("No changes made.", style="yellow")
+        return
+
+    # Validate new content
+    try:
+        import tomllib as tl
+        task = TaskConfig(**tl.loads(content_after))
+    except Exception as e:
+        console.print(f"Invalid config: {e}", style="red")
+        console.print("Changes discarded.", style="yellow")
+        raise typer.Exit(1)
+
+    # Save and regenerate
+    was_loaded = is_loaded(name)
+    if was_loaded:
+        unload_plist(name)
+
+    task_file.write_text(content_after)
+    write_plist(task)
+
+    if was_loaded:
+        load_plist(task.name)
+
+    console.print(f"Updated task '{name}'.", style="green")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

trigr-0.1.0/src/trigr/config.py

@@ -0,0 +1,89 @@
+import os
+import shutil
+import sqlite3
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "trigr"
+TASKS_DIR = CONFIG_DIR / "tasks"
+LOGS_DIR = CONFIG_DIR / "logs"
+LOCKS_DIR = CONFIG_DIR / "locks"
+DB_PATH = CONFIG_DIR / "history.db"
+ENV_FILE = CONFIG_DIR / "env"
+PLIST_DIR = Path.home() / "Library" / "LaunchAgents"
+PLIST_PREFIX = "com.trigr"
+
+ENV_KEYS = ["PATH", "HOME", "SHELL", "USER", "LANG"]
+
+
+def init() -> None:
+    """Create dirs, capture env, init SQLite."""
+    for d in [CONFIG_DIR, TASKS_DIR, LOGS_DIR, LOCKS_DIR]:
+        d.mkdir(parents=True, exist_ok=True)
+    PLIST_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Capture environment
+    lines: list[str] = []
+    for key in ENV_KEYS:
+        val = os.environ.get(key, "")
+        if val:
+            lines.append(f"{key}={val}")
+    trigr_path = shutil.which("trigr")
+    if trigr_path:
+        lines.append(f"TRIGR_PATH={trigr_path}")
+    ENV_FILE.write_text("\n".join(lines) + "\n")
+
+    # Init SQLite
+    _init_db()
+
+
+def _init_db() -> None:
+    con = sqlite3.connect(DB_PATH)
+    con.executescript("""
+        CREATE TABLE IF NOT EXISTS runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            task_name TEXT NOT NULL,
+            started_at TEXT NOT NULL,
+            finished_at TEXT,
+            exit_code INTEGER,
+            stdout TEXT,
+            stderr TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_runs_task ON runs(task_name);
+
+        CREATE TABLE IF NOT EXISTS state (
+            task_name TEXT PRIMARY KEY,
+            last_value TEXT,
+            updated_at TEXT
+        );
+    """)
+    con.close()
+
+
+def ensure_init() -> None:
+    """Auto-init if config dir doesn't exist."""
+    if not CONFIG_DIR.exists():
+        init()
+    elif not DB_PATH.exists():
+        _init_db()
+
+
+def load_env() -> dict[str, str]:
+    """Load captured environment from env file."""
+    env: dict[str, str] = {}
+    if ENV_FILE.exists():
+        for line in ENV_FILE.read_text().splitlines():
+            if "=" in line:
+                key, _, val = line.partition("=")
+                env[key] = val
+    return env
+
+
+def get_trigr_path() -> str:
+    """Get the absolute path to the trigr binary."""
+    env = load_env()
+    if "TRIGR_PATH" in env:
+        return env["TRIGR_PATH"]
+    path = shutil.which("trigr")
+    if path:
+        return path
+    return "trigr"

trigr-0.1.0/src/trigr/models.py

@@ -0,0 +1,71 @@
+from enum import Enum
+
+from pydantic import BaseModel, model_validator
+
+
+class TriggerType(str, Enum):
+    cron = "cron"
+    interval = "interval"
+    watch = "watch"
+
+
+class CronSchedule(BaseModel):
+    minute: int | None = None
+    hour: int | None = None
+    day: int | None = None  # day of month
+    weekday: int | None = None  # 0=Sunday
+    month: int | None = None
+
+
+class TriggerConfig(BaseModel):
+    type: TriggerType
+    cron: CronSchedule | None = None
+    interval_seconds: int | None = None
+    watch_paths: list[str] | None = None
+
+    @model_validator(mode="after")
+    def validate_trigger(self) -> "TriggerConfig":
+        match self.type:
+            case TriggerType.cron:
+                if self.cron is None:
+                    raise ValueError("cron trigger requires [trigger.cron] section")
+            case TriggerType.interval:
+                if self.interval_seconds is None:
+                    raise ValueError("interval trigger requires interval_seconds")
+            case TriggerType.watch:
+                if not self.watch_paths:
+                    raise ValueError("watch trigger requires watch_paths")
+        return self
+
+
+class ActionConfig(BaseModel):
+    type: str  # "script" or "claude"
+    command: str | None = None
+    prompt: str | None = None
+    working_dir: str | None = None
+    timeout: int = 300
+
+    @model_validator(mode="after")
+    def validate_action(self) -> "ActionConfig":
+        if self.type == "script" and not self.command:
+            raise ValueError("script action requires command")
+        if self.type == "claude" and not self.prompt:
+            raise ValueError("claude action requires prompt")
+        if self.type not in ("script", "claude"):
+            raise ValueError(f"unknown action type: {self.type}")
+        return self
+
+
+class NotifyConfig(BaseModel):
+    on_success: bool = False
+    on_failure: bool = True
+    title: str | None = None
+
+
+class TaskConfig(BaseModel):
+    name: str
+    description: str = ""
+    trigger: TriggerConfig
+    action: ActionConfig
+    notify: NotifyConfig = NotifyConfig()
+    enabled: bool = True

trigr-0.1.0/src/trigr/notify.py

@@ -0,0 +1,14 @@
+import subprocess
+
+
+def send_notification(title: str, body: str) -> None:
+    """Send a macOS notification via osascript."""
+    # Escape double quotes for AppleScript
+    title = title.replace('"', '\\"')
+    body = body.replace('"', '\\"')
+    script = f'display notification "{body}" with title "{title}"'
+    subprocess.run(
+        ["osascript", "-e", script],
+        capture_output=True,
+        timeout=10,
+    )

trigr-0.1.0/src/trigr/plist.py

@@ -0,0 +1,111 @@
+import plistlib
+import subprocess
+from pathlib import Path
+
+from trigr.config import LOGS_DIR, PLIST_DIR, PLIST_PREFIX, get_trigr_path, load_env
+from trigr.models import TaskConfig, TriggerType
+
+
+def plist_label(name: str) -> str:
+    return f"{PLIST_PREFIX}.{name}"
+
+
+def plist_path(name: str) -> Path:
+    return PLIST_DIR / f"{plist_label(name)}.plist"
+
+
+def generate_plist(task: TaskConfig) -> dict:
+    """Generate a launchd plist dict from a TaskConfig."""
+    trigr_path = get_trigr_path()
+    env = load_env()
+    # Remove TRIGR_PATH from env vars passed to plist
+    env.pop("TRIGR_PATH", None)
+
+    plist: dict = {
+        "Label": plist_label(task.name),
+        "ProgramArguments": [trigr_path, "run", task.name],
+        "EnvironmentVariables": env,
+        "StandardOutPath": str(LOGS_DIR / f"{task.name}.out.log"),
+        "StandardErrorPath": str(LOGS_DIR / f"{task.name}.err.log"),
+        "RunAtLoad": False,
+    }
+
+    match task.trigger.type:
+        case TriggerType.cron:
+            cal: dict = {}
+            cron = task.trigger.cron
+            assert cron is not None
+            if cron.minute is not None:
+                cal["Minute"] = cron.minute
+            if cron.hour is not None:
+                cal["Hour"] = cron.hour
+            if cron.day is not None:
+                cal["Day"] = cron.day
+            if cron.weekday is not None:
+                cal["Weekday"] = cron.weekday
+            if cron.month is not None:
+                cal["Month"] = cron.month
+            plist["StartCalendarInterval"] = cal
+
+        case TriggerType.interval:
+            assert task.trigger.interval_seconds is not None
+            plist["StartInterval"] = task.trigger.interval_seconds
+
+        case TriggerType.watch:
+            assert task.trigger.watch_paths is not None
+            plist["WatchPaths"] = [str(Path(p).expanduser().resolve()) for p in task.trigger.watch_paths]
+
+    return plist
+
+
+def write_plist(task: TaskConfig) -> Path:
+    """Generate and write plist file. Returns the plist path."""
+    plist = generate_plist(task)
+    path = plist_path(task.name)
+    with open(path, "wb") as f:
+        plistlib.dump(plist, f)
+    return path
+
+
+def remove_plist(name: str) -> None:
+    """Remove plist file if it exists."""
+    path = plist_path(name)
+    if path.exists():
+        path.unlink()
+
+
+def load_plist(name: str) -> bool:
+    """Load (enable) a plist into launchd. Returns True on success."""
+    path = plist_path(name)
+    if not path.exists():
+        return False
+    result = subprocess.run(
+        ["launchctl", "load", str(path)],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def unload_plist(name: str) -> bool:
+    """Unload (disable) a plist from launchd. Returns True on success."""
+    path = plist_path(name)
+    if not path.exists():
+        return False
+    result = subprocess.run(
+        ["launchctl", "unload", str(path)],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def is_loaded(name: str) -> bool:
+    """Check if a task is currently loaded in launchd."""
+    label = plist_label(name)
+    result = subprocess.run(
+        ["launchctl", "list", label],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0