@scemoon/cdh 1.0.6 → 1.0.7

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/pyproject.toml

@@ -1,74 +0,0 @@
-[project]
-name = "cloud-dev-harness"
-version = "1.0.5"
-description = "Cloud Dev Harness - cloud-native development Agent framework with A2TUI"
-requires-python = ">=3.14.2"
-dependencies = [
-    "textual>=0.46.0",
-    "textual[syntax]==8.2.6",
-    "click==8.4.0",
-    "platformdirs==4.9.6",
-    "rich>=13.7.0",
-    "rich==15.0.0",
-    "pydantic>=2.5.0",
-    "pyyaml>=6.0",
-    "click>=8.1.0",
-    "python-dotenv>=1.0.0",
-    "sqlalchemy>=2.0.0",
-    "sqlite-utils>=3.35",
-    "httpx>=0.25.0",
-    "typeguard==4.5.2",
-    "xdg-base-dirs>=6.0.2",
-    "textual-serve>=1.1.2",
-    "textual-speedups==0.2.1",
-    "packaging==26.2",
-    "bashlex==0.18",
-    "pathspec==1.1.1",
-    "notify-py==0.3.43",
-    "pyperclip==1.11.0",
-    "watchdog==6.0.0",
-    "setproctitle==1.3.7",
-    "psutil==7.2.2",
-    "aiosqlite==0.22.1",
-    "textual-diff-view==0.1.5",
-    "typing-extensions==4.15.0",
-]
-
-[project.scripts]
-cdh = "cdh.cli:main"
-onecode-agent-acp = "onecode.agent.onecode_agent_acp:main"
-onecode = "onecode.cli:main"
-tui = "tui.cli:main"
-
-[build-system]
-requires = ["setuptools>=68.0"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools.packages.find]
-include = ["onecode*", "cdh*", "tui*"]
-
-[tool.setuptools.package-data]
-tui = [
-    "tui.tcss",
-    "screens/*.tcss",
-    "data/**/*",
-]
-onecode = [
-    "builtin_skills/**/*",
-]
-
-[tool.ruff]
-exclude = ["tui/", "dist/", ".venv/"]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
-
-[dependency-groups]
-dev = [
-    "mypy>=1.19.1",
-    "pyinstrument>=5.1.1",
-    "pytest>=9.0.3",
-    "pytest-asyncio>=1.4.0",
-    "pytest-cov>=6.0.0",
-    "textual-dev>=1.8.0",
-]

package/tui/__init__.py

@@ -1,46 +0,0 @@
-from typing import Literal
-import platform
-
-NAME = "tui"
-TITLE = "A2TUI"
-
-OS = Literal["linux", "macos", "windows", "*"]
-
-_system = platform.system()
-_OS_map: dict[str, OS] = {
-    "Linux": "linux",
-    "Darwin": "macos",
-    "Windows": "windows",
-}
-os: OS = _OS_map.get(_system, "linux")
-
-
-def get_os_matrix(matrix: dict[OS, str]) -> str | None:
-    """Get a value from a mapping where the key is an OS, falling back to a wildcard ("*").
-
-    Args:
-        matrix: A mapping where an OS literal is the key.
-
-    Returns:
-        The value, if one is found, or `None`.
-    """
-    if (result := matrix.get(os)) is None:
-        result = matrix.get("*")
-    return result
-
-
-def get_version() -> str:
-    """Get the current version of A2TUI.
-
-    Returns:
-        str: Version string, e.g "1.2.3"
-    """
-    from importlib.metadata import version
-
-    try:
-        return version("batrachian-tui")
-    except Exception:
-        try:
-            return version("tui")
-        except Exception:
-            return "0.1.0unknown"

package/tui/__main__.py

@@ -1,4 +0,0 @@
-from tui.cli import main
-
-if __name__ == "__main__":
-    main()

package/tui/_loop.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterable, Literal, Sequence, TypeVar
-
-T = TypeVar("T")
-
-
-def loop_first(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
-    """Iterate and generate a tuple with a flag for first value."""
-    iter_values = iter(values)
-    try:
-        value = next(iter_values)
-    except StopIteration:
-        return
-    yield True, value
-    for value in iter_values:
-        yield False, value
-
-
-def loop_last(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
-    """Iterate and generate a tuple with a flag for last value."""
-    iter_values = iter(values)
-    try:
-        previous_value = next(iter_values)
-    except StopIteration:
-        return
-    for value in iter_values:
-        yield False, previous_value
-        previous_value = value
-    yield True, previous_value
-
-
-def loop_first_last(values: Iterable[T]) -> Iterable[tuple[bool, bool, T]]:
-    """Iterate and generate a tuple with a flag for first and last value."""
-    iter_values = iter(values)
-    try:
-        previous_value = next(iter_values)
-    except StopIteration:
-        return
-    first = True
-    for value in iter_values:
-        yield first, False, previous_value
-        first = False
-        previous_value = value
-    yield first, True, previous_value
-
-
-def loop_from_index(
-    values: Sequence[T],
-    index: int,
-    direction: Literal[-1, +1] = +1,
-    wrap: bool = True,
-) -> Iterable[tuple[int, T]]:
-    """Iterate over values in a sequence from a given starting index, potentially wrapping the index
-    if it would go out of bounds.
-
-    Note that the first value to be yielded is a step from `index`, and `index` will be yielded *last*.
-
-
-    Args:
-        values: A sequence of values.
-        index: Starting index.
-        direction: Direction to move index (+1 for forward, -1 for backward).
-        bool: Should the index wrap when out of bounds?
-
-    Yields:
-        A tuple of index and value from the sequence.
-    """
-    # Sanity check for devs who miss the typing errors
-    assert direction in (-1, +1), "direction must be -1 or +1"
-    count = len(values)
-    if wrap:
-        for _ in range(count):
-            index = (index + direction) % count
-            yield (index, values[index])
-    else:
-        if direction == +1:
-            for _ in range(count):
-                if (index := index + 1) >= count:
-                    break
-                yield (index, values[index])
-        else:
-            for _ in range(count):
-                if (index := index - 1) < 0:
-                    break
-                yield (index, values[index])

package/tui/_path_fuzzy_search.py

@@ -1,48 +0,0 @@
-from functools import lru_cache
-from typing import Sequence
-import re
-
-
-from tui.fuzzy import FuzzySearch
-
-
-class PathFuzzySearch(FuzzySearch):
-    @classmethod
-    @lru_cache(maxsize=1024)
-    def get_first_letters(cls, candidate: str) -> frozenset[int]:
-        return frozenset(
-            {
-                0,
-                *[match.start() + 1 for match in re.finditer(r"/", candidate)],
-            }
-        )
-
-    def score(self, candidate: str, positions: Sequence[int]) -> float:
-        """Score a search.
-
-        Args:
-            search: Search object.
-
-        Returns:
-            Score.
-        """
-        first_letters = self.get_first_letters(candidate)
-        # This is a heuristic, and can be tweaked for better results
-        # Boost first letter matches
-        offset_count = len(positions)
-        score: float = offset_count + len(first_letters.intersection(positions))
-
-        groups = 1
-        last_offset, *offsets = positions
-        for offset in offsets:
-            if offset != last_offset + 1:
-                groups += 1
-            last_offset = offset
-
-        # Boost to favor less groups
-        normalized_groups = (offset_count - (groups - 1)) / offset_count
-        score *= 1 + (normalized_groups * normalized_groups)
-
-        if positions[0] > candidate.rfind("/"):
-            score *= 2
-        return score