@scemoon/cdh 1.0.8 → 1.0.9-beta.2

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,173 @@
+from __future__ import annotations
+
+import json
+import time
+import uuid
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from onecode.config import ONECODE_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 = ONECODE_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/verification/__init__.py

@@ -0,0 +1,5 @@
+from onecode.verification.loop import VerificationLoop, VerificationState
+from onecode.verification.policy import VerificationPolicy
+from onecode.verification.aggregation import AggregateResult
+
+__all__ = ["VerificationLoop", "VerificationState", "VerificationPolicy", "AggregateResult"]

package/onecode/verification/aggregation.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+
+@dataclass
+class GateResult:
+    name: str
+    status: str = "skipped"
+    exit_code: int | None = None
+    duration_ms: int = 0
+    summary: str = ""
+    log_path: str | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "status": self.status,
+            "exit_code": self.exit_code,
+            "duration_ms": self.duration_ms,
+            "summary": self.summary[:200] if self.summary else "",
+        }
+
+
+@dataclass
+class AggregateResult:
+    gate_results: dict[str, GateResult] = field(default_factory=dict)
+    timestamp: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+    @property
+    def passed(self) -> bool:
+        return len(self.failed_gates) == 0
+
+    @property
+    def failed(self) -> bool:
+        return len(self.failed_gates) > 0
+
+    @property
+    def skipped(self) -> list[str]:
+        return [n for n, r in self.gate_results.items() if r.status == "skipped"]
+
+    @property
+    def failed_gates(self) -> list[str]:
+        return [n for n, r in self.gate_results.items() if r.status == "failed"]
+
+    def to_dict(self) -> dict:
+        return {
+            "passed": self.passed,
+            "failed_gates": self.failed_gates,
+            "results": {n: {"status": r.status, "duration_ms": r.duration_ms, "summary": r.summary}
+                       for n, r in self.gate_results.items()},
+        }

package/onecode/verification/gates/__init__.py

@@ -0,0 +1,6 @@
+from onecode.verification.gates.base import Gate, GateResult
+from onecode.verification.gates.lint_gate import LintGate
+from onecode.verification.gates.type_gate import TypeGate
+from onecode.verification.gates.test_gate import TestGate
+
+__all__ = ["Gate", "GateResult", "LintGate", "TypeGate", "TestGate"]

package/onecode/verification/gates/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from onecode.agent.turn_record import TurnRecord
+from onecode.verification.aggregation import GateResult
+
+
+class Gate(ABC):
+    name: str = ""
+    enabled: bool = True
+
+    @abstractmethod
+    def should_run(self, tool_name: str, tool_result: Any) -> bool:
+        ...
+
+    @abstractmethod
+    async def run(self, turn_record: TurnRecord) -> GateResult:
+        ...

package/onecode/verification/gates/lint_gate.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from onecode.agent.turn_record import TurnRecord
+from onecode.verification.aggregation import GateResult
+from onecode.verification.gates.base import Gate
+
+
+class LintGate(Gate):
+    name = "lint"
+    target_dir: str = "."
+
+    def __init__(self, target_dir: str = "."):
+        self.target_dir = target_dir
+
+    def should_run(self, tool_name: str, tool_result: Any) -> bool:
+        return tool_name in {"WriteTool", "EditTool", "InsertTool", "ApplyPatchTool"}
+
+    async def run(self, turn_record: TurnRecord) -> GateResult:
+        start = time.time()
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "ruff", "check", self.target_dir,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+            duration = int((time.time() - start) * 1000)
+            out = stderr.decode() or stdout.decode()
+            return GateResult(
+                name=self.name,
+                status="passed" if proc.returncode == 0 else "failed",
+                exit_code=proc.returncode,
+                duration_ms=duration,
+                summary=out[:500],
+            )
+        except FileNotFoundError:
+            return GateResult(
+                name=self.name,
+                status="skipped",
+                summary="ruff not found in PATH",
+            )

package/onecode/verification/gates/test_gate.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any
+
+from onecode.agent.turn_record import TurnRecord
+from onecode.verification.aggregation import GateResult
+from onecode.verification.gates.base import Gate
+
+
+class TestGate(Gate):
+    name = "test"
+    target_dir: str = "tests"
+
+    def __init__(self, target_dir: str = "tests"):
+        self.target_dir = target_dir
+
+    _CODE_MODIFYING_PATTERNS = (
+        " > ", " | tee ", "tee -a ",
+        "pip install", "poetry install", "npm install", "yarn install", "pnpm install",
+        "cp ", "mv ", "rm ", "mkdir ",
+        "git commit", "git push", "git pull",
+        "cargo install", "go install",
+        "make install",
+    )
+
+    def should_run(self, tool_name: str, tool_result: Any) -> bool:
+        if tool_name == "ApplyPatchTool":
+            return True
+        if tool_name == "BashTool" and tool_result:
+            result_lower = str(tool_result).lower()
+            return any(
+                pat in result_lower for pat in self._CODE_MODIFYING_PATTERNS
+            )
+        return False
+
+    async def run(self, turn_record: TurnRecord) -> GateResult:
+        start = time.time()
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "pytest", self.target_dir, "-x", "--tb=short",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+            duration = int((time.time() - start) * 1000)
+            out = stderr.decode() or stdout.decode()
+            passed = proc.returncode == 0
+            return GateResult(
+                name=self.name,
+                status="passed" if passed else "failed",
+                exit_code=proc.returncode,
+                duration_ms=duration,
+                summary=out[-800:] if len(out) > 800 else out,
+            )
+        except FileNotFoundError:
+            return GateResult(
+                name=self.name,
+                status="skipped",
+                summary="pytest not found in PATH",
+            )