@scemoon/cdh 1.0.9 → 1.0.10-beta.1

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"),
-        )

package/onecode/trace/tracer.py

@@ -1,173 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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