taskwatch 0.1.0__py3-none-any.whl

taskwatch/__init__.py

@@ -0,0 +1,3 @@
+"""TaskWatch - A lightweight local task scheduler with CLI, web UI, and email reporting."""
+
+__version__ = "0.3.0"

taskwatch/cli/log.py

@@ -0,0 +1,128 @@
+"""Log viewing CLI commands."""
+
+import time
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from taskwatch.core.models import Database
+from taskwatch.utils.config import get_config
+
+console = Console()
+log_app = typer.Typer(help="Log viewing commands", no_args_is_help=True)
+
+
+@log_app.callback(invoke_without_command=True)
+def view_log(
+    task_id: int = typer.Argument(..., help="Task ID to view logs for"),
+    tail: int = typer.Option(20, "--tail", "-n", help="Number of recent lines to show"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow log output in real-time"),
+    run_id: Optional[int] = typer.Option(None, "--run-id", help="Specific run ID to view"),
+):
+    """View task logs."""
+    db = Database().connect()
+    config = get_config()
+
+    task = db.get_task(task_id)
+    if task is None:
+        console.print(f"[red]Task {task_id} not found.[/red]")
+        raise typer.Exit(1)
+
+    if run_id:
+        # View specific run log
+        run = db.get_run(run_id)
+        if run is None or run["task_id"] != task_id:
+            console.print(f"[red]Run {run_id} not found for task {task_id}.[/red]")
+            raise typer.Exit(1)
+
+        _display_run_log(run, config, tail)
+    else:
+        # View recent runs
+        runs = db.get_recent_runs(task_id, limit=10)
+        if not runs:
+            console.print(f"[yellow]No runs found for task '{task['name']}'.[/yellow]")
+            db.close()
+            return
+
+        # Show recent runs table
+        table = Table(title=f"Recent Runs for '{task['name']}'", show_lines=True)
+        table.add_column("Run ID", style="cyan", width=7)
+        table.add_column("Start Time", style="white", width=20)
+        table.add_column("Status", style="yellow", width=10)
+        table.add_column("Duration", style="green", width=10)
+        table.add_column("Log File", style="blue", width=40)
+
+        for r in runs:
+            duration_s = f"{r['duration'] / 1000:.1f}s" if r.get("duration") else "-"
+            status_color = {
+                "success": "green",
+                "failed": "red",
+                "timeout": "red",
+                "running": "yellow",
+                "killed": "red",
+            }.get(r.get("status", ""), "white")
+            table.add_row(
+                str(r["id"]),
+                r.get("start_time", "-")[:19],
+                f"[{status_color}]{r.get('status', '-')}[/{status_color}]",
+                duration_s,
+                r.get("log_file", "-"),
+            )
+
+        console.print(table)
+
+        # Show the latest run's log
+        latest = runs[0]
+        if latest.get("log_file") and Path(latest["log_file"]).exists():
+            console.print(f"\n[bold]Latest log (Run #{latest['id']}):[/bold]")
+            _display_run_log(latest, config, tail, follow)
+
+    db.close()
+
+
+def _display_run_log(
+    run: dict,
+    config,
+    tail: int = 20,
+    follow: bool = False,
+) -> None:
+    """Display a run's log content."""
+    log_file = run.get("log_file")
+    if log_file and Path(log_file).exists():
+        path = Path(log_file)
+        if follow:
+            _follow_file(path)
+        else:
+            lines = path.read_text(encoding="utf-8", errors="replace").splitlines()
+            display_lines = lines[-tail:] if len(lines) > tail else lines
+            for line in display_lines:
+                console.print(line)
+    else:
+        # Fallback to database summaries
+        if run.get("stdout_summary"):
+            console.print("[bold]STDOUT:[/bold]")
+            console.print(run["stdout_summary"][:tail * 100])
+        if run.get("stderr_summary"):
+            console.print("[bold red]STDERR:[/bold red]")
+            console.print(run["stderr_summary"][:tail * 100])
+        if not run.get("stdout_summary") and not run.get("stderr_summary"):
+            console.print("[yellow]No log content available.[/yellow]")
+
+
+def _follow_file(path: Path) -> None:
+    """Follow a log file in real-time (like tail -f)."""
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            # Seek to end
+            f.seek(0, 2)
+            while True:
+                line = f.readline()
+                if line:
+                    console.print(line, end="")
+                else:
+                    time.sleep(0.5)
+    except KeyboardInterrupt:
+        pass

taskwatch/cli/main.py

@@ -0,0 +1,219 @@
+"""TaskWatch CLI main application (Typer)."""
+
+import typer
+
+app = typer.Typer(
+    name="taskwatch",
+    help="TaskWatch - A lightweight local task scheduler with CLI, web UI, and email reporting.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+
+
+@app.callback()
+def main():
+    """TaskWatch - Lightweight task scheduler and monitor."""
+    pass
+
+
+@app.command(name="init")
+def init_cmd():
+    """Initialize TaskWatch: create directories, database, and config file."""
+    from pathlib import Path
+    from taskwatch.utils.config import _get_default_dir, Config
+    from taskwatch.core.models import Database
+    from taskwatch.utils.logger import get_logger
+
+    logger = get_logger()
+
+    # Resolve the working directory
+    work_dir = _get_default_dir()
+
+    # Create directory
+    work_dir.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Created directory: {work_dir}")
+
+    # Create log directory
+    log_dir = work_dir / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Created log directory: {log_dir}")
+
+    # Initialize database
+    db_path = work_dir / "taskwatch.db"
+    db = Database(db_path)
+    db.connect()
+    db.initialize()
+    db.close()
+    logger.info(f"Initialized database: {db_path}")
+
+    # Create default config
+    config_path = work_dir / "config.toml"
+    if not config_path.exists():
+        config = Config(config_path)
+        config.load()
+        config.save()
+        logger.info(f"Created config file: {config_path}")
+    else:
+        logger.info(f"Config file already exists: {config_path}")
+
+    # Interactive SMTP setup
+    smtp_setup = typer.confirm("Would you like to configure SMTP for email alerts?", default=False)
+    if smtp_setup:
+        config = Config(config_path).load()
+
+        host = typer.prompt("SMTP server host", default="smtp.gmail.com")
+        port = typer.prompt("SMTP server port", default=587, type=int)
+        username = typer.prompt("SMTP username (email address)")
+        password = typer.prompt("SMTP password", hide_input=True)
+        from_addr = typer.prompt("From email address", default=username)
+        to_addrs_str = typer.prompt("Recipient email addresses (comma-separated)")
+
+        config.set("smtp", "enabled", value=True)
+        config.set("smtp", "host", value=host)
+        config.set("smtp", "port", value=port)
+        config.set("smtp", "username", value=username)
+        config.set("smtp", "password", value=password)
+        config.set("smtp", "from_addr", value=from_addr)
+        config.set("smtp", "to_addrs", value=[a.strip() for a in to_addrs_str.split(",")])
+        config.save()
+
+        logger.info("SMTP configuration saved")
+
+        # Test email
+        test_mail = typer.confirm("Send a test email to verify configuration?", default=False)
+        if test_mail:
+            from taskwatch.core.notifier import Notifier
+            notifier = Notifier()
+            if notifier.send_test_email():
+                typer.echo("Test email sent successfully!")
+            else:
+                typer.echo("Failed to send test email. Please check your configuration.", err=True)
+
+    typer.echo("\nTaskWatch initialized successfully!")
+    typer.echo(f"  Data directory: {work_dir}")
+    typer.echo(f"  Config file:    {config_path}")
+    typer.echo(f"  Database:       {db_path}")
+    typer.echo("\nNext steps:")
+    typer.echo("  tw task add --name 'my_task' --command 'echo hello' --schedule '0 9 * * *'")
+    typer.echo("  tw run")
+
+
+@app.command(name="config")
+def config_cmd(
+    key: str = typer.Argument(None, help="Config key (e.g., 'smtp.host')"),
+    value: str = typer.Argument(None, help="Config value to set"),
+    list_all: bool = typer.Option(False, "--list", "-l", help="List all configuration"),
+):
+    """View or modify TaskWatch configuration."""
+    from taskwatch.utils.config import get_config, reload_config
+
+    config = reload_config()
+
+    if list_all or key is None:
+        import json
+        typer.echo(json.dumps(config.data, indent=2, ensure_ascii=False))
+        return
+
+    keys = key.split(".")
+    if value is None:
+        # Get value
+        val = config.get(*keys)
+        if val is None:
+            typer.echo(f"Key '{key}' not found", err=True)
+            raise typer.Exit(1)
+        typer.echo(f"{key} = {val}")
+    else:
+        # Set value
+        parsed_value = value
+        if value.lower() in ("true", "false"):
+            parsed_value = value.lower() == "true"
+        elif value.isdigit():
+            parsed_value = int(value)
+        else:
+            try:
+                parsed_value = float(value)
+            except ValueError:
+                pass
+
+        config.set(*keys, value=parsed_value)
+        config.save()
+        typer.echo(f"Set {key} = {parsed_value}")
+
+
+@app.command(name="mail")
+def mail_cmd(
+    action: str = typer.Argument(..., help="Mail action: 'test'"),
+):
+    """Mail-related commands. Use 'mail test' to test SMTP configuration."""
+    if action == "test":
+        from taskwatch.core.notifier import Notifier
+        notifier = Notifier()
+        if not notifier.is_configured:
+            typer.echo("SMTP is not configured. Run 'tw init' or 'tw config' to set up SMTP.", err=True)
+            raise typer.Exit(1)
+        if notifier.send_test_email():
+            typer.echo("Test email sent successfully!")
+        else:
+            typer.echo("Failed to send test email.", err=True)
+            raise typer.Exit(1)
+    else:
+        typer.echo(f"Unknown mail action: {action}. Use 'mail test'.", err=True)
+        raise typer.Exit(1)
+
+
+@app.command(name="web")
+def web_cmd(
+    host: str = typer.Option("127.0.0.1", "--host", help="Host to bind to"),
+    port: int = typer.Option(8899, "--port", "-p", help="Port to listen on"),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Don't auto-open browser"),
+):
+    """Start the TaskWatch web management interface."""
+    from taskwatch.utils.config import get_config
+    from taskwatch.utils.logger import get_logger
+
+    logger = get_logger()
+
+    config = get_config()
+    actual_host = host or config.web_host
+    actual_port = port or config.web_port
+
+    logger.info(f"Starting TaskWatch web server on {actual_host}:{actual_port}")
+
+    # Auto-open browser
+    open_browser = not no_browser and config.web_auto_open_browser
+    if open_browser:
+        import webbrowser
+        import threading
+
+        def _open():
+            import time
+            time.sleep(1.5)
+            webbrowser.open(f"http://{actual_host}:{actual_port}")
+
+        threading.Thread(target=_open, daemon=True).start()
+
+    # Start uvicorn
+    import uvicorn
+    uvicorn.run(
+        "taskwatch.web.app:create_app",
+        host=actual_host,
+        port=actual_port,
+        factory=True,
+        log_level="info",
+    )
+
+
+# Register sub-commands from other modules
+from taskwatch.cli.task import task_app
+from taskwatch.cli.run import run_app
+from taskwatch.cli.log import log_app
+from taskwatch.cli.report import report_app
+
+app.add_typer(task_app, name="task", help="Task management commands")
+app.add_typer(run_app, name="run", help="Run the scheduler")
+app.add_typer(log_app, name="log", help="View task logs")
+app.add_typer(report_app, name="report", help="Generate reports")
+
+
+if __name__ == "__main__":
+    app()

taskwatch/cli/report.py

@@ -0,0 +1,104 @@
+"""Report commands for TaskWatch CLI."""
+
+import typer
+
+report_app = typer.Typer(help="Report generation commands", no_args_is_help=True)
+
+
+@report_app.command("daily")
+def generate_daily(
+    date: str = typer.Argument(None, help="Date in YYYY-MM-DD format (default: today)"),
+    send: bool = typer.Option(False, "--send", "-s", help="Send report via email after generation"),
+):
+    """Generate a daily report."""
+    from taskwatch.core.models import Database
+    from taskwatch.core.reporter import Reporter
+    from taskwatch.core.notifier import Notifier
+    from taskwatch.utils.logger import get_logger
+
+    logger = get_logger()
+
+    db = Database().connect()
+    reporter = Reporter(db)
+    result = reporter.generate_daily_report(date)
+
+    if result is None:
+        db.close()
+        typer.echo("No data available for daily report.")
+        raise typer.Exit(1)
+
+    typer.echo(f"Daily report generated (ID: {result['report_id']})")
+    typer.echo(f"  Date: {result['date']}")
+    typer.echo(f"  Total: {result['total']}, Success: {result['success_count']}, Fail: {result['fail_count']}")
+    typer.echo(f"  Success rate: {result['success_rate']}%")
+
+    if send:
+        notifier = Notifier(db)
+        if not notifier.is_configured:
+            db.close()
+            typer.echo("SMTP not configured, cannot send report.", err=True)
+            raise typer.Exit(1)
+
+        from datetime import datetime
+        html = result["html_content"]
+        subject = f"[TaskWatch] 日报 - {result['date']}"
+        recipients = notifier._get_recipients()
+        success = notifier._send_email(recipients, subject, html) if recipients else False
+
+        db.update_report(result["report_id"], {
+            "sent_status": "success" if success else "failed",
+            "sent_at": datetime.now().isoformat(),
+        })
+        typer.echo(f"  Email sent: {'OK' if success else 'FAILED'}")
+
+    db.close()
+
+
+@report_app.command("weekly")
+def generate_weekly(
+    start_date: str = typer.Argument(None, help="Start date in YYYY-MM-DD format"),
+    end_date: str = typer.Argument(None, help="End date in YYYY-MM-DD format"),
+    send: bool = typer.Option(False, "--send", "-s", help="Send report via email after generation"),
+):
+    """Generate a weekly report."""
+    from taskwatch.core.models import Database
+    from taskwatch.core.reporter import Reporter
+    from taskwatch.core.notifier import Notifier
+    from taskwatch.utils.logger import get_logger
+
+    logger = get_logger()
+
+    db = Database().connect()
+    reporter = Reporter(db)
+    result = reporter.generate_weekly_report(start_date, end_date)
+
+    if result is None:
+        db.close()
+        typer.echo("No data available for weekly report.")
+        raise typer.Exit(1)
+
+    typer.echo(f"Weekly report generated (ID: {result['report_id']})")
+    typer.echo(f"  Period: {result['start_date']} ~ {result['end_date']}")
+    typer.echo(f"  Total: {result['total']}, Success: {result['success_count']}")
+    typer.echo(f"  Success rate: {result['success_rate']}%")
+
+    if send:
+        notifier = Notifier(db)
+        if not notifier.is_configured:
+            db.close()
+            typer.echo("SMTP not configured, cannot send report.", err=True)
+            raise typer.Exit(1)
+
+        from datetime import datetime
+        html = result["html_content"]
+        subject = f"[TaskWatch] 周报 - {result['start_date']} ~ {result['end_date']}"
+        recipients = notifier._get_recipients()
+        success = notifier._send_email(recipients, subject, html) if recipients else False
+
+        db.update_report(result["report_id"], {
+            "sent_status": "success" if success else "failed",
+            "sent_at": datetime.now().isoformat(),
+        })
+        typer.echo(f"  Email sent: {'OK' if success else 'FAILED'}")
+
+    db.close()

taskwatch/cli/run.py

@@ -0,0 +1,23 @@
+"""Run command for TaskWatch CLI - starts the scheduler."""
+
+import typer
+
+run_app = typer.Typer(help="Scheduler commands", no_args_is_help=True)
+
+
+@run_app.callback(invoke_without_command=True)
+def run_scheduler(
+    daemon: bool = typer.Option(False, "--daemon", "-d", help="Run as background daemon (Unix-like only)"),
+):
+    """Start the task scheduler."""
+    from taskwatch.core.scheduler import TaskScheduler
+    from taskwatch.utils.logger import get_logger
+
+    logger = get_logger()
+
+    scheduler = TaskScheduler()
+
+    if daemon:
+        scheduler.run_daemon()
+    else:
+        scheduler.run_forever()