newcode 0.1.1__py3-none-any.whl

code_puppy/scheduler/__init__.py

@@ -0,0 +1,41 @@
+"""Scheduler - Run scheduled prompts automatically.
+
+This module provides a cross-platform scheduler daemon that executes
+prompts on configurable schedules (intervals, cron expressions).
+
+Components:
+    - config: Task definitions and JSON persistence
+    - daemon: Background scheduler process
+    - executor: Task execution logic
+    - platform: Cross-platform daemon management
+"""
+
+from code_puppy.scheduler.config import (
+    SCHEDULER_LOG_DIR,
+    SCHEDULER_PID_FILE,
+    SCHEDULES_FILE,
+    ScheduledTask,
+    add_task,
+    delete_task,
+    get_task,
+    load_tasks,
+    save_tasks,
+    toggle_task,
+    update_task,
+)
+from code_puppy.scheduler.daemon import start_daemon_background
+
+__all__ = [
+    "ScheduledTask",
+    "load_tasks",
+    "save_tasks",
+    "add_task",
+    "update_task",
+    "delete_task",
+    "get_task",
+    "toggle_task",
+    "start_daemon_background",
+    "SCHEDULES_FILE",
+    "SCHEDULER_PID_FILE",
+    "SCHEDULER_LOG_DIR",
+]

code_puppy/scheduler/__main__.py

@@ -0,0 +1,9 @@
+"""Entry point for running scheduler daemon directly.
+
+Usage: python -m code_puppy.scheduler
+"""
+
+from code_puppy.scheduler.daemon import start_daemon
+
+if __name__ == "__main__":
+    start_daemon(foreground=True)

code_puppy/scheduler/cli.py

@@ -0,0 +1,118 @@
+"""CLI subcommands for the scheduler.
+
+Handles command-line operations like starting/stopping the daemon,
+listing tasks, and running tasks immediately.
+"""
+
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
+
+
+def handle_scheduler_start() -> bool:
+    """Start the scheduler daemon in background."""
+    from code_puppy.scheduler.daemon import get_daemon_pid, start_daemon_background
+
+    pid = get_daemon_pid()
+    if pid:
+        emit_warning(f"Scheduler daemon already running (PID {pid})")
+        return True
+
+    emit_info("Starting scheduler daemon...")
+
+    if start_daemon_background():
+        pid = get_daemon_pid()
+        emit_success(f"Scheduler daemon started (PID {pid})")
+        return True
+    else:
+        emit_error("Failed to start scheduler daemon")
+        return False
+
+
+def handle_scheduler_stop() -> bool:
+    """Stop the scheduler daemon."""
+    from code_puppy.scheduler.daemon import get_daemon_pid, stop_daemon
+
+    pid = get_daemon_pid()
+    if not pid:
+        emit_info("Scheduler daemon is not running")
+        return True
+
+    emit_info(f"Stopping scheduler daemon (PID {pid})...")
+
+    if stop_daemon():
+        emit_success("Scheduler daemon stopped")
+        return True
+    else:
+        emit_error("Failed to stop scheduler daemon")
+        return False
+
+
+def handle_scheduler_status() -> bool:
+    """Show scheduler daemon status."""
+    from code_puppy.scheduler.config import load_tasks
+    from code_puppy.scheduler.daemon import get_daemon_pid
+
+    pid = get_daemon_pid()
+    if pid:
+        emit_success(f"Scheduler daemon: RUNNING (PID {pid})")
+    else:
+        emit_warning("Scheduler daemon: STOPPED")
+
+    tasks = load_tasks()
+    enabled_count = sum(1 for t in tasks if t.enabled)
+
+    emit_info(f"\n📅 Scheduled tasks: {len(tasks)} total, {enabled_count} enabled")
+
+    if tasks:
+        emit_info("\nTasks:")
+        for task in tasks:
+            status_icon = "🟢" if task.enabled else "🔴"
+            last_run = task.last_run[:19] if task.last_run else "never"
+            emit_info(
+                f"  {status_icon} {task.name} ({task.schedule_type}: {task.schedule_value})"
+            )
+            emit_info(
+                f"      Last run: {last_run}, Status: {task.last_status or 'pending'}"
+            )
+
+    return True
+
+
+def handle_scheduler_list() -> bool:
+    """List all scheduled tasks."""
+    from code_puppy.scheduler.config import load_tasks
+
+    tasks = load_tasks()
+
+    if not tasks:
+        emit_info("No scheduled tasks configured.")
+        emit_info("Use '/scheduler' to create one.")
+        return True
+
+    emit_info(f"📅 Scheduled Tasks ({len(tasks)}):\n")
+
+    for task in tasks:
+        status = "🟢 enabled" if task.enabled else "🔴 disabled"
+        emit_info(f"  [{task.id}] {task.name}")
+        emit_info(f"      Status: {status}")
+        emit_info(f"      Schedule: {task.schedule_type} ({task.schedule_value})")
+        emit_info(f"      Agent: {task.agent}, Model: {task.model or 'default'}")
+        if task.last_run:
+            emit_info(f"      Last run: {task.last_run[:19]} ({task.last_status})")
+        emit_info("")
+
+    return True
+
+
+def handle_scheduler_run(task_id: str) -> bool:
+    """Run a specific task immediately."""
+    from code_puppy.scheduler.executor import run_task_by_id
+
+    emit_info(f"Running task {task_id}...")
+    success, message = run_task_by_id(task_id)
+
+    if success:
+        emit_success(message)
+    else:
+        emit_error(message)
+
+    return success

code_puppy/scheduler/config.py

@@ -0,0 +1,126 @@
+"""Scheduler configuration and task management.
+
+Handles ScheduledTask dataclass definition and JSON persistence
+for scheduled tasks.
+"""
+
+import json
+import os
+import uuid
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+# Import from existing config
+from code_puppy.config import DATA_DIR
+
+SCHEDULES_FILE = os.path.join(DATA_DIR, "scheduled_tasks.json")
+SCHEDULER_PID_FILE = os.path.join(DATA_DIR, "scheduler.pid")
+SCHEDULER_LOG_DIR = os.path.join(DATA_DIR, "scheduler_logs")
+
+
+@dataclass
+class ScheduledTask:
+    """A scheduled task."""
+
+    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
+    name: str = ""
+    prompt: str = ""
+    agent: str = "code-puppy"
+    model: str = ""  # Uses default if empty
+    schedule_type: str = "interval"  # "interval", "cron", "daily", "hourly"
+    schedule_value: str = "1h"  # e.g., "30m", "1h", "0 9 * * *" for cron
+    working_directory: str = "."
+    log_file: str = ""  # Auto-generated if empty
+    enabled: bool = True
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    last_run: Optional[str] = None
+    last_status: Optional[str] = None  # "success", "failed", "running"
+    last_exit_code: Optional[int] = None
+
+    def __post_init__(self):
+        if not self.log_file:
+            self.log_file = os.path.join(SCHEDULER_LOG_DIR, f"{self.id}.log")
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ScheduledTask":
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+def ensure_scheduler_dirs() -> None:
+    """Create scheduler directories if they don't exist."""
+    os.makedirs(SCHEDULER_LOG_DIR, mode=0o700, exist_ok=True)
+
+
+def load_tasks() -> List[ScheduledTask]:
+    """Load all scheduled tasks from JSON file."""
+    ensure_scheduler_dirs()
+    if not os.path.exists(SCHEDULES_FILE):
+        return []
+    try:
+        with open(SCHEDULES_FILE, "r") as f:
+            data = json.load(f)
+            return [ScheduledTask.from_dict(t) for t in data]
+    except (json.JSONDecodeError, IOError):
+        return []
+
+
+def save_tasks(tasks: List[ScheduledTask]) -> None:
+    """Save all scheduled tasks to JSON file."""
+    ensure_scheduler_dirs()
+    temp_path = Path(SCHEDULES_FILE).with_suffix(".tmp")
+    with open(temp_path, "w", encoding="utf-8") as f:
+        json.dump([t.to_dict() for t in tasks], f, indent=2, ensure_ascii=False)
+    temp_path.replace(SCHEDULES_FILE)
+
+
+def add_task(task: ScheduledTask) -> None:
+    """Add a new scheduled task."""
+    tasks = load_tasks()
+    tasks.append(task)
+    save_tasks(tasks)
+
+
+def update_task(task: ScheduledTask) -> bool:
+    """Update an existing task. Returns True if found and updated."""
+    tasks = load_tasks()
+    for i, t in enumerate(tasks):
+        if t.id == task.id:
+            tasks[i] = task
+            save_tasks(tasks)
+            return True
+    return False
+
+
+def delete_task(task_id: str) -> bool:
+    """Delete a task by ID. Returns True if found and deleted."""
+    tasks = load_tasks()
+    original_len = len(tasks)
+    tasks = [t for t in tasks if t.id != task_id]
+    if len(tasks) < original_len:
+        save_tasks(tasks)
+        return True
+    return False
+
+
+def get_task(task_id: str) -> Optional[ScheduledTask]:
+    """Get a task by ID."""
+    tasks = load_tasks()
+    for t in tasks:
+        if t.id == task_id:
+            return t
+    return None
+
+
+def toggle_task(task_id: str) -> Optional[bool]:
+    """Toggle a task's enabled state. Returns new state or None if not found."""
+    task = get_task(task_id)
+    if task:
+        task.enabled = not task.enabled
+        update_task(task)
+        return task.enabled
+    return None

code_puppy/scheduler/daemon.py

@@ -0,0 +1,280 @@
+"""Scheduler daemon.
+
+Runs as a background process, checking for and executing scheduled tasks.
+Uses pure Python timing (no external scheduler dependencies).
+"""
+
+import atexit
+import os
+import re
+import signal
+import sys
+import tempfile
+import time
+from datetime import datetime, timedelta
+from typing import Optional
+
+from code_puppy.scheduler.config import (
+    SCHEDULER_PID_FILE,
+    ScheduledTask,
+    load_tasks,
+)
+from code_puppy.scheduler.executor import execute_task
+
+# Global flag for graceful shutdown
+_shutdown_requested = False
+
+
+def parse_interval(interval_str: str) -> Optional[timedelta]:
+    """Parse interval string like '30m', '1h', '2d' into timedelta."""
+    match = re.match(r"^(\d+)([smhd])$", interval_str.lower())
+    if not match:
+        return None
+
+    value = int(match.group(1))
+    unit = match.group(2)
+
+    if unit == "s":
+        return timedelta(seconds=value)
+    elif unit == "m":
+        return timedelta(minutes=value)
+    elif unit == "h":
+        return timedelta(hours=value)
+    elif unit == "d":
+        return timedelta(days=value)
+    return None
+
+
+def should_run_task(task: ScheduledTask, now: datetime) -> bool:
+    """Determine if a task should run now based on its schedule."""
+    if not task.enabled:
+        return False
+
+    if task.schedule_type == "interval":
+        interval = parse_interval(task.schedule_value)
+        if not interval:
+            return False
+
+        if not task.last_run:
+            return True  # Never run before
+
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= interval
+
+    elif task.schedule_type == "hourly":
+        if not task.last_run:
+            return True
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= timedelta(hours=1)
+
+    elif task.schedule_type == "daily":
+        if not task.last_run:
+            return True
+        last_run = datetime.fromisoformat(task.last_run)
+        return (now - last_run) >= timedelta(days=1)
+
+    elif task.schedule_type == "cron":
+        # Cron expressions not yet supported - would need croniter library
+        # Log warning so users know why task isn't running
+        print(
+            f"[Scheduler] Warning: Cron schedules not yet supported, skipping: {task.name}"
+        )
+        return False
+
+    return False
+
+
+def run_scheduler_loop(check_interval: int = 60):
+    """Main scheduler loop. Checks tasks every `check_interval` seconds."""
+    global _shutdown_requested
+
+    print(f"[Scheduler] Starting daemon (PID: {os.getpid()})")
+    print(f"[Scheduler] Check interval: {check_interval}s")
+
+    while not _shutdown_requested:
+        try:
+            tasks = load_tasks()
+            now = datetime.now()
+
+            for task in tasks:
+                if _shutdown_requested:
+                    break
+
+                if should_run_task(task, now):
+                    print(f"[Scheduler] Running task: {task.name} ({task.id})")
+                    success, exit_code, error = execute_task(task)
+                    if success:
+                        print(f"[Scheduler] Task completed: {task.name}")
+                    else:
+                        print(f"[Scheduler] Task failed: {task.name} - {error}")
+
+            # Sleep in small increments to allow graceful shutdown
+            for _ in range(check_interval):
+                if _shutdown_requested:
+                    break
+                time.sleep(1)
+
+        except Exception as e:
+            print(f"[Scheduler] Error in loop: {e}")
+            time.sleep(10)  # Wait before retrying
+
+    print("[Scheduler] Daemon stopped")
+
+
+def write_pid_file():
+    """Write the current PID to the PID file atomically.
+
+    Writes to a temp file first, then atomically replaces the PID file.
+    This prevents corruption if a crash occurs mid-write.
+    """
+    pid_dir = os.path.dirname(SCHEDULER_PID_FILE)
+    os.makedirs(pid_dir, exist_ok=True)
+    fd, tmp_path = tempfile.mkstemp(dir=pid_dir, prefix=".pid_tmp_")
+    try:
+        with os.fdopen(fd, "w") as f:
+            f.write(str(os.getpid()))
+        os.replace(tmp_path, SCHEDULER_PID_FILE)
+    except BaseException:
+        try:
+            os.remove(tmp_path)
+        except OSError:
+            pass
+        raise
+
+
+def remove_pid_file():
+    """Remove the PID file."""
+    try:
+        if os.path.exists(SCHEDULER_PID_FILE):
+            os.remove(SCHEDULER_PID_FILE)
+    except OSError:
+        pass
+
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals."""
+    global _shutdown_requested
+    print(f"\n[Scheduler] Received signal {signum}, shutting down...")
+    _shutdown_requested = True
+
+
+def start_daemon(foreground: bool = False):
+    """Start the scheduler daemon.
+
+    Args:
+        foreground: If True, run in foreground. If False, daemonize.
+    """
+    global _shutdown_requested
+    _shutdown_requested = False
+
+    # Set up signal handlers
+    signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGINT, signal_handler)
+
+    # Write PID file and register cleanup
+    write_pid_file()
+    atexit.register(remove_pid_file)
+
+    # Run the scheduler loop
+    run_scheduler_loop()
+
+
+def get_daemon_pid() -> Optional[int]:
+    """Get the PID of the running daemon, or None if not running."""
+    if not os.path.exists(SCHEDULER_PID_FILE):
+        return None
+
+    try:
+        with open(SCHEDULER_PID_FILE, "r") as f:
+            content = f.read().strip()
+        if not content:
+            remove_pid_file()
+            return None
+        pid = int(content)
+
+        # Check if process is actually running
+        if sys.platform == "win32":
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            handle = kernel32.OpenProcess(
+                0x1000, False, pid
+            )  # PROCESS_QUERY_LIMITED_INFORMATION
+            if handle:
+                kernel32.CloseHandle(handle)
+                return pid
+            return None
+        else:
+            os.kill(pid, 0)  # Doesn't kill, just checks if process exists
+            return pid
+    except (ValueError, ProcessLookupError, PermissionError, OSError):
+        # PID file exists but process is not running - stale PID file
+        remove_pid_file()
+        return None
+
+
+def start_daemon_background() -> bool:
+    """Start the scheduler daemon in the background.
+
+    Returns:
+        True if daemon started successfully, False otherwise.
+    """
+    import subprocess
+    import time
+
+    # NOTE: There is an inherent TOCTOU race between checking if the daemon
+    # is running and starting a new one. Full mitigation would require file
+    # locking (e.g., fcntl.flock). We mitigate by re-checking after start.
+    pid = get_daemon_pid()
+    if pid:
+        return True  # Already running
+
+    cmd = [sys.executable, "-m", "code_puppy.scheduler"]
+
+    if sys.platform == "win32":
+        subprocess.Popen(
+            cmd,
+            creationflags=subprocess.CREATE_NO_WINDOW,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    else:
+        subprocess.Popen(
+            cmd,
+            start_new_session=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    time.sleep(1)
+    # Re-check to confirm daemon actually started (also catches race where
+    # another process started the daemon between our check and Popen).
+    return get_daemon_pid() is not None
+
+
+def stop_daemon() -> bool:
+    """Stop the running daemon. Returns True if stopped successfully."""
+    pid = get_daemon_pid()
+    if not pid:
+        return False
+
+    try:
+        if sys.platform == "win32":
+            import ctypes
+
+            kernel32 = ctypes.windll.kernel32
+            handle = kernel32.OpenProcess(1, False, pid)  # PROCESS_TERMINATE
+            kernel32.TerminateProcess(handle, 0)
+            kernel32.CloseHandle(handle)
+        else:
+            os.kill(pid, signal.SIGTERM)
+
+        # Wait for process to stop
+        for _ in range(10):
+            time.sleep(0.5)
+            if not get_daemon_pid():
+                return True
+
+        return False
+    except Exception:
+        return False