@scemoon/cdh 1.0.8 → 1.0.9-beta.2

package/onecode/verification/gates/type_gate.py

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

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

@@ -0,0 +1,29 @@
+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/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@scemoon/cdh",
-  "version": "1.0.8",
+  "version": "1.0.9-beta.2",
   "description": "Cloud Dev Harness - cloud-native development Agent framework",
-  "keywords": ["ai", "agent", "cloud", "development", "cli", "cdc"],
+  "keywords": ["ai", "agent", "cloud", "development", "cli", "tui"],
   "license": "MIT",
   "repository": {
     "type": "git",

package/pyproject.toml

@@ -0,0 +1,84 @@
+[project]
+name = "cloud-dev-harness"
+version = "1.0.7"
+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

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

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

package/tui/_loop.py

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

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