Phase 5: 자동화 태스크 시스템 구현

- automation/taskModel.py: TaskDefinition, TaskRun, TaskStatus 모델
- automation/taskRunner.py: 문서를 headless로 실행 (기존 SessionManager 재사용)
- automation/scheduler.py: asyncio 기반 인프로세스 스케줄러 (@every_Xm/h/s 프리셋)
- automation/taskRegistry.py: 태스크 CRUD + 실행 이력, ~/.codaro/tasks/ 디스크 영속
- api/automationRouter.py: GET/POST/PUT/DELETE /api/tasks, POST /api/tasks/{id}/run
- cli.py: `codaro task run <path>`, `codaro task list` 커맨드 추가
- server.py: automation 라우터 등록
- 테스트 22개 추가 (총 231개 통과)

Author: eddmpython

src/codaro/api/__init__.py

@@ -1,4 +1,5 @@
 from .aiRouter import createAiRouter
+from .automationRouter import createAutomationRouter
 from .appState import ServerState, createServerState
 from .bootstrapRouter import createBootstrapRouter
 from .curriculumRouter import createCurriculumRouter
@@ -38,6 +39,7 @@
     "ApiError",
     "apiErrorHandler",
     "createAiRouter",
+    "createAutomationRouter",
     "createBootstrapRouter",
     "createCurriculumRouter",
     "createDocumentRouter",

src/codaro/api/automationRouter.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from ..automation.taskModel import TaskDefinition
+from ..automation.taskRegistry import getTaskRegistry
+from ..automation.taskRunner import TaskRunner
+
+logger = logging.getLogger(__name__)
+
+
+class CreateTaskRequest(BaseModel):
+    name: str
+    documentPath: str
+    description: str = ""
+    schedule: str | None = None
+    inputs: dict[str, Any] | None = None
+
+
+class UpdateTaskRequest(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    schedule: str | None = None
+    enabled: bool | None = None
+
+
+class ScheduleRequest(BaseModel):
+    schedule: str
+
+
+def createAutomationRouter(state: Any) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/api/tasks")
+    def apiListTasks():
+        registry = getTaskRegistry()
+        tasks = registry.listTasks()
+        return {
+            "tasks": [t.serialize() for t in tasks],
+            "total": len(tasks),
+        }
+
+    @router.post("/api/tasks")
+    def apiCreateTask(req: CreateTaskRequest):
+        registry = getTaskRegistry()
+        task = registry.create(
+            name=req.name,
+            documentPath=req.documentPath,
+            description=req.description,
+            schedule=req.schedule,
+            inputs=req.inputs,
+        )
+        return task.serialize()
+
+    @router.get("/api/tasks/{taskId}")
+    def apiGetTask(taskId: str):
+        registry = getTaskRegistry()
+        task = registry.get(taskId)
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+        lastRun = registry.getLastRun(taskId)
+        result = task.serialize()
+        if lastRun:
+            result["lastRun"] = lastRun.serialize()
+        return result
+
+    @router.put("/api/tasks/{taskId}")
+    def apiUpdateTask(taskId: str, req: UpdateTaskRequest):
+        registry = getTaskRegistry()
+        task = registry.update(
+            taskId,
+            name=req.name,
+            description=req.description,
+            schedule=req.schedule,
+            enabled=req.enabled,
+        )
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+        return task.serialize()
+
+    @router.delete("/api/tasks/{taskId}")
+    def apiDeleteTask(taskId: str):
+        registry = getTaskRegistry()
+        deleted = registry.delete(taskId)
+        if not deleted:
+            raise HTTPException(status_code=404, detail="Task not found")
+        return {"ok": True}
+
+    @router.post("/api/tasks/{taskId}/run")
+    async def apiRunTask(taskId: str):
+        registry = getTaskRegistry()
+        task = registry.get(taskId)
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+
+        workspaceRoot = str(getattr(state, "workspaceRoot", "."))
+        runner = TaskRunner(workspaceRoot=workspaceRoot)
+        run = await runner.run(task)
+        registry.addRun(run)
+        return run.serialize()
+
+    @router.get("/api/tasks/{taskId}/runs")
+    def apiGetRuns(taskId: str, limit: int = Query(20)):
+        registry = getTaskRegistry()
+        task = registry.get(taskId)
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+        runs = registry.getRuns(taskId, limit=limit)
+        return {"runs": [r.serialize() for r in runs]}
+
+    @router.put("/api/tasks/{taskId}/schedule")
+    def apiSetSchedule(taskId: str, req: ScheduleRequest):
+        registry = getTaskRegistry()
+        task = registry.update(taskId, schedule=req.schedule)
+        if task is None:
+            raise HTTPException(status_code=404, detail="Task not found")
+
+        from ..automation.scheduler import TaskScheduler, parseScheduleSeconds
+
+        if parseScheduleSeconds(req.schedule) is None:
+            raise HTTPException(status_code=400, detail=f"Invalid schedule: {req.schedule}")
+
+        return {"ok": True, "schedule": req.schedule}
+
+    return router

src/codaro/automation/__init__.py

@@ -0,0 +1,14 @@
+from .taskModel import TaskDefinition, TaskRun, TaskStatus
+from .taskRunner import TaskRunner
+from .scheduler import TaskScheduler
+from .taskRegistry import TaskRegistry, getTaskRegistry
+
+__all__ = [
+    "TaskDefinition",
+    "TaskRun",
+    "TaskStatus",
+    "TaskRunner",
+    "TaskScheduler",
+    "TaskRegistry",
+    "getTaskRegistry",
+]

src/codaro/automation/scheduler.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from datetime import datetime, timezone
+from typing import Any, Callable, Coroutine
+
+logger = logging.getLogger(__name__)
+
+_CRON_PRESETS: dict[str, int] = {
+    "@every_1m": 60,
+    "@every_5m": 300,
+    "@every_15m": 900,
+    "@every_30m": 1800,
+    "@every_1h": 3600,
+    "@every_6h": 21600,
+    "@every_12h": 43200,
+    "@daily": 86400,
+}
+
+
+def parseScheduleSeconds(schedule: str) -> int | None:
+    if schedule in _CRON_PRESETS:
+        return _CRON_PRESETS[schedule]
+
+    match = re.match(r"^@every_(\d+)(s|m|h)$", schedule)
+    if match:
+        value = int(match.group(1))
+        unit = match.group(2)
+        if unit == "s":
+            return value
+        if unit == "m":
+            return value * 60
+        if unit == "h":
+            return value * 3600
+
+    return None
+
+
+class TaskScheduler:
+
+    def __init__(self) -> None:
+        self._jobs: dict[str, asyncio.Task[None]] = {}
+        self._running = False
+
+    @property
+    def jobCount(self) -> int:
+        return len(self._jobs)
+
+    def schedule(
+        self,
+        taskId: str,
+        schedule: str,
+        callback: Callable[[], Coroutine[Any, Any, None]],
+    ) -> bool:
+        intervalSeconds = parseScheduleSeconds(schedule)
+        if intervalSeconds is None:
+            return False
+
+        self.cancel(taskId)
+
+        async def _loop() -> None:
+            while True:
+                await asyncio.sleep(intervalSeconds)
+                try:
+                    await callback()
+                except asyncio.CancelledError:
+                    break
+                except Exception:
+                    logger.exception("Scheduled task %s failed", taskId)
+
+        self._jobs[taskId] = asyncio.create_task(_loop())
+        return True
+
+    def cancel(self, taskId: str) -> bool:
+        job = self._jobs.pop(taskId, None)
+        if job is not None:
+            job.cancel()
+            return True
+        return False
+
+    def cancelAll(self) -> int:
+        count = len(self._jobs)
+        for job in self._jobs.values():
+            job.cancel()
+        self._jobs.clear()
+        return count
+
+    def isScheduled(self, taskId: str) -> bool:
+        return taskId in self._jobs
+
+    def listScheduled(self) -> list[str]:
+        return list(self._jobs.keys())

src/codaro/automation/taskModel.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any
+
+
+class TaskStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+@dataclass
+class TaskDefinition:
+    id: str = field(default_factory=lambda: f"task-{uuid.uuid4().hex[:10]}")
+    name: str = ""
+    description: str = ""
+    documentPath: str = ""
+    schedule: str | None = None
+    inputs: dict[str, Any] = field(default_factory=dict)
+    outputs: list[str] = field(default_factory=list)
+    createdAt: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    updatedAt: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+    enabled: bool = True
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "documentPath": self.documentPath,
+            "schedule": self.schedule,
+            "inputs": self.inputs,
+            "outputs": self.outputs,
+            "createdAt": self.createdAt,
+            "updatedAt": self.updatedAt,
+            "enabled": self.enabled,
+        }
+
+
+@dataclass
+class TaskRun:
+    id: str = field(default_factory=lambda: f"run-{uuid.uuid4().hex[:10]}")
+    taskId: str = ""
+    status: TaskStatus = TaskStatus.PENDING
+    startedAt: str | None = None
+    finishedAt: str | None = None
+    durationMs: int | None = None
+    output: str = ""
+    error: str | None = None
+    variables: dict[str, Any] = field(default_factory=dict)
+
+    def serialize(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "taskId": self.taskId,
+            "status": self.status.value,
+            "startedAt": self.startedAt,
+            "finishedAt": self.finishedAt,
+            "durationMs": self.durationMs,
+            "output": self.output,
+            "error": self.error,
+            "variables": self.variables,
+        }