@scemoon/cdh 1.0.6 → 1.0.8

package/onecode/storage/session.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import json
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-from sqlalchemy import (
-    Column,
-    String,
-    DateTime,
-    JSON,
-    create_engine,
-)
-from sqlalchemy.orm import declarative_base, sessionmaker
-
-from onecode.config import ONECODE_DIR
-
-Base = declarative_base()
-
-
-class SessionRecord(Base):
-    __tablename__ = "sessions"
-
-    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
-    name = Column(String(255), default="Untitled")
-    mode = Column(String(50), default="build")
-    project = Column(String(255), default="")
-    model = Column(String(255), default="")
-    provider = Column(String(255), default="")
-    messages = Column(JSON, default=list)
-    lifecycle_state = Column(JSON, default=dict)
-    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
-    updated_at = Column(
-        DateTime,
-        default=lambda: datetime.now(timezone.utc),
-        onupdate=lambda: datetime.now(timezone.utc),
-    )
-
-
-class SessionStore:
-    def __init__(self, db_path: Optional[Path] = None):
-        if db_path is None:
-            db_path = ONECODE_DIR / "sessions" / "cdh.db"
-        db_path.parent.mkdir(parents=True, exist_ok=True)
-        self.engine = create_engine(f"sqlite:///{db_path}")
-        Base.metadata.create_all(self.engine)
-        self.Session = sessionmaker(bind=self.engine)
-
-    def create(self, name: str = "Untitled", mode: str = "build", project: str = "") -> SessionRecord:
-        with self.Session() as session:
-            record = SessionRecord(name=name, mode=mode, project=project)
-            session.add(record)
-            session.commit()
-            session.refresh(record)
-            return record
-
-    def list_all(self) -> list[SessionRecord]:
-        with self.Session() as session:
-            return session.query(SessionRecord).order_by(SessionRecord.updated_at.desc()).all()
-
-    def list_by_project(self, project: str) -> list[SessionRecord]:
-        with self.Session() as session:
-            return (
-                session.query(SessionRecord)
-                .filter_by(project=project)
-                .order_by(SessionRecord.updated_at.desc())
-                .all()
-            )
-
-    def load(self, session_id: str) -> Optional[SessionRecord]:
-        with self.Session() as session:
-            return session.query(SessionRecord).filter_by(id=session_id).first()
-
-    def update(self, record: SessionRecord):
-        with self.Session() as s:
-            s.merge(record)
-            s.commit()
-
-    def delete(self, session_id: str):
-        with self.Session() as s:
-            record = s.query(SessionRecord).filter_by(id=session_id).first()
-            if record:
-                s.delete(record)
-                s.commit()
-
-    def rename(self, session_id: str, new_name: str):
-        with self.Session() as s:
-            record = s.query(SessionRecord).filter_by(id=session_id).first()
-            if record:
-                record.name = new_name
-                s.commit()
-
-    def export_json(self, session_id: str) -> Optional[str]:
-        record = self.load(session_id)
-        if not record:
-            return None
-        return json.dumps(
-            {
-                "id": record.id,
-                "name": record.name,
-                "mode": record.mode,
-                "project": record.project,
-                "model": record.model,
-                "messages": record.messages,
-                "created_at": record.created_at.isoformat() if record.created_at else None,
-                "updated_at": record.updated_at.isoformat() if record.updated_at else None,
-            },
-            indent=2,
-            ensure_ascii=False,
-        )

package/onecode/tasks/__init__.py

@@ -1,26 +0,0 @@
-from onecode.tasks.models import (
-    TaskStatus,
-    TodoStatus,
-    TodoItem,
-    TaskChecklistState,
-    TaskGateRecord,
-    TaskToolCallSummary,
-    TaskTimelineEntry,
-    TaskRecord,
-)
-from onecode.tasks.manager import TaskManager, TaskExecutor, ExecutionTask, TaskExecutionResult
-
-__all__ = [
-    "TaskStatus",
-    "TodoStatus", 
-    "TodoItem",
-    "TaskChecklistState",
-    "TaskGateRecord",
-    "TaskToolCallSummary",
-    "TaskTimelineEntry",
-    "TaskRecord",
-    "TaskManager",
-    "TaskExecutor",
-    "ExecutionTask",
-    "TaskExecutionResult",
-]

package/onecode/tasks/manager.py

@@ -1,232 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-import uuid
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Callable, Optional
-
-logger = logging.getLogger("onecode.tasks")
-
-from onecode.tasks.models import (
-    TaskRecord,
-    TaskStatus,
-    TaskChecklistState,
-    TaskGateRecord,
-    TaskToolCallSummary,
-)
-
-
-class TaskExecutor(Callable[..., Any]):
-    async def execute(
-        self,
-        task: "ExecutionTask",
-        events: asyncio.Queue,
-        cancel: asyncio.Event,
-    ) -> dict[str, Any]:
-        raise NotImplementedError
-
-
-@dataclass
-class ExecutionTask:
-    id: str
-    prompt: str
-    model: str
-    workspace: Path
-
-
-@dataclass
-class TaskExecutionResult:
-    task_id: str
-    success: bool
-    output: str = ""
-    error: Optional[str] = None
-    duration_ms: int = 0
-
-
-class TaskManager:
-    def __init__(self, storage_path: Optional[Path] = None):
-        self._tasks: dict[str, TaskRecord] = {}
-        self._queue: asyncio.Queue[ExecutionTask] = asyncio.Queue()
-        self._running: dict[str, asyncio.Task] = {}
-        self._storage_path = storage_path or Path.home() / ".cdh" / "tasks"
-        self._executor: Optional[TaskExecutor] = None
-        self._worker_task: Optional[asyncio.Task] = None
-        self._semaphore = asyncio.Semaphore(5)
-        self._shutdown: bool = False
-
-    def set_executor(self, executor: TaskExecutor) -> None:
-        self._executor = executor
-
-    def add_task(
-        self,
-        prompt: str,
-        model: str = "MiniMax-M2.7",
-        workspace: Optional[Path] = None,
-        checklist: Optional[TaskChecklistState] = None,
-    ) -> TaskRecord:
-        task = TaskRecord(
-            id=str(uuid.uuid4())[:8],
-            prompt=prompt,
-            model=model,
-            workspace=workspace or Path.cwd(),
-            checklist=checklist or TaskChecklistState(),
-        )
-        self._tasks[task.id] = task
-        self._queue.put_nowait(
-            ExecutionTask(
-                id=task.id,
-                prompt=prompt,
-                model=model,
-                workspace=task.workspace,
-            )
-        )
-        return task
-
-    async def start_worker(self) -> None:
-        if self._worker_task is None:
-            self._worker_task = asyncio.create_task(self._worker_loop())
-
-    async def _worker_loop(self) -> None:
-        while not self._shutdown:
-            try:
-                task = await asyncio.wait_for(self._queue.get(), timeout=30)
-                if task.id not in self._running:
-                    async with self._semaphore:
-                        self._running[task.id] = asyncio.create_task(self._run_task(task))
-            except asyncio.TimeoutError:
-                continue
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error("Task worker error: %s", e)
-
-    async def _run_task(self, execution: ExecutionTask) -> None:
-        task_record = self._tasks.get(execution.id)
-        if not task_record:
-            return
-
-        task_record.status = TaskStatus.RUNNING
-        task_record.started_at = datetime.utcnow()
-
-        try:
-            if self._executor:
-                cancel = asyncio.Event()
-                events: asyncio.Queue = asyncio.Queue()
-                result = await asyncio.wait_for(
-                    self._executor.execute(execution, events, cancel),
-                    timeout=300,
-                )
-                task_record.status = TaskStatus.COMPLETED if result.get("success") else TaskStatus.FAILED
-                task_record.error = result.get("error")
-            else:
-                await asyncio.sleep(0.1)
-                task_record.status = TaskStatus.COMPLETED
-        except Exception as e:
-            task_record.status = TaskStatus.FAILED
-            task_record.error = str(e)
-        finally:
-            task_record.ended_at = datetime.utcnow()
-            if task_record.started_at:
-                task_record.duration_ms = int(
-                    (task_record.ended_at - task_record.started_at).total_seconds() * 1000
-                )
-            self._running.pop(execution.id, None)
-
-    def cancel_task(self, task_id: str) -> bool:
-        if task_id in self._running:
-            self._running[task_id].cancel()
-            task_record = self._tasks.get(task_id)
-            if task_record:
-                task_record.status = TaskStatus.CANCELED
-                task_record.ended_at = datetime.utcnow()
-            return True
-        return False
-
-    def get_task(self, task_id: str) -> Optional[TaskRecord]:
-        return self._tasks.get(task_id)
-
-    def list_tasks(self, status: Optional[TaskStatus] = None) -> list[TaskRecord]:
-        if status is None:
-            return list(self._tasks.values())
-        return [t for t in self._tasks.values() if t.status == status]
-
-    def add_todo_to_task(self, task_id: str, content: str, status: str = "pending") -> Optional["TaskChecklistItem"]:  # noqa: F821
-        task = self._tasks.get(task_id)
-        if not task:
-            return None
-        return task.checklist.add(content, status)
-
-    def update_todo_status(self, task_id: str, todo_id: int, status: str) -> bool:
-        task = self._tasks.get(task_id)
-        if not task:
-            return False
-        return task.checklist.update_status(todo_id, status)
-
-    def add_gate(
-        self,
-        task_id: str,
-        gate: str,
-        command: str,
-    ) -> Optional[TaskGateRecord]:
-        task = self._tasks.get(task_id)
-        if not task:
-            return None
-        gate_record = TaskGateRecord(
-            id=str(uuid.uuid4())[:8],
-            gate=gate,
-            command=command,
-        )
-        task.gates.append(gate_record)
-        return gate_record
-
-    def add_tool_call(
-        self,
-        task_id: str,
-        tool_id: str,
-        name: str,
-        input: dict[str, Any],
-    ) -> Optional[TaskToolCallSummary]:
-        task = self._tasks.get(task_id)
-        if not task:
-            return None
-        tc = TaskToolCallSummary(id=tool_id, name=name, input=input)
-        task.tool_calls.append(tc)
-        return tc
-
-    def update_tool_call_output(self, task_id: str, tool_id: str, output: str, duration_ms: int) -> bool:
-        task = self._tasks.get(task_id)
-        if not task:
-            return False
-        for tc in task.tool_calls:
-            if tc.id == tool_id:
-                tc.output = output
-                tc.duration_ms = duration_ms
-                return True
-        return False
-
-    def add_timeline_entry(self, task_id: str, event: str, detail: str = "") -> bool:
-        task = self._tasks.get(task_id)
-        if not task:
-            return False
-        from onecode.tasks.models import TaskTimelineEntry
-        task.timeline.append(TaskTimelineEntry(timestamp=datetime.utcnow(), event=event, detail=detail))
-        return True
-
-    async def stop(self) -> None:
-        self._shutdown = True
-        if self._worker_task:
-            self._worker_task.cancel()
-            try:
-                await self._worker_task
-            except asyncio.CancelledError:
-                pass
-        if self._running:
-            results = await asyncio.gather(
-                *self._running.values(), return_exceptions=True,
-            )
-            for tid, res in zip(list(self._running.keys()), results):
-                if isinstance(res, Exception):
-                    logger.warning("Task %s exited with error: %s", tid, res)

package/onecode/tasks/models.py

@@ -1,240 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from typing import Any, Optional
-from pathlib import Path
-
-
-class TaskStatus(str, Enum):
-    QUEUED = "queued"
-    RUNNING = "running"
-    COMPLETED = "completed"
-    FAILED = "failed"
-    CANCELED = "canceled"
-
-
-class TodoStatus(str, Enum):
-    PENDING = "pending"
-    IN_PROGRESS = "in_progress"
-    COMPLETED = "completed"
-
-
-@dataclass
-class TaskChecklistItem:
-    id: int
-    content: str
-    status: str = "pending"
-
-    def to_dict(self) -> dict:
-        return {"id": self.id, "content": self.content, "status": self.status}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TaskChecklistItem:
-        return cls(
-            id=data["id"],
-            content=data["content"],
-            status=data.get("status", "pending"),
-        )
-
-
-@dataclass
-class TodoItem:
-    id: int
-    content: str
-    status: TodoStatus = TodoStatus.PENDING
-
-    def to_dict(self) -> dict:
-        return {"id": self.id, "content": self.content, "status": self.status.value}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TodoItem:
-        return cls(
-            id=data["id"],
-            content=data["content"],
-            status=TodoStatus(data.get("status", "pending")),
-        )
-
-
-@dataclass
-class TaskChecklistState:
-    items: list[TaskChecklistItem] = field(default_factory=list)
-    completion_pct: int = 0
-    in_progress_id: Optional[int] = None
-    updated_at: Optional[datetime] = None
-
-    def add(self, content: str, status: str = "pending") -> TaskChecklistItem:
-        next_id = max([0] + [item.id for item in self.items]) + 1
-        item = TaskChecklistItem(id=next_id, content=content, status=status)
-        self.items.append(item)
-        self._recalc()
-        return item
-
-    def update_status(self, item_id: int, status: str) -> bool:
-        for item in self.items:
-            if item.id == item_id:
-                item.status = status
-                self._recalc()
-                return True
-        return False
-
-    def remove(self, item_id: int) -> bool:
-        for i, item in enumerate(self.items):
-            if item.id == item_id:
-                self.items.pop(i)
-                self._recalc()
-                return True
-        return False
-
-    def _recalc(self) -> None:
-        if not self.items:
-            self.completion_pct = 0
-            self.in_progress_id = None
-        else:
-            completed = sum(1 for item in self.items if item.status == "completed")
-            self.completion_pct = int(100 * completed / len(self.items))
-            in_progress = next((item.id for item in self.items if item.status == "in_progress"), None)
-            self.in_progress_id = in_progress
-        self.updated_at = datetime.utcnow()
-
-    def to_dict(self) -> dict:
-        return {
-            "items": [item.to_dict() for item in self.items],
-            "completion_pct": self.completion_pct,
-            "in_progress_id": self.in_progress_id,
-            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TaskChecklistState:
-        return cls(
-            items=[TaskChecklistItem.from_dict(d) for d in data.get("items", [])],
-            completion_pct=data.get("completion_pct", 0),
-            in_progress_id=data.get("in_progress_id"),
-            updated_at=datetime.fromisoformat(data["updated_at"]) if data.get("updated_at") else None,
-        )
-
-
-@dataclass
-class TaskGateRecord:
-    id: str
-    gate: str
-    command: str
-    exit_code: Optional[int] = None
-    status: str = "pending"
-    classification: str = ""
-    duration_ms: int = 0
-    summary: str = ""
-    log_path: Optional[Path] = None
-
-
-@dataclass
-class TaskToolCallSummary:
-    id: str
-    name: str
-    input: dict[str, Any]
-    output: str = ""
-    duration_ms: int = 0
-
-
-@dataclass
-class TaskTimelineEntry:
-    timestamp: datetime
-    event: str
-    detail: str = ""
-
-
-@dataclass
-class TaskRecord:
-    id: str
-    prompt: str
-    model: str
-    workspace: Path
-    status: TaskStatus = TaskStatus.QUEUED
-    created_at: datetime = field(default_factory=datetime.utcnow)
-    started_at: Optional[datetime] = None
-    ended_at: Optional[datetime] = None
-    duration_ms: Optional[int] = None
-    checklist: TaskChecklistState = field(default_factory=TaskChecklistState)
-    gates: list[TaskGateRecord] = field(default_factory=list)
-    tool_calls: list[TaskToolCallSummary] = field(default_factory=list)
-    timeline: list[TaskTimelineEntry] = field(default_factory=list)
-    artifacts: list[str] = field(default_factory=list)
-    error: Optional[str] = None
-
-    def to_dict(self) -> dict:
-        return {
-            "id": self.id,
-            "prompt": self.prompt,
-            "model": self.model,
-            "workspace": str(self.workspace),
-            "status": self.status.value,
-            "created_at": self.created_at.isoformat(),
-            "started_at": self.started_at.isoformat() if self.started_at else None,
-            "ended_at": self.ended_at.isoformat() if self.ended_at else None,
-            "duration_ms": self.duration_ms,
-            "checklist": self.checklist.to_dict(),
-            "gates": [
-                {
-                    "id": g.id,
-                    "gate": g.gate,
-                    "command": g.command,
-                    "exit_code": g.exit_code,
-                    "status": g.status,
-                    "classification": g.classification,
-                    "duration_ms": g.duration_ms,
-                    "summary": g.summary,
-                    "log_path": str(g.log_path) if g.log_path else None,
-                }
-                for g in self.gates
-            ],
-            "tool_calls": [
-                {
-                    "id": tc.id,
-                    "name": tc.name,
-                    "input": tc.input,
-                    "output": tc.output,
-                    "duration_ms": tc.duration_ms,
-                }
-                for tc in self.tool_calls
-            ],
-            "timeline": [
-                {
-                    "timestamp": t.timestamp.isoformat(),
-                    "event": t.event,
-                    "detail": t.detail,
-                }
-                for t in self.timeline
-            ],
-            "artifacts": self.artifacts,
-            "error": self.error,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TaskRecord:
-        from datetime import datetime
-        return cls(
-            id=data["id"],
-            prompt=data["prompt"],
-            model=data["model"],
-            workspace=Path(data["workspace"]),
-            status=TaskStatus(data.get("status", "queued")),
-            created_at=datetime.fromisoformat(data["created_at"]) if data.get("created_at") else datetime.utcnow(),
-            started_at=datetime.fromisoformat(data["started_at"]) if data.get("started_at") else None,
-            ended_at=datetime.fromisoformat(data["ended_at"]) if data.get("ended_at") else None,
-            duration_ms=data.get("duration_ms"),
-            checklist=TaskChecklistState.from_dict(data.get("checklist", {})),
-            gates=[TaskGateRecord(**g) for g in data.get("gates", [])],
-            tool_calls=[TaskToolCallSummary(**tc) for tc in data.get("tool_calls", [])],
-            timeline=[
-                TaskTimelineEntry(
-                    timestamp=datetime.fromisoformat(t["timestamp"]),
-                    event=t["event"],
-                    detail=t.get("detail", ""),
-                )
-                for t in data.get("timeline", [])
-            ],
-            artifacts=data.get("artifacts", []),
-            error=data.get("error"),
-        )