yee88 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

yee88/cli/__init__.py

@@ -91,6 +91,8 @@ from .config import (
     config_set,
     config_unset,
 )
+from .cron import app as cron_app
+from .reload import reload_command
 
 
 def _load_settings_optional() -> tuple[TakopiSettings | None, Path | None]:
@@ -212,6 +214,8 @@ def create_app() -> typer.Typer:
     app.command(name="onboarding-paths")(onboarding_paths)
     app.command(name="plugins")(plugins_cmd)
     app.add_typer(config_app, name="config")
+    app.add_typer(cron_app, name="cron")
+    app.command(name="reload")(reload_command)
     app.callback()(app_main)
     for engine_id in _engine_ids_for_cli():
         help_text = f"Run with the {engine_id} engine."

yee88/cli/cron.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import typer
+
+from ..config import HOME_CONFIG_PATH
+from ..cron.manager import CronManager
+from ..cron.models import CronJob
+from ..settings import load_settings_if_exists
+from ..engines import list_backend_ids
+
+app = typer.Typer(help="Manage yee88 cron jobs")
+
+
+def get_cron_manager() -> CronManager:
+    return CronManager(HOME_CONFIG_PATH.parent)
+
+
+def _validate_project(project: str) -> None:
+    if not project:
+        return
+    result = load_settings_if_exists()
+    if result is None:
+        raise ValueError(f"未找到配置文件，无法验证项目: {project}")
+    settings, config_path = result
+    engine_ids = list_backend_ids()
+    projects_config = settings.to_projects_config(config_path=config_path, engine_ids=engine_ids)
+    if project.lower() not in projects_config.projects:
+        available = list(projects_config.projects.keys())
+        if available:
+            raise ValueError(f"未知项目: {project}。可用项目: {', '.join(available)}")
+        else:
+            raise ValueError(f"未知项目: {project}。请先使用 'yee88 init' 注册项目")
+
+
+def _parse_one_time(schedule: str) -> str:
+    """解析一次性任务时间，支持相对时间和 ISO 8601 格式。"""
+    now = datetime.now()
+
+    # 相对时间格式: +30s, +5m, +2h, +1d
+    if schedule.startswith("+"):
+        match = re.match(r"\+(\d+)([smhd])", schedule)
+        if not match:
+            raise ValueError(
+                f"无效的时间格式: {schedule}。使用 +30s, +5m, +2h, +1d 或 ISO 8601 (2026-02-01T10:00:00)"
+            )
+
+        value, unit = int(match.group(1)), match.group(2)
+        delta = {
+            "s": timedelta(seconds=value),
+            "m": timedelta(minutes=value),
+            "h": timedelta(hours=value),
+            "d": timedelta(days=value),
+        }[unit]
+
+        return (now + delta).isoformat()
+
+    # ISO 8601 格式
+    try:
+        dt = datetime.fromisoformat(schedule)
+        if dt <= now:
+            raise ValueError("执行时间必须在未来")
+        return dt.isoformat()
+    except ValueError as e:
+        if "执行时间必须在未来" in str(e):
+            raise
+        raise ValueError(
+            f"无效的时间格式: {schedule}。使用 +30s, +5m, +2h, +1d 或 ISO 8601 (2026-02-01T10:00:00)"
+        )
+
+
+@app.command()
+def add(
+    id: str = typer.Argument(...),
+    schedule: str = typer.Argument(...),
+    message: str = typer.Argument(...),
+    project: str = typer.Option("", "--project", "-p", help="项目别名（可选，如 takopi）"),
+    one_time: bool = typer.Option(False, "--one-time", "-o", help="一次性任务，执行后自动删除"),
+):
+    try:
+        manager = get_cron_manager()
+        manager.load()
+
+        _validate_project(project)
+
+        if one_time:
+            schedule = _parse_one_time(schedule)
+
+        job = CronJob(
+            id=id,
+            schedule=schedule,
+            message=message,
+            project=project,
+            enabled=True,
+            one_time=one_time,
+        )
+
+        manager.add(job)
+
+        if one_time:
+            typer.echo(f"✅ 已添加一次性任务: {id}")
+            typer.echo(f"   执行时间: {schedule[:19]}")
+        else:
+            typer.echo(f"✅ 已添加定时任务: {id}")
+            typer.echo(f"   时间: {schedule}")
+        if project:
+            typer.echo(f"   项目: {project}")
+        typer.echo(f"   消息: {message}")
+
+    except ValueError as e:
+        typer.echo(f"❌ 错误: {e}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def list(
+    show_all: bool = typer.Option(False, "--all", "-a"),
+):
+    manager = get_cron_manager()
+    manager.load()
+
+    jobs = manager.list()
+
+    if not jobs:
+        typer.echo("暂无定时任务")
+        return
+
+    if not show_all:
+        jobs = [j for j in jobs if j.enabled]
+
+    typer.echo(f"{'ID':<20} {'TYPE':<8} {'SCHEDULE':<20} {'STATUS':<10} {'PROJECT'}")
+    typer.echo("-" * 90)
+
+    for job in jobs:
+        status = "✓ enabled" if job.enabled else "✗ disabled"
+        job_type = "once" if job.one_time else "cron"
+        schedule_display = job.schedule[:19] if job.one_time else job.schedule
+        if len(schedule_display) > 20:
+            schedule_display = schedule_display[:17] + "..."
+        project_display = job.project
+        if len(project_display) > 25:
+            project_display = "..." + project_display[-22:]
+        typer.echo(f"{job.id:<20} {job_type:<8} {schedule_display:<20} {status:<10} {project_display}")
+
+
+@app.command()
+def enable(
+    id: str = typer.Argument(...),
+):
+    manager = get_cron_manager()
+    manager.load()
+
+    if manager.enable(id):
+        typer.echo(f"✅ 已启用: {id}")
+    else:
+        typer.echo(f"❌ 未找到任务: {id}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def disable(
+    id: str = typer.Argument(...),
+):
+    manager = get_cron_manager()
+    manager.load()
+
+    if manager.disable(id):
+        typer.echo(f"⏸️  已禁用: {id}")
+    else:
+        typer.echo(f"❌ 未找到任务: {id}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def remove(
+    id: str = typer.Argument(...),
+    force: bool = typer.Option(False, "--force", "-f"),
+):
+    manager = get_cron_manager()
+    manager.load()
+
+    if not force:
+        confirm = typer.confirm(f"确定要删除任务 '{id}' 吗？")
+        if not confirm:
+            typer.echo("已取消")
+            raise typer.Exit(0)
+
+    if manager.remove(id):
+        typer.echo(f"🗑️  已删除: {id}")
+    else:
+        typer.echo(f"❌ 未找到任务: {id}", err=True)
+        raise typer.Exit(1)
+
+
+@app.command()
+def run(
+    id: str = typer.Argument(...),
+):
+    manager = get_cron_manager()
+    manager.load()
+
+    job = manager.get(id)
+    if not job:
+        typer.echo(f"❌ 未找到任务: {id}", err=True)
+        raise typer.Exit(1)
+
+    typer.echo(f"🚀 执行任务: {id}")
+    typer.echo(f"   路径: {job.project}")
+    typer.echo(f"   消息: {job.message}")
+    typer.echo(f"   计划时间: {job.schedule}")
+    typer.echo("✅ 测试执行完成")

yee88/cli/reload.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+
+import typer
+
+from ..config import HOME_CONFIG_PATH, load_or_init_config
+from ..lockfile import _pid_running, _read_lock_info, lock_path_for_config
+from ..logging import get_logger
+
+logger = get_logger(__name__)
+
+_reload_requested = False
+
+
+def _get_exec_args() -> tuple[str, list[str]]:
+    import shutil
+    yee88_path = shutil.which("yee88")
+    if yee88_path:
+        return yee88_path, ["yee88"]
+    executable = sys.executable
+    args = [executable, "-m", "yee88"]
+    return executable, args
+
+
+def request_reload() -> None:
+    global _reload_requested
+    _reload_requested = True
+
+
+def should_reload() -> bool:
+    return _reload_requested
+
+
+def do_exec_restart() -> None:
+    logger.info("reload.exec_restart", pid=os.getpid())
+    sys.stdout.flush()
+    sys.stderr.flush()
+    
+    executable, args = _get_exec_args()
+    os.execv(executable, args)
+
+
+def _handle_sighup(signum: int, frame: object) -> None:
+    logger.info("reload.signal_received", signal="SIGHUP", pid=os.getpid())
+    request_reload()
+
+
+def install_reload_handler() -> None:
+    if hasattr(signal, "SIGHUP"):
+        signal.signal(signal.SIGHUP, _handle_sighup)
+        logger.debug("reload.handler_installed", signal="SIGHUP")
+
+
+def _find_running_instance(config_path: Path | None = None) -> tuple[int, Path] | None:
+    if config_path is None:
+        try:
+            _, config_path = load_or_init_config()
+        except Exception:
+            config_path = HOME_CONFIG_PATH
+    
+    lock_path = lock_path_for_config(config_path)
+    lock_info = _read_lock_info(lock_path)
+    
+    if lock_info is None or lock_info.pid is None:
+        return None
+    
+    if not _pid_running(lock_info.pid):
+        lock_path.unlink(missing_ok=True)
+        return None
+    
+    return lock_info.pid, lock_path
+
+
+def send_reload_signal(config_path: Path | None = None) -> bool:
+    result = _find_running_instance(config_path)
+    
+    if result is None:
+        return False
+    
+    pid, _ = result
+    
+    if pid == os.getpid():
+        return False
+    
+    try:
+        os.kill(pid, signal.SIGHUP)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+def run_reload(
+    config_path: Path | None = None,
+    timeout: float = 10.0,
+) -> None:
+    result = _find_running_instance(config_path)
+    
+    if result is None:
+        typer.echo("No running yee88 instance found.", err=True)
+        raise typer.Exit(code=1)
+    
+    pid, lock_path = result
+    
+    if pid == os.getpid():
+        typer.echo("Cannot reload self. Run from another terminal.", err=True)
+        raise typer.Exit(code=1)
+    
+    typer.echo(f"Sending reload signal to yee88 (PID: {pid})...")
+    
+    try:
+        os.kill(pid, signal.SIGHUP)
+    except ProcessLookupError:
+        typer.echo("Process already exited.", err=True)
+        lock_path.unlink(missing_ok=True)
+        raise typer.Exit(code=1)
+    except PermissionError:
+        typer.echo(f"Permission denied: cannot signal PID {pid}", err=True)
+        raise typer.Exit(code=1)
+    
+    typer.echo("✓ Reload signal sent. Process will restart with new code.")
+
+
+def reload_command(
+    config_path: Path | None = typer.Option(
+        None,
+        "--config-path",
+        help="Path to config file",
+    ),
+    timeout: float = typer.Option(
+        10.0,
+        "--timeout",
+        help="Timeout in seconds",
+    ),
+) -> None:
+    run_reload(config_path=config_path, timeout=timeout)

yee88/cli/run.py

@@ -16,6 +16,7 @@ from ..config import ConfigError, load_or_init_config
 from ..engines import get_backend
 from ..ids import RESERVED_CHAT_COMMANDS
 from ..lockfile import LockError, LockHandle, acquire_lock, token_fingerprint
+from .reload import do_exec_restart, install_reload_handler, should_reload
 from ..logging import get_logger, setup_logging
 from ..runtime_loader import build_runtime_spec, resolve_plugins_allowlist
 from ..settings import TakopiSettings, load_settings, load_settings_if_exists
@@ -299,6 +300,7 @@ def _run_auto_router(
         )
         lock_handle = acquire_config_lock_fn(config_path, lock_token)
         runtime = spec.to_runtime(config_path=config_path)
+        install_reload_handler()
         transport_backend.build_and_run(
             final_notify=final_notify,
             default_engine_override=default_engine_override,
@@ -306,6 +308,11 @@ def _run_auto_router(
             transport_config=transport_config,
             runtime=runtime,
         )
+        if should_reload():
+            if lock_handle is not None:
+                lock_handle.release()
+                lock_handle = None
+            do_exec_restart()
     except ConfigError as exc:
         typer.echo(f"error: {exc}", err=True)
         raise typer.Exit(code=1) from exc

yee88/cron/__init__.py

@@ -0,0 +1,5 @@
+from .models import CronJob
+from .manager import CronManager
+from .scheduler import CronScheduler
+
+__all__ = ["CronJob", "CronManager", "CronScheduler"]

yee88/cron/manager.py

@@ -0,0 +1,140 @@
+import tomllib
+import tomli_w
+from pathlib import Path
+from typing import List, Optional
+from croniter import croniter
+from datetime import datetime
+from .models import CronJob
+
+
+class CronManager:
+    def __init__(self, config_dir: Path):
+        self.file = config_dir / "cron.toml"
+        self.jobs: List[CronJob] = []
+
+    def _validate_project(self, project: str) -> None:
+        if not project:
+            return
+        path = Path(project).expanduser().resolve()
+        if path.exists() and path.is_dir():
+            git_dir = path / ".git"
+            if git_dir.exists():
+                return
+            raise ValueError(f"不是 git 仓库: {project}")
+
+    def load(self):
+        if not self.file.exists():
+            self.jobs = []
+            return
+
+        with open(self.file, "rb") as f:
+            data = tomllib.load(f)
+
+        self.jobs = [
+            CronJob(**job)
+            for job in data.get("jobs", [])
+        ]
+
+    def save(self):
+        data = {
+            "jobs": [
+                {
+                    "id": job.id,
+                    "schedule": job.schedule,
+                    "message": job.message,
+                    "project": job.project,
+                    "enabled": job.enabled,
+                    "last_run": job.last_run,
+                    "next_run": job.next_run,
+                    "one_time": job.one_time,
+                }
+                for job in self.jobs
+            ]
+        }
+
+        with open(self.file, "wb") as f:
+            tomli_w.dump(data, f)
+
+    def add(self, job: CronJob) -> None:
+        self._validate_project(job.project)
+
+        if any(j.id == job.id for j in self.jobs):
+            raise ValueError(f"任务 ID 已存在: {job.id}")
+
+        self.jobs.append(job)
+        self.save()
+
+    def remove(self, job_id: str) -> bool:
+        original_len = len(self.jobs)
+        self.jobs = [j for j in self.jobs if j.id != job_id]
+
+        if len(self.jobs) < original_len:
+            self.save()
+            return True
+        return False
+
+    def get(self, job_id: str) -> Optional[CronJob]:
+        for job in self.jobs:
+            if job.id == job_id:
+                return job
+        return None
+
+    def list(self) -> List[CronJob]:
+        return self.jobs
+
+    def enable(self, job_id: str) -> bool:
+        for job in self.jobs:
+            if job.id == job_id:
+                job.enabled = True
+                self.save()
+                return True
+        return False
+
+    def disable(self, job_id: str) -> bool:
+        for job in self.jobs:
+            if job.id == job_id:
+                job.enabled = False
+                self.save()
+                return True
+        return False
+
+    def get_due_jobs(self) -> List[CronJob]:
+        now = datetime.now()
+        due = []
+        one_time_completed = []
+
+        for job in self.jobs:
+            if not job.enabled:
+                continue
+
+            # 一次性任务处理
+            if job.one_time:
+                try:
+                    exec_time = datetime.fromisoformat(job.schedule)
+                    if exec_time <= now:
+                        due.append(job)
+                        one_time_completed.append(job.id)
+                except Exception:
+                    continue
+            else:
+                # 周期性任务处理
+                try:
+                    base = datetime.fromisoformat(job.last_run) if job.last_run else now
+                    itr = croniter(job.schedule, base)
+                    next_run = itr.get_next(datetime)
+
+                    if next_run <= now:
+                        due.append(job)
+                        job.last_run = now.isoformat()
+                        job.next_run = itr.get_next(datetime).isoformat()
+                except Exception:
+                    continue
+
+        # 删除已完成的一次性任务
+        if one_time_completed:
+            self.jobs = [j for j in self.jobs if j.id not in one_time_completed]
+
+        if due:
+            self.save()
+
+        return due

yee88/cron/models.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CronJob:
+    id: str
+    schedule: str
+    message: str
+    project: str
+    enabled: bool = True
+    last_run: str = ""
+    next_run: str = ""
+    one_time: bool = False

yee88/cron/scheduler.py

@@ -0,0 +1,57 @@
+import asyncio
+from typing import Callable, Awaitable
+from anyio.abc import TaskGroup
+from .manager import CronManager
+from .models import CronJob
+from ..logging import get_logger
+
+logger = get_logger()
+
+
+class CronScheduler:
+    def __init__(
+        self,
+        manager: CronManager,
+        callback: Callable[[CronJob], Awaitable[None]],
+        task_group: TaskGroup,
+    ):
+        self.manager = manager
+        self.callback = callback
+        self.task_group = task_group
+        self.running = False
+
+    async def start(self):
+        self.running = True
+        self.manager.load()
+        logger.info("cron.scheduler.started", job_count=len(self.manager.jobs))
+
+        cycle = 0
+        while self.running:
+            cycle += 1
+            self.manager.load()
+            logger.info("cron.scheduler.check_cycle", cycle=cycle, job_count=len(self.manager.jobs))
+            due_jobs = self.manager.get_due_jobs()
+
+            if due_jobs:
+                logger.info("cron.scheduler.due_jobs_found", cycle=cycle, count=len(due_jobs), job_ids=[j.id for j in due_jobs])
+            else:
+                logger.info("cron.scheduler.no_due_jobs", cycle=cycle)
+
+            for job in due_jobs:
+                logger.info("cron.scheduler.dispatching_job", job_id=job.id, message=job.message[:50])
+                self.task_group.start_soon(self._run_job_safe, job)
+
+            logger.info("cron.scheduler.sleeping", cycle=cycle, seconds=60)
+            await asyncio.sleep(60)
+
+    async def _run_job_safe(self, job: CronJob) -> None:
+        logger.info("cron.job.executing", job_id=job.id)
+        try:
+            await self.callback(job)
+            logger.info("cron.job.completed", job_id=job.id)
+        except Exception as exc:
+            logger.error("cron.job.failed", job_id=job.id, error=str(exc))
+
+    def stop(self):
+        self.running = False
+        logger.info("cron.scheduler.stopped")

yee88/markdown.py

@@ -244,6 +244,8 @@ class MarkdownFormatter:
             lines.append(state.context_line)
         if state.resume_line:
             lines.append(state.resume_line)
+        if state.model:
+            lines.append(f"`model: {state.model}`")
         if not lines:
             return None
         return HARD_BREAK.join(lines)

yee88/progress.py

@@ -25,6 +25,7 @@ class ProgressState:
     resume: ResumeToken | None
     resume_line: str | None
     context_line: str | None
+    model: str | None = None
 
 
 class ProgressTracker:
@@ -82,6 +83,7 @@ class ProgressTracker:
         *,
         resume_formatter: Callable[[ResumeToken], str] | None = None,
         context_line: str | None = None,
+        model: str | None = None,
     ) -> ProgressState:
         resume_line: str | None = None
         if self.resume is not None and resume_formatter is not None:
@@ -96,4 +98,5 @@ class ProgressTracker:
             resume=self.resume,
             resume_line=resume_line,
             context_line=context_line,
+            model=model,
         )

yee88/runner.py

@@ -698,6 +698,7 @@ class JsonlSubprocessRunner(BaseRunner):
 
 class Runner(Protocol):
     engine: str
+    model: str | None
 
     def is_resume_line(self, line: str) -> bool: ...