@scemoon/cdh 1.0.6 → 1.0.8

package/tui/version.py

@@ -1,80 +0,0 @@
-from typing import NamedTuple
-
-
-VERSION_TOML_URL = "https://www.batrachian.ai/tui.toml"
-
-
-class VersionMeta(NamedTuple):
-    """Information about the current version of A2TUI."""
-
-    version: str
-    upgrade_message: str
-    visit_url: str
-
-
-class VersionCheckFailed(Exception):
-    """Something went wrong in the version check."""
-
-
-async def check_version() -> tuple[bool, VersionMeta]:
-    """Check for a new version of A2TUI.
-
-    Returns:
-        A tuple containing a boolean that indicates if there is a newer version,
-            and a `VersionMeta` structure with meta information.
-    """
-    import httpx
-    import packaging.version
-    import tomllib
-
-    from tui import get_version
-
-    try:
-        current_version = packaging.version.parse(get_version())
-    except packaging.version.InvalidVersion as error:
-        raise VersionCheckFailed(f"Invalid version;{error}")
-
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.get(VERSION_TOML_URL)
-            version_toml_bytes = await response.aread()
-    except Exception as error:
-        raise VersionCheckFailed(f"Failed to retrieve version;{error}")
-
-    try:
-        version_toml = version_toml_bytes.decode("utf-8", "replace")
-        version_meta = tomllib.loads(version_toml)
-    except Exception as error:
-        raise VersionCheckFailed(f"Failed to decode version TOML;{error}")
-
-    if not isinstance(version_meta, dict):
-        raise VersionCheckFailed("Response isn't TOML")
-
-    toad_version = str(version_meta.get("version", "0"))
-    version_message = str(version_meta.get("upgrade_message", ""))
-    version_message = version_message.replace("$VERSION", toad_version)
-    verison_meta = VersionMeta(
-        version=toad_version,
-        upgrade_message=version_message,
-        visit_url=str(version_meta.get("visit_url", "")),
-    )
-
-    try:
-        new_version = packaging.version.parse(verison_meta.version)
-    except packaging.version.InvalidVersion as error:
-        raise VersionCheckFailed(f"Invalid remote version;{error}")
-
-    return new_version > current_version, verison_meta
-
-
-if __name__ == "__main__":
-
-    async def run() -> None:
-        result = await check_version()
-        from rich import print
-
-        print(result)
-
-    import asyncio
-
-    asyncio.run(run())

package/tui/visuals/columns.py

@@ -1,272 +0,0 @@
-from __future__ import annotations
-
-from typing import Iterator, Literal
-from fractions import Fraction
-
-import rich.repr
-from rich.segment import Segment
-
-from textual.cache import LRUCache
-from textual.content import Content
-from textual.css.styles import RulesMap
-from textual.visual import Visual, RenderOptions
-from textual.strip import Strip
-from textual.style import Style
-
-from tui._loop import loop_last
-
-
-
-
-@rich.repr.auto
-class Row(Visual):
-    """A visual for a row produced by `columns`.
-
-    No need to construct these manually, they are returned from the Columns `__getindex__`
-
-    """
-
-    def __init__(self, columns: Columns, row_index: int) -> None:
-        """
-
-        Args:
-            columns: The parent Columns instance.
-            row_index: Index of the row within columns.
-        """
-        self.columns = columns
-        self.row_index = row_index
-
-    def __rich_repr__(self) -> rich.repr.Result:
-        yield self.columns
-        yield self.row_index
-
-    def render_strips(
-        self, width: int, height: int | None, style: Style, options: RenderOptions
-    ) -> list[Strip]:
-        strips = self.columns.render(self.row_index, width, style)
-        return strips
-
-    def get_optimal_width(self, rules: RulesMap, container_width: int) -> int:
-        return min(container_width, self.columns.get_optimal_width())
-
-    def get_height(self, rules: RulesMap, width: int) -> int:
-        return self.columns.get_row_height(width, self.row_index)
-
-
-@rich.repr.auto
-class Columns:
-    """Renders columns of Content."""
-
-    def __init__(
-        self,
-        *columns: Literal["auto", "flex"],
-        gutter: int = 1,
-        style: Style | str = "",
-    ) -> None:
-        """
-
-        Args:
-            *columns: "auto" to use the maximum width of the cells in a column,
-                or "flex" to use the remaining space.
-            gutter: Space between columns in cells.
-            style: Base style for the columns.
-        """
-        self.columns = columns
-        self.gutter = gutter
-        self.style = style
-        self.rows: list[list[Content]] = []
-        self._render_cache: LRUCache[tuple, list[list[Strip]]] = LRUCache(maxsize=64)
-        self._optimal_width_cache: int | None = None
-
-    def __rich_repr__(self) -> rich.repr.Result:
-        for column in self.columns:
-            yield column
-        yield "gutter", self.gutter, 1
-        yield "style", self.style, ""
-
-    def __getitem__(self, row_index: int) -> Row:
-        if row_index < 0:
-            row_index = len(self.rows) - row_index
-        if row_index >= len(self.rows):
-            raise IndexError(f"No row with index {row_index}")
-        return Row(self, row_index)
-
-    def __len__(self) -> int:
-        return len(self.rows)
-
-    def __iter__(self) -> Iterator[Row]:
-        return iter([self[row_index] for row_index in range(len(self))])
-
-    def get_optimal_width(self) -> int:
-        """Get optional width (Visual protocol).
-
-        Returns:
-            Width in cells.
-        """
-        if self._optimal_width_cache is not None:
-            return self._optimal_width_cache
-        gutter_width = (len(self.columns) - 1) * self.gutter
-        optimal_width = max(
-            sum(content.cell_length for content in row) + gutter_width
-            for row in self.rows
-        )
-        self._optimal_width_cache = optimal_width
-        return optimal_width
-
-    def get_row_height(self, width: int, row_index: int) -> int:
-        """Get the height of a row when rendered with the given width.
-
-        Args:
-            width: Available width.
-            row_index: Index of the row.
-
-        Returns:
-            Height in lines of the row.
-        """
-        if self._last_render is None:
-            row_strips = self._render(width, Style.null())
-        else:
-            row_strips = self._last_render
-        return len(row_strips[row_index])
-
-    def add_row(self, *cells: Content | str) -> Row:
-        """Add a row.
-
-        Args:
-            *cells: Cell content.
-
-        Returns:
-            A Row renderable.
-
-        """
-        assert len(cells) == len(self.columns)
-        new_cells = [
-            cell if isinstance(cell, Content) else Content(cell) for cell in cells
-        ]
-        self.rows.append(new_cells)
-        self._optimal_width_cache = None
-        self._last_render = None
-        self._render_cache.clear()
-        return Row(self, len(self.rows) - 1)
-
-    def render(
-        self, row_index: int, render_width: int, style: Style = Style.null()
-    ) -> list[Strip]:
-        """render a row given by its index.
-
-        Args:
-            row_index: Index of the row.
-            render_width: Width of the render.
-            style: Base style to render.
-
-        Returns:
-            A list of strips, which may be returned from a visual.
-        """
-        row_strips = self._render(render_width, style)
-        return row_strips[row_index]
-
-    def _render(self, render_width: int, style: Style) -> list[list[Strip]]:
-        """Render a row.
-
-        Args:
-            render_width: Width of render.
-            style: Base Style.
-
-        Returns:
-            A list of list of Strips (one list of strips per row).
-        """
-
-        cache_key = (render_width, style)
-        if (cached_render := self._render_cache.get(cache_key)) is not None:
-            return cached_render
-
-        gutter_width = (len(self.columns) - 1) * self.gutter
-        widths: list[int | None] = []
-
-        for index, column in enumerate(self.columns):
-            if column == "auto":
-                widths.append(max(row[index].cell_length for row in self.rows))
-            else:
-                widths.append(None)
-
-        if any(width is None for width in widths):
-            used_width = sum(width for width in widths if width is not None)
-            remaining_width = Fraction(render_width - gutter_width - used_width)
-            if remaining_width <= 0:
-                widths = [width or 0 for width in widths]
-            else:
-                remaining_count = sum(1 for width in widths if width is None)
-                cell_width = remaining_width / remaining_count
-
-                distribute: list[int] = []
-                previous_width = 0
-                total = Fraction(0)
-                for _ in range(remaining_count):
-                    total += cell_width
-                    distribute.append(int(total) - previous_width)
-                    previous_width = int(total)
-
-                iter_distribute = iter(distribute)
-                for index, column_width in enumerate(widths.copy()):
-                    if column_width is None:
-                        widths[index] = int(next(iter_distribute))
-
-        row_strips: list[list[Strip]] = []
-
-        for row in self.rows:
-            column_renders: list[list[list[Segment]]] = []
-            for content_width, content in zip(widths, row):
-                assert content_width is not None
-                segments = [
-                    line.truncate(content_width, pad=True).render_segments(style)
-                    for line in content.wrap(content_width)
-                ]
-
-                column_renders.append(segments)
-
-            height = max(len(lines) for lines in column_renders)
-            rich_style = style.rich_style
-            for width, lines in zip(widths, column_renders):
-                assert width is not None
-                while len(lines) < height:
-                    lines.append([Segment(" " * width, rich_style)])
-
-            gutter = Segment(" " * self.gutter, rich_style)
-            strips: list[Strip] = []
-            for line_no in range(height):
-                strip_segments: list[Segment] = []
-                for last, column in loop_last(column_renders):
-                    strip_segments.extend(column[line_no])
-                    if not last and gutter:
-                        strip_segments.append(gutter)
-                strips.append(Strip(strip_segments, render_width))
-
-            row_strips.append(strips)
-
-        self._render_cache[cache_key] = row_strips
-        return row_strips
-
-
-if __name__ == "__main__":
-    from rich import traceback
-
-    traceback.install(show_locals=True)
-
-    from textual.app import App, ComposeResult
-    from textual.widgets import Static
-
-    columns = Columns("auto", "flex")
-    columns.add_row("Foo", "Hello, World! " * 20)
-
-    class CApp(App):
-        DEFAULT_CSS = """
-        .row1 {
-            background: blue;
-           
-        }
-        """
-
-        def compose(self) -> ComposeResult:
-            yield Static(columns[0], classes="row1")
-
-    CApp().run()

package/tui/widgets/acp_content.py

@@ -1,70 +0,0 @@
-from textual import containers
-from textual.app import ComposeResult
-from textual import widgets
-from tui.acp.protocol import ToolCallContent
-
-
-_WRITE_ICON = "✏️ "
-
-
-def _header_path(content_blocks: list[ToolCallContent]) -> str:
-    """Extract filename from content blocks for use in the permission header."""
-    for block in content_blocks:
-        text = ""
-        match block:
-            case {"type": "content", "content": {"type": "text", "text": t}}:
-                text = t
-            case {"type": "resource", "resource": {"uri": uri}}:
-                return uri.rsplit("/", 1)[-1] if "/" in uri else uri
-            case {"type": "diff", "path": path}:
-                return path
-        if text:
-            for line in text.splitlines():
-                line = line.strip()
-                if line.startswith("📄 "):
-                    return line[2:].strip()
-    return ""
-
-
-class ACPToolCallContent(containers.VerticalGroup):
-
-    def __init__(
-        self,
-        content: list[ToolCallContent],
-        *,
-        id: str | None = None,
-        classes: str | None = None,
-    ) -> None:
-        self._content = content
-        super().__init__(id=id, classes=classes)
-
-    def compose(self) -> ComposeResult:
-        for content in self._content:
-            match content:
-                case {
-                    "type": "content",
-                    "content": {
-                        "type": "text",
-                        "text": text,
-                    },
-                }:
-                    yield widgets.Markdown(text)
-                case {
-                    "type": "diff",
-                    "oldText": old_text,
-                    "newText": new_text,
-                    "path": path,
-                }:
-                    from tui.widgets.diff_view import make_diff
-
-                    yield make_diff(path, path, old_text, new_text)
-                case {"type": "resource", "resource": res}:
-                    text = res.get("text", "") or res.get("blob", "") or ""
-                    mime = res.get("mimeType", "")
-                    if text:
-                        yield widgets.Markdown(f"```\n{text}\n```")
-                case {"type": "text", "text": text}:
-                    yield widgets.Markdown(text)
-                case _:
-                    import json
-                    yield widgets.Static(json.dumps(content, indent=2, ensure_ascii=False))

package/tui/widgets/agent_response.py

@@ -1,76 +0,0 @@
-from textual.reactive import var
-from textual.widget import Widget
-from textual.widgets.markdown import MarkdownStream
-
-from tui.conversation_markdown import ConversationMarkdown
-
-
-SYSTEM = """\
-If asked to output code add inline documentation in the google style format, and always use type hinting where appropriate.
-Avoid using external libraries where possible, and favor code that writes output to the terminal.
-When asked for a table do not wrap it in a code fence.
-"""
-
-
-class AgentResponse(ConversationMarkdown):
-    DEFAULT_CLASSES = "block"
-    block_cursor_offset = var(-1)
-
-    def __init__(self, markdown: str | None = None) -> None:
-        super().__init__(markdown)
-        self._stream: MarkdownStream | None = None
-
-    def block_cursor_clear(self) -> None:
-        self.block_cursor_offset = -1
-
-    def block_cursor_up(self) -> Widget | None:
-        if self.block_cursor_offset == -1:
-            if self.children:
-                self.block_cursor_offset = len(self.children) - 1
-            else:
-                return None
-        else:
-            self.block_cursor_offset -= 1
-
-        if self.block_cursor_offset == -1:
-            return None
-        try:
-            return self.children[self.block_cursor_offset]
-        except IndexError:
-            self.block_cursor_offset = -1
-            return None
-
-    def block_cursor_down(self) -> Widget | None:
-        if self.block_cursor_offset == -1:
-            if self.children:
-                self.block_cursor_offset = 0
-            else:
-                return None
-        else:
-            self.block_cursor_offset += 1
-        if self.block_cursor_offset >= len(self.children):
-            self.block_cursor_offset = -1
-            return None
-        try:
-            return self.children[self.block_cursor_offset]
-        except IndexError:
-            self.block_cursor_offset = -1
-            return None
-
-    def get_cursor_block(self) -> Widget | None:
-        if self.block_cursor_offset == -1:
-            return None
-        return self.children[self.block_cursor_offset]
-
-    def block_select(self, widget: Widget) -> None:
-        self.block_cursor_offset = self.children.index(widget)
-
-    @property
-    def stream(self) -> MarkdownStream:
-        if self._stream is None:
-            self._stream = self.get_stream(self)
-        return self._stream
-
-    async def append_fragment(self, fragment: str) -> None:
-        self.loading = False
-        await self.stream.write(fragment)