@scemoon/cdh 1.0.0

package/onecode/tasks/manager.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+from dataclasses import dataclass, field
+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,
+    TodoItem,
+    TodoStatus,
+)
+
+
+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() / ".onecode" / "tasks"
+        self._executor: Optional[TaskExecutor] = None
+        self._worker_task: Optional[asyncio.Task] = None
+
+    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 True:
+            try:
+                task = await self._queue.get()
+                if task.id not in self._running:
+                    self._running[task.id] = asyncio.create_task(self._run_task(task))
+            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 self._executor.execute(execution, events, cancel)
+                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"]:
+        from onecode.tasks.models import TaskChecklistItem
+        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:
+        if self._worker_task:
+            self._worker_task.cancel()
+            try:
+                await self._worker_task
+            except asyncio.CancelledError:
+                pass

package/onecode/tasks/models.py

@@ -0,0 +1,240 @@
+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"),
+        )

package/onecode/trace/tracer.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+
+class Span:
+    def __init__(self, name: str, trace_id: str, parent_id: Optional[str] = None):
+        self.span_id = str(uuid.uuid4())[:16]
+        self.trace_id = trace_id
+        self.parent_id = parent_id
+        self.name = name
+        self.start_time = time.time()
+        self.end_time: Optional[float] = None
+        self.attributes: dict[str, Any] = {}
+        self.events: list[dict] = []
+
+    def finish(self):
+        self.end_time = time.time()
+
+    def to_dict(self) -> dict:
+        return {
+            "span_id": self.span_id,
+            "trace_id": self.trace_id,
+            "parent_id": self.parent_id,
+            "name": self.name,
+            "start_time": self.start_time,
+            "end_time": self.end_time,
+            "duration_ms": round((self.end_time - self.start_time) * 1000, 2) if self.end_time else None,
+            "attributes": self.attributes,
+            "events": self.events,
+        }
+
+    def set_attribute(self, key: str, value: Any) -> None:
+        self.attributes[key] = value
+
+    def add_event(self, name: str, attributes: Optional[dict] = None) -> None:
+        self.events.append({
+            "name": name,
+            "timestamp": time.time(),
+            "attributes": attributes or {},
+        })
+
+
+class Tracer:
+    def __init__(self):
+        self.trace_id: Optional[str] = None
+        self.recording: bool = False
+        self.spans: list[Span] = []
+        self.stack: list[str] = []
+        self.trace_dir = CLOUD_DEV_HARNESS_DIR / "traces"
+        self.trace_dir.mkdir(parents=True, exist_ok=True)
+        self._otlp_endpoint: Optional[str] = None
+
+    def start(self):
+        self.trace_id = str(uuid.uuid4())
+        self.recording = True
+        self.spans = []
+        self.stack = []
+
+    def stop(self):
+        self.recording = False
+        self._export()
+        if self._otlp_endpoint:
+            self._export_otlp()
+
+    def set_otlp_endpoint(self, endpoint: str) -> None:
+        self._otlp_endpoint = endpoint
+
+    @contextmanager
+    def span(self, name: str, attributes: Optional[dict] = None):
+        span = self.start_span(name, attributes)
+        try:
+            yield span
+        except Exception as e:
+            span.add_event("exception", {"message": str(e), "type": type(e).__name__})
+            raise
+        finally:
+            self.end_span(span)
+
+    def start_span(self, name: str, attributes: Optional[dict] = None) -> Span:
+        if not self.recording:
+            span = Span(name, "no-trace")
+            span.finish()
+            return span
+        parent_id = self.stack[-1] if self.stack else None
+        span = Span(name, self.trace_id or "", parent_id)
+        if attributes:
+            span.attributes.update(attributes)
+        self.spans.append(span)
+        self.stack.append(span.span_id)
+        return span
+
+    def end_span(self, span: Span):
+        span.finish()
+        if self.stack and self.stack[-1] == span.span_id:
+            self.stack.pop()
+
+    def record_event(self, name: str, attributes: Optional[dict] = None, span: Optional[Span] = None) -> None:
+        target = span or (self.spans[-1] if self.spans else None)
+        if target:
+            target.add_event(name, attributes)
+
+    def add_event(self, span: Span, name: str, attributes: Optional[dict] = None):
+        span.events.append({
+            "name": name,
+            "timestamp": time.time(),
+            "attributes": attributes or {},
+        })
+
+    def _export(self):
+        if not self.trace_id:
+            return
+        data = {
+            "trace_id": self.trace_id,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "spans": [s.to_dict() for s in self.spans],
+        }
+        path = self.trace_dir / f"{self.trace_id}.json"
+        path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+
+    def _export_otlp(self):
+        if not self._otlp_endpoint or not self.trace_id:
+            return
+        try:
+            import httpx
+            payload = {
+                "resourceSpans": [{
+                    "traceId": self.trace_id,
+                    "spans": [{
+                        "spanId": s.span_id,
+                        "parentSpanId": s.parent_id or "",
+                        "name": s.name,
+                        "startTimeUnixNano": int(s.start_time * 1e9),
+                        "endTimeUnixNano": int(s.end_time * 1e9) if s.end_time else 0,
+                        "attributes": [{"key": k, "value": {"stringValue": str(v)}} for k, v in s.attributes.items()],
+                        "events": [{"name": e["name"], "timeUnixNano": int(e["timestamp"] * 1e9)} for e in s.events],
+                    } for s in self.spans],
+                }]
+            }
+            httpx.post(self._otlp_endpoint, json=payload, timeout=5)
+        except Exception:
+            pass
+
+    def view(self, trace_id: Optional[str] = None) -> list[dict]:
+        if trace_id:
+            path = self.trace_dir / f"{trace_id}.json"
+            if path.exists():
+                data = json.loads(path.read_text())
+                return data.get("spans", [])
+        return [s.to_dict() for s in self.spans]
+
+    def list_traces(self) -> list[dict]:
+        if not self.trace_dir.exists():
+            return []
+        traces = []
+        for f in self.trace_dir.glob("*.json"):
+            try:
+                data = json.loads(f.read_text())
+                traces.append({
+                    "trace_id": data.get("trace_id"),
+                    "timestamp": data.get("timestamp"),
+                    "span_count": len(data.get("spans", [])),
+                })
+            except Exception:
+                continue
+        return sorted(traces, key=lambda x: x.get("timestamp", ""), reverse=True)

package/onecode/utils/helpers.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Optional
+
+
+def expand_path(path: str, base: Optional[Path] = None) -> Path:
+    path = Path(path).expanduser()
+    if not path.is_absolute() and base:
+        path = base / path
+    return path.resolve()
+
+
+def sanitize_name(name: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9_-]", "_", name).lower()
+
+
+def truncate(text: str, max_len: int = 100) -> str:
+    return text[:max_len] + "..." if len(text) > max_len else text

package/onecode-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./run.js').run('onecode');

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@scemoon/cdh",
+  "version": "1.0.0",
+  "description": "Cloud Dev Harness - cloud-native development Agent framework",
+  "keywords": ["ai", "agent", "cloud", "development", "cli", "tui"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scemoon/cloud-dev-harness.git"
+  },
+  "bin": {
+    "cdh": "cli.js",
+    "cloud-dev-harness": "cli.js"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "cli.js",
+    "onecode-cli.js",
+    "run.js",
+    "package.json",
+    "pyproject.toml",
+    "cdh",
+    "onecode",
+    "tui",
+    "ai-dlc-skill"
+  ],
+  "scripts": {
+    "postinstall": "node cli.js"
+  }
+}