@scemoon/cdh 1.0.9 → 1.0.10-beta.1

package/onecode/verification/gates/type_gate.py

@@ -1,46 +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 TypeGate(Gate):
-    name = "type"
-    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(
-                "mypy", 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()
-            passed = proc.returncode == 0
-            return GateResult(
-                name=self.name,
-                status="passed" if passed else "failed",
-                exit_code=proc.returncode,
-                duration_ms=duration,
-                summary=out[:500],
-            )
-        except FileNotFoundError:
-            return GateResult(
-                name=self.name,
-                status="skipped",
-                summary="mypy not found in PATH",
-            )

package/onecode/verification/loop.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-import logging
-from enum import Enum
-
-from onecode.agent.turn_record import TurnRecord
-from onecode.verification.policy import VerificationPolicy
-from onecode.verification.aggregation import AggregateResult, GateResult
-from onecode.verification.gates.base import Gate
-
-logger = logging.getLogger("onecode.verification.loop")
-
-
-class VerificationState(Enum):
-    IDLE = "idle"
-    RUNNING = "running"
-    PAUSED = "paused"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class VerificationLoop:
-    def __init__(self, policy: str = "conditional"):
-        self.state = VerificationState.IDLE
-        self.policy = VerificationPolicy.from_str(policy)
-        self._gates: dict[str, Gate] = {}
-
-    @property
-    def enabled(self) -> bool:
-        return self.state is not VerificationState.IDLE
-
-    @property
-    def gates(self) -> list[Gate]:
-        return list(self._gates.values())
-
-    def register_gate(self, gate: Gate) -> None:
-        self._gates[gate.name] = gate
-
-    def unregister_gate(self, name: str) -> None:
-        self._gates.pop(name, None)
-
-    def activate(self) -> None:
-        self.state = VerificationState.RUNNING
-
-    def pause(self) -> None:
-        self.state = VerificationState.PAUSED
-
-    def resume(self) -> None:
-        self.state = VerificationState.RUNNING
-
-    def should_verify(self, tool_name: str) -> bool:
-        if self.state != VerificationState.RUNNING:
-            return False
-        return self.policy.should_verify(tool_name)
-
-    def should_final_verify(self) -> bool:
-        if self.state != VerificationState.RUNNING:
-            return False
-        return self.policy.should_final_verify()
-
-    async def run_gates(self, turn_record: TurnRecord) -> AggregateResult:
-        results: dict[str, GateResult] = {}
-        for name, gate in self._gates.items():
-            if not gate.enabled:
-                continue
-            if not gate.should_run(turn_record.tool_name, turn_record.tool_output):
-                continue
-            try:
-                result = await gate.run(turn_record)
-            except Exception as e:
-                logger.warning("Gate %s failed: %s", name, e)
-                result = GateResult(name=name, status="failed", summary=str(e))
-            results[name] = result
-
-        aggregated = AggregateResult(gate_results=results)
-        return aggregated
-
-    async def run_all_final_gates(self) -> AggregateResult:
-        results: dict[str, GateResult] = {}
-        for name, gate in self._gates.items():
-            if not gate.enabled:
-                continue
-            try:
-                result = await gate.run(TurnRecord(
-                    turn_number=-1, thought="", tool_name="__final__", tool_output=None,
-                ))
-            except Exception as exc:
-                logger.warning("Final gate %s failed: %s", name, exc)
-                result = GateResult(name=name, status="failed", summary=str(exc))
-            results[name] = result
-
-        aggregated = AggregateResult(gate_results=results)
-        if aggregated.failed:
-            self.state = VerificationState.FAILED
-        return aggregated

package/onecode/verification/policy.py

@@ -1,29 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-
-
-class VerificationPolicy(Enum):
-    EVERY_STEP = "every_step"
-    FINAL_ONLY = "final_only"
-    CONDITIONAL = "conditional"
-
-    @classmethod
-    def from_str(cls, value: str) -> VerificationPolicy:
-        for member in cls:
-            if member.value == value:
-                return member
-        return cls.CONDITIONAL
-
-    def should_verify(self, tool_name: str) -> bool:
-        if self == VerificationPolicy.EVERY_STEP:
-            return True
-        if self == VerificationPolicy.FINAL_ONLY:
-            return False
-        if self == VerificationPolicy.CONDITIONAL:
-            write_tools = {"WriteTool", "EditTool", "InsertTool", "ApplyPatchTool", "BashTool"}
-            return tool_name in write_tools
-        return False
-
-    def should_final_verify(self) -> bool:
-        return self in (VerificationPolicy.FINAL_ONLY, VerificationPolicy.CONDITIONAL)

package/pyproject.toml

@@ -1,84 +0,0 @@
-[project]
-name = "cloud-dev-harness"
-version = "1.0.9"
-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-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",
-    "agenttrace>=0.1.2",
-    "tencentcloud-sdk-python>=3.0.0",
-    "starlette>=0.40.0",
-    "uvicorn[standard]>=0.30.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/**/*",
-    "agent/agents/prompts/**/*",
-]
-cdh = [
-    "generators/**/*.toml",
-    "generators/**/*.tmpl",
-]
-
-[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-bdd>=8.0.0",
-    "pytest-cov>=6.0.0",
-    "ruff>=0.15.21",
-    "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