bone-agent 1.3.0

package/src/core/cron.py

@@ -0,0 +1,527 @@
+"""Cron scheduler for bone-agent.
+
+Provides natural-language scheduled job execution integrated into the
+bone-agent agentic loop. Jobs are defined in ~/.bone/cron/jobs.yaml and
+run as background threads while bone-agent is active.
+
+External trigger: bone-agent --cron-run <job-id>
+"""
+
+import logging
+import re
+import threading
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+# ── Paths ────────────────────────────────────────────────────────────────
+
+def _get_cron_dir() -> Path:
+    """Return ~/.bone/cron/ directory, creating it if needed."""
+    cron_dir = Path.home() / ".bone" / "cron"
+    cron_dir.mkdir(parents=True, exist_ok=True)
+    return cron_dir
+
+
+def _get_jobs_path() -> Path:
+    return _get_cron_dir() / "jobs.yaml"
+
+
+def _get_log_dir() -> Path:
+    log_dir = _get_cron_dir() / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+# ── Data model ───────────────────────────────────────────────────────────
+
+@dataclass
+class CronJob:
+    """A single cron job definition."""
+    id: str
+    schedule: str           # Natural language: "every 5 minutes", "weekdays at 8am"
+    command: str            # The prompt to feed into the agentic loop
+    enabled: bool = True
+    description: str = ""
+    last_run: Optional[str] = None    # ISO timestamp of last successful run
+    last_status: Optional[str] = None  # "ok" | "error"
+    created: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "CronJob":
+        return cls(**{k: v for k, v in d.items() if k in cls.__dataclass_fields__})
+
+
+# ── Schedule parser ──────────────────────────────────────────────────────
+
+# Patterns we support (ordered by specificity):
+#   "every N minutes|hours|days"
+#   "daily at HH:MM"
+#   "weekdays at HH:MM"
+#   "mondays|tuesdays|... at HH:MM"
+#   "HH:MM" (daily shorthand)
+
+def _extract_time(m: re.Match) -> dict:
+    """Extract hour/minute from a regex match with hour, minute, ampm groups."""
+    hour = int(m.group("hour"))
+    minute = int(m.group("minute") or 0)
+    ampm = (m.group("ampm") or "").lower()
+    if ampm == "am" and hour == 12:
+        hour = 0
+    elif ampm == "pm" and hour != 12:
+        hour += 12
+    return {"hour": hour, "minute": minute}
+
+
+_SCHEDULE_PATTERNS = [
+    # every N <unit>
+    (re.compile(
+        r"^every\s+(?P<n>\d+)\s*(?P<unit>minute|minutes|min|m|hour|hours|hr|h|day|days|d)s?\s*$",
+        re.IGNORECASE
+    ), "interval"),
+    # every day/night/morning/afternoon/evening [at] <time>
+    (re.compile(
+        r"^every\s+(?:day|night|morning|afternoon|evening)s?\s+(?:at\s+)?(?P<hour>\d{1,2})(?::(?P<minute>\d{2}))?\s*(?P<ampm>[ap]m)?\s*$",
+        re.IGNORECASE
+    ), "daily"),
+    # weekdays at <time>
+    (re.compile(
+        r"^weekdays?\s+at\s+(?P<hour>\d{1,2})(?::(?P<minute>\d{2}))?\s*(?P<ampm>[ap]m)?\s*$",
+        re.IGNORECASE
+    ), "weekdays"),
+    # specific day at <time>
+    (re.compile(
+        r"^(?P<day>monday|tuesday|wednesday|thursday|friday|saturday|sunday)s?\s+at\s+(?P<hour>\d{1,2})(?::(?P<minute>\d{2}))?\s*(?P<ampm>[ap]m)?\s*$",
+        re.IGNORECASE
+    ), "day_of_week"),
+    # daily at <time>
+    (re.compile(
+        r"^daily\s+at\s+(?P<hour>\d{1,2})(?::(?P<minute>\d{2}))?\s*(?P<ampm>[ap]m)?\s*$",
+        re.IGNORECASE
+    ), "daily"),
+    # bare HH:MM or HHam/pm (treated as daily)
+    (re.compile(
+        r"^(?P<hour>\d{1,2}):(?P<minute>\d{2})\s*(?P<ampm>[ap]m)?\s*$"
+    ), "daily"),
+]
+
+_DAY_MAP = {
+    "monday": 0, "tuesday": 1, "wednesday": 2, "thursday": 3,
+    "friday": 4, "saturday": 5, "sunday": 6,
+}
+
+
+def parse_schedule(schedule: str) -> dict:
+    """Parse a natural-language schedule into a structured spec.
+
+    Returns dict with:
+        type: "interval" | "daily" | "weekdays" | "day_of_week"
+        For interval: interval_seconds (int)
+        For time-based: hour (int), minute (int)
+        For day_of_week: weekday (0=Mon..6=Sun)
+
+    Raises ValueError if schedule can't be parsed.
+    """
+    schedule = schedule.strip()
+    for pattern, sched_type in _SCHEDULE_PATTERNS:
+        m = pattern.match(schedule)
+        if m:
+            if sched_type == "interval":
+                n = int(m.group("n"))
+                if n <= 0:
+                    raise ValueError(
+                        f"Interval must be at least 1: 'every {n} {m.group('unit')}'"
+                    )
+                unit = m.group("unit").lower()
+                if unit in ("minute", "minutes", "min", "m"):
+                    return {"type": "interval", "interval_seconds": n * 60}
+                elif unit in ("hour", "hours", "hr", "h"):
+                    return {"type": "interval", "interval_seconds": n * 3600}
+                elif unit in ("day", "days", "d"):
+                    return {"type": "interval", "interval_seconds": n * 86400}
+            elif sched_type == "weekdays":
+                t = _extract_time(m)
+                return {"type": "weekdays", **t}
+            elif sched_type == "day_of_week":
+                t = _extract_time(m)
+                return {
+                    "type": "day_of_week",
+                    "weekday": _DAY_MAP[m.group("day").lower()],
+                    **t,
+                }
+            elif sched_type == "daily":
+                t = _extract_time(m)
+                return {"type": "daily", **t}
+
+    raise ValueError(
+        f"Cannot parse schedule: '{schedule}'. "
+        f"Examples: 'every 5 minutes', 'every hour', 'daily at 8am', "
+        f"'every day at 5am', 'weekdays at 9:00', 'mondays at 10:30pm'"
+    )
+
+
+def _should_run(spec: dict, last_run: Optional[datetime], now: datetime) -> bool:
+    """Check if a job with the given schedule spec should run now."""
+    if spec["type"] == "interval":
+        interval = spec["interval_seconds"]
+        if last_run is None:
+            return True
+        return (now - last_run).total_seconds() >= interval
+
+    elif spec["type"] in ("daily", "weekdays", "day_of_week"):
+        # Time-based: check if we've passed the target time today
+        # and haven't already run today
+        target_time = now.replace(hour=spec["hour"], minute=spec["minute"], second=0, microsecond=0)
+
+        # Check day-of-week constraints
+        if spec["type"] == "weekdays" and now.weekday() >= 5:
+            return False
+        if spec["type"] == "day_of_week" and now.weekday() != spec["weekday"]:
+            return False
+
+        # Has the target time passed today?
+        if now < target_time:
+            return False
+
+        # Did we already run today (after target time)?
+        if last_run is not None and last_run >= target_time:
+            return False
+
+        return True
+
+    return False
+
+
+# ── Config persistence ───────────────────────────────────────────────────
+
+class CronConfig:
+    """Load/save cron jobs from ~/.bone/cron/jobs.yaml."""
+
+    def __init__(self):
+        self._path = _get_jobs_path()
+        self.jobs: dict[str, CronJob] = {}
+        self.load()
+
+    def load(self):
+        self.jobs.clear()
+        if not self._path.exists():
+            return
+        try:
+            data = yaml.safe_load(self._path.read_text(encoding="utf-8")) or {}
+            for job_dict in data.get("jobs", []):
+                job = CronJob.from_dict(job_dict)
+                self.jobs[job.id] = job
+        except Exception as e:
+            logger.warning("Failed to load cron config: %s", e)
+
+    def save(self):
+        data = {"jobs": [j.to_dict() for j in self.jobs.values()]}
+        self._path.write_text(
+            yaml.dump(data, default_flow_style=False, sort_keys=False, allow_unicode=True),
+            encoding="utf-8",
+        )
+
+    def add_job(self, job: CronJob):
+        self.jobs[job.id] = job
+        self.save()
+
+    def remove_job(self, job_id: str) -> bool:
+        if job_id in self.jobs:
+            del self.jobs[job_id]
+            self.save()
+            return True
+        return False
+
+    def get_job(self, job_id: str) -> Optional[CronJob]:
+        return self.jobs.get(job_id)
+
+    def update_job(self, job_id: str, **kwargs):
+        job = self.jobs.get(job_id)
+        if job:
+            for k, v in kwargs.items():
+                if k in job.__dataclass_fields__:
+                    setattr(job, k, v)
+            self.save()
+
+
+# ── Scheduler ────────────────────────────────────────────────────────────
+
+def _write_job_log(job: CronJob, output: str, error: bool):
+    """Append job output to a log file."""
+    log_dir = _get_log_dir()
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_file = log_dir / f"{job.id}_{timestamp}.log"
+    try:
+        log_file.write_text(
+            f"Job: {job.id}\n"
+            f"Schedule: {job.schedule}\n"
+            f"Ran at: {datetime.now().isoformat()}\n"
+            f"Status: {'ERROR' if error else 'OK'}\n"
+            f"{'─' * 40}\n"
+            f"{output}\n",
+            encoding="utf-8",
+        )
+    except Exception as e:
+        logger.error("Failed to write cron log: %s", e)
+
+
+def run_single_job(job: CronJob, console=None, interactive=False) -> None:
+    """Execute a single cron job without requiring a CronScheduler instance.
+
+    Used by the /cron run subcommand (interactive=True) and run_job_headless
+    (interactive=False, default).
+
+    Args:
+        job: The CronJob to execute.
+        console: Optional Rich console for interactive output.
+        interactive: If True, use the real console for interactive command
+            approval (test-run mode). Commands are auto-saved to the allow list.
+            If False, use a buffer console (scheduled mode). Unlisted commands
+            are blocked.
+    """
+    from rich.console import Console as RichConsole
+    from io import StringIO
+    from core.cron_allowlist import CronAllowlist
+
+    # Capture output for logging
+    output_buf = StringIO()
+
+    if interactive and console is not None:
+        # Interactive test run: use the real console so user can approve commands
+        job_console = console
+    else:
+        # Scheduled run: use a buffer console (no interactive prompts)
+        job_console = RichConsole(
+            file=output_buf,
+            force_terminal=True,
+            width=80,
+        )
+
+    try:
+        from core.chat_manager import ChatManager
+        from core.agentic import AgenticOrchestrator
+        from utils.paths import RG_EXE_PATH
+        from tools.loader import load_all_tools
+        from llm.config import TOOLS_ENABLED
+
+        if not TOOLS_ENABLED:
+            raise RuntimeError("Cron requires tools to be enabled")
+
+        # Ensure tools are loaded
+        load_all_tools()
+
+        # Fresh ChatManager for this job
+        chat_manager = ChatManager()
+
+        # Build the prompt — inject context about cron execution
+        prompt = (
+            f"[Cron job: {job.id}]\n"
+            f"{job.command}"
+        )
+
+        repo_root = Path.cwd().resolve()
+
+        # Set up cron allow list for command gating
+        allowlist = CronAllowlist()
+
+        orchestrator = AgenticOrchestrator(
+            chat_manager=chat_manager,
+            repo_root=repo_root,
+            rg_exe_path=RG_EXE_PATH,
+            console=job_console,
+            debug_mode=False,
+            suppress_result_display=False,
+            cron_job_id=job.id,
+            cron_allowlist=allowlist,
+            cron_interactive=interactive,
+        )
+        orchestrator.run(prompt)
+
+        # Log output
+        _write_job_log(job, output_buf.getvalue(), error=False)
+
+    except Exception as e:
+        _write_job_log(job, str(e), error=True)
+        raise
+
+
+class CronScheduler:
+    """Background scheduler that runs cron jobs via the agentic loop.
+
+    Starts a daemon thread that wakes every 30 seconds to check if any
+    jobs are due. When a job fires, it creates a fresh ChatManager
+    (to avoid polluting the user's conversation) and runs the job's
+    command through the agentic orchestrator.
+    """
+
+    CHECK_INTERVAL = 30  # seconds between schedule checks
+
+    def __init__(self, console=None):
+        self.config = CronConfig()
+        self.console = console
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._lock = threading.Lock()
+        self._running = False
+
+    def start(self):
+        """Start the cron scheduler background thread."""
+        enabled_jobs = [j for j in self.config.jobs.values() if j.enabled]
+
+        # Validate all schedules on startup
+        for job in enabled_jobs:
+            try:
+                parse_schedule(job.schedule)
+            except ValueError as e:
+                logger.warning("Cron job '%s' has invalid schedule: %s", job.id, e)
+
+        self._stop_event.clear()
+        self._thread = None
+        try:
+            self._running = True
+            self._thread = threading.Thread(
+                target=self._run_loop,
+                name="cron-scheduler",
+                daemon=True,
+            )
+            self._thread.start()
+        except Exception:
+            self._running = False
+            self._thread = None
+            raise
+        logger.info("Cron scheduler started with %d job(s)", len(enabled_jobs))
+
+    def stop(self):
+        """Signal the scheduler thread to stop and wait for it."""
+        self._stop_event.set()
+        self._running = False
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=10)
+        logger.info("Cron scheduler stopped")
+
+    def reload(self):
+        """Reload config from disk (e.g. after /cron add/remove)."""
+        with self._lock:
+            self.config.load()
+
+    def execute_job(self, job: CronJob):
+        """Execute a single cron job. Public wrapper around run_single_job."""
+        run_single_job(job, console=self.console)
+
+    def _run_loop(self):
+        """Main scheduler loop — runs in background thread."""
+        # Track last run times from persisted state
+        last_runs: dict[str, datetime] = {}
+        for job in self.config.jobs.values():
+            if job.last_run:
+                try:
+                    last_runs[job.id] = datetime.fromisoformat(job.last_run)
+                except (ValueError, TypeError):
+                    pass
+
+        while not self._stop_event.is_set():
+            now = datetime.now()
+
+            # Collect due jobs under lock, then execute outside
+            due_jobs: list[CronJob] = []
+            with self._lock:
+                for job in list(self.config.jobs.values()):
+                    if not job.enabled:
+                        continue
+                    try:
+                        spec = parse_schedule(job.schedule)
+                    except ValueError:
+                        continue
+
+                    last_run = last_runs.get(job.id)
+                    if _should_run(spec, last_run, now):
+                        due_jobs.append(job)
+
+            # Execute jobs outside the lock so scheduling isn't blocked
+            for job in due_jobs:
+                logger.info("Cron firing job '%s'", job.id)
+                try:
+                    self.execute_job(job)
+                    job.last_run = now.isoformat()
+                    job.last_status = "ok"
+                    last_runs[job.id] = now
+                except Exception as e:
+                    logger.error("Cron job '%s' failed: %s", job.id, e)
+                    job.last_status = "error"
+                    job.last_run = now.isoformat()
+                    last_runs[job.id] = now
+                finally:
+                    with self._lock:
+                        # Snapshot only the current job's updated state
+                        lr, ls = job.last_run, job.last_status
+
+                        # Reload to pick up any /cron changes made while
+                        # the job was running, so we don't overwrite them
+                        self.config.load()
+
+                        # Merge our last_run/last_status back onto reloaded job
+                        reloaded = self.config.jobs.get(job.id)
+                        if reloaded:
+                            reloaded.last_run = lr
+                            reloaded.last_status = ls
+
+                        self.config.save()
+
+            self._stop_event.wait(self.CHECK_INTERVAL)
+
+            # Reload config from disk so /cron add/remove changes are picked up
+            with self._lock:
+                self.config.load()
+                # Sync in-memory last_runs from reloaded config
+                # (picks up /cron run or --cron-run updates)
+                for job in self.config.jobs.values():
+                    if job.id not in last_runs and job.last_run:
+                        try:
+                            last_runs[job.id] = datetime.fromisoformat(job.last_run)
+                        except (ValueError, TypeError):
+                            pass
+
+
+# ── External runner (for --cron-run) ────────────────────────────────────
+
+def run_job_headless(job_id: str) -> int:
+    """Run a single job headlessly (no interactive session).
+
+    Used by `bone-agent --cron-run <job-id>`.
+
+    Returns 0 on success, 1 on failure.
+    """
+    config = CronConfig()
+    job = config.get_job(job_id)
+    if not job:
+        print(f"Error: cron job '{job_id}' not found")
+        return 1
+
+    print(f"Running cron job: {job.id}")
+    print(f"Schedule: {job.schedule}")
+    print(f"Command: {job.command}")
+    print("─" * 40)
+
+    try:
+        run_single_job(job)
+        job.last_run = datetime.now().isoformat()
+        job.last_status = "ok"
+        config.save()
+        print("─" * 40)
+        print("Job completed successfully.")
+        return 0
+    except Exception as e:
+        job.last_run = datetime.now().isoformat()
+        job.last_status = "error"
+        config.save()
+        print(f"─" * 40)
+        print(f"Job failed: {e}")
+        return 1

package/src/core/cron_allowlist.py

@@ -0,0 +1,118 @@
+"""Per-job command allow list for cron jobs.
+
+Stores approved shell commands per job ID in ~/.bone/cron/allowed_commands.yaml.
+During scheduled runs, only commands on the allow list (plus global SAFE_COMMAND_RULES)
+are auto-approved. Unlisted commands are blocked with agent feedback.
+
+During interactive test runs (/cron run), accepted commands are auto-saved.
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+def _get_allowed_commands_path() -> Path:
+    """Return ~/.bone/cron/allowed_commands.yaml."""
+    cron_dir = Path.home() / ".bone" / "cron"
+    cron_dir.mkdir(parents=True, exist_ok=True)
+    return cron_dir / "allowed_commands.yaml"
+
+
+class CronAllowlist:
+    """Manages per-job shell command allow lists.
+
+    Storage format (YAML):
+        jobs:
+          my_job:
+            commands:
+              - "git add -A"
+              - "git commit -m 'auto commit'"
+              - "git push origin main"
+    """
+
+    def __init__(self):
+        self._path = _get_allowed_commands_path()
+        self._jobs: dict[str, list[str]] = {}
+        self.load()
+
+    def load(self):
+        """Load allow list from disk."""
+        self._jobs.clear()
+        if not self._path.exists():
+            return
+        try:
+            data = yaml.safe_load(self._path.read_text(encoding="utf-8")) or {}
+            for job_id, entry in data.get("jobs", {}).items():
+                self._jobs[job_id] = entry.get("commands", [])
+        except Exception as e:
+            logger.warning("Failed to load cron allow list: %s", e)
+
+    def save(self):
+        """Persist allow list to disk."""
+        data = {
+            "jobs": {
+                job_id: {"commands": cmds}
+                for job_id, cmds in self._jobs.items()
+            }
+        }
+        self._path.write_text(
+            yaml.dump(data, default_flow_style=False, sort_keys=False, allow_unicode=True),
+            encoding="utf-8",
+        )
+
+    def get_commands(self, job_id: str) -> list[str]:
+        """Return the list of allowed commands for a job."""
+        return list(self._jobs.get(job_id, []))
+
+    def add_command(self, job_id: str, command: str) -> bool:
+        """Add a command to a job's allow list. Returns True if newly added."""
+        command = command.strip()
+        if not command:
+            return False
+        if job_id not in self._jobs:
+            self._jobs[job_id] = []
+        if command not in self._jobs[job_id]:
+            self._jobs[job_id].append(command)
+            self.save()
+            return True
+        return False
+
+    def remove_command(self, job_id: str, command: str) -> bool:
+        """Remove a command from a job's allow list. Returns True if removed."""
+        command = command.strip()
+        if job_id in self._jobs and command in self._jobs[job_id]:
+            self._jobs[job_id].remove(command)
+            if not self._jobs[job_id]:
+                del self._jobs[job_id]
+            self.save()
+            return True
+        return False
+
+    def clear_job(self, job_id: str) -> int:
+        """Remove all commands for a job. Returns count of removed commands."""
+        if job_id not in self._jobs:
+            return 0
+        count = len(self._jobs[job_id])
+        del self._jobs[job_id]
+        self.save()
+        return count
+
+    def is_allowed(self, job_id: str, command: str) -> bool:
+        """Check if a command is on the allow list for a job.
+
+        Matching is exact (normalized whitespace). For commands that
+        are prefixes of list entries or vice versa, we don't match --
+        the user should approve the exact command they expect.
+        """
+        command = command.strip()
+        allowed = self._jobs.get(job_id, [])
+        return command in allowed
+
+    def all_jobs(self) -> dict[str, list[str]]:
+        """Return a copy of all job allow lists."""
+        return {jid: list(cmds) for jid, cmds in self._jobs.items()}