configui 1.0.0__py3-none-any.whl

configui/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

configui/__init__.py

@@ -0,0 +1,3 @@
+from configui.__about__ import __version__
+
+__all__ = ["__version__"]

configui/__main__.py

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

configui/config/__init__.py

@@ -0,0 +1,7 @@
+from configui.config._protocol import Config
+from configui.config.formats import SupportedConfigFormat
+from configui.config.json_config import JsonConfig
+from configui.config.toml_config import TomlConfig
+from configui.config.yaml_config import YamlConfig
+
+__all__ = ["Config", "JsonConfig", "SupportedConfigFormat", "TomlConfig", "YamlConfig"]

configui/config/_atomic.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import os
+import tempfile
+from contextlib import suppress
+from pathlib import Path
+from typing import IO, TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, MutableMapping
+
+_ALLOW_NEW_KEYS: bool = os.environ.get("CONFIGUI_UPDATE_ALLOW_NEW_KEYS", "0") == "1"
+_ALLOW_MISSING_KEYS: bool = os.environ.get("CONFIGUI_UPDATE_ALLOW_MISSING_KEYS", "1") == "1"
+
+
+def atomic_update(
+    data: MutableMapping,
+    updates: dict[str, Any],
+    *,
+    allow_new_keys: bool,
+    allow_missing_keys: bool,
+) -> None:
+    if not allow_new_keys:
+        extra = updates.keys() - data.keys()
+        if extra:
+            msg = f"Keys not found in config: {sorted(extra)}"
+            raise KeyError(msg)
+    if not allow_missing_keys:
+        missing = data.keys() - updates.keys()
+        if missing:
+            msg = f"Missing keys in update: {sorted(missing)}"
+            raise KeyError(msg)
+    for k, v in updates.items():
+        data[k] = v
+
+
+def atomic_write(path: Path, writer: Callable[[IO[str]], None]) -> None:
+    path = Path(path)
+    fd, tmp_path = tempfile.mkstemp(suffix=".tmp", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w") as f:
+            writer(f)
+        os.replace(tmp_path, path)
+    except BaseException as e:
+        msg = f"Failed to save config to '{path}'"
+        raise RuntimeError(msg) from e
+    finally:
+        with suppress(BaseException):
+            os.unlink(tmp_path)

configui/config/_protocol.py

@@ -0,0 +1,18 @@
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, Protocol
+
+
+class Config(Protocol):
+    _data: Mapping
+    _path: Path
+
+    def load(self, **kwargs: Any) -> None: ...
+
+    def save(self, **kwargs: Any) -> None: ...
+
+    def save_as(self, new_path: Path, **kwargs: Any) -> None: ...
+
+    def update(
+        self, data: dict[str, Any], *, allow_new_keys: bool | None = None, allow_missing_keys: bool | None = None
+    ) -> None: ...

configui/config/formats.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from enum import StrEnum, auto
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from configui.config._protocol import Config
+
+from configui.config.json_config import JsonConfig
+from configui.config.toml_config import TomlConfig
+from configui.config.yaml_config import YamlConfig
+
+_YAML_ALIASES: set[str] = {"yml", "yaml"}
+
+
+class SupportedConfigFormat(StrEnum):
+    JSON = auto()
+    YAML = auto()
+    TOML = auto()
+
+    @classmethod
+    def from_filename(cls, filename: str) -> SupportedConfigFormat:
+        ext = Path(filename).suffix.lstrip(".").lower()
+        if ext in _YAML_ALIASES:
+            ext = "yaml"
+        return cls(ext)
+
+    def get_config_cls(self) -> type[Config]:
+        return _CONFIG_CLASSES[self]
+
+
+_CONFIG_CLASSES: dict[SupportedConfigFormat, type[Config]] = {
+    SupportedConfigFormat.JSON: JsonConfig,
+    SupportedConfigFormat.YAML: YamlConfig,
+    SupportedConfigFormat.TOML: TomlConfig,
+}

configui/config/json_config.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from configui.config._atomic import _ALLOW_MISSING_KEYS, _ALLOW_NEW_KEYS, atomic_update, atomic_write
+from configui.config._protocol import Config
+
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+
+class JsonConfig(Config):
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path)
+        self._data: MutableMapping[str, Any] = {}
+
+    def load(self, **kwargs: Any) -> None:
+        try:
+            self._data = json.loads(self._path.read_text(**kwargs))
+        except json.JSONDecodeError as e:
+            msg = f"Failed to parse JSON file '{self._path}': {e}"
+            raise ValueError(msg) from e
+
+    def save(self, **kwargs: Any) -> None:
+        atomic_write(self._path, lambda f: json.dump(self._data, f, indent=2, ensure_ascii=False, **kwargs))
+
+    def save_as(self, new_path: Path, **kwargs: Any) -> None:
+        atomic_write(new_path, lambda f: json.dump(self._data, f, indent=2, ensure_ascii=False, **kwargs))
+
+    def update(
+        self, data: dict[str, Any], *, allow_new_keys: bool | None = None, allow_missing_keys: bool | None = None
+    ) -> None:
+        _allow_new = allow_new_keys if allow_new_keys is not None else _ALLOW_NEW_KEYS
+        _allow_missing = allow_missing_keys if allow_missing_keys is not None else _ALLOW_MISSING_KEYS
+        atomic_update(self._data, data, allow_new_keys=_allow_new, allow_missing_keys=_allow_missing)

configui/config/toml_config.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import tomlkit
+from tomlkit.exceptions import TOMLKitError
+
+from configui.config._atomic import _ALLOW_MISSING_KEYS, _ALLOW_NEW_KEYS, atomic_update, atomic_write
+from configui.config._protocol import Config
+
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+
+class TomlConfig(Config):
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path)
+        self._data: MutableMapping[str, Any] = {}
+
+    def load(self, **kwargs: Any) -> None:
+        try:
+            self._data = tomlkit.parse(self._path.read_text(**kwargs))
+        except TOMLKitError as e:
+            msg = f"Failed to parse TOML file '{self._path}': {e}"
+            raise ValueError(msg) from e
+
+    def save(self, **_kwargs: Any) -> None:
+        atomic_write(self._path, lambda f: tomlkit.dump(self._data, f))
+
+    def save_as(self, new_path: Path, **_kwargs: Any) -> None:
+        atomic_write(new_path, lambda f: tomlkit.dump(self._data, f))
+
+    def update(
+        self, data: dict[str, Any], *, allow_new_keys: bool | None = None, allow_missing_keys: bool | None = None
+    ) -> None:
+        _allow_new = allow_new_keys if allow_new_keys is not None else _ALLOW_NEW_KEYS
+        _allow_missing = allow_missing_keys if allow_missing_keys is not None else _ALLOW_MISSING_KEYS
+        atomic_update(self._data, data, allow_new_keys=_allow_new, allow_missing_keys=_allow_missing)

configui/config/yaml_config.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ruamel.yaml import YAML
+from ruamel.yaml.error import YAMLError
+
+from configui.config._atomic import _ALLOW_MISSING_KEYS, _ALLOW_NEW_KEYS, atomic_update, atomic_write
+from configui.config._protocol import Config
+
+if TYPE_CHECKING:
+    from collections.abc import MutableMapping
+
+
+class YamlConfig(Config):
+    def __init__(self, path: str | Path, yaml_type: str = "rt") -> None:
+        """Initialize YamlConfig.
+
+        Args:
+            path: Path to the YAML file.
+            yaml_type: ruamel.yaml round-trip mode — ``"rt"`` preserves
+                comments, anchors, aliases, and key ordering on load/edit/save.
+        """
+        self._path = Path(path)
+        self._data: MutableMapping[str, Any] = {}
+        self._yaml = YAML(typ=yaml_type)
+
+    def load(self, **kwargs: Any) -> None:
+        try:
+            self._data = self._yaml.load(self._path.read_text(**kwargs))
+        except YAMLError as e:
+            msg = f"Failed to parse YAML file '{self._path}': {e}"
+            raise ValueError(msg) from e
+
+    def save(self, **_kwargs: Any) -> None:
+        atomic_write(self._path, lambda f: self._yaml.dump(self._data, f))
+
+    def save_as(self, new_path: Path, **_kwargs: Any) -> None:
+        atomic_write(new_path, lambda f: self._yaml.dump(self._data, f))
+
+    def update(
+        self, data: dict[str, Any], *, allow_new_keys: bool | None = None, allow_missing_keys: bool | None = None
+    ) -> None:
+        _allow_new = allow_new_keys if allow_new_keys is not None else _ALLOW_NEW_KEYS
+        _allow_missing = allow_missing_keys if allow_missing_keys is not None else _ALLOW_MISSING_KEYS
+        atomic_update(self._data, data, allow_new_keys=_allow_new, allow_missing_keys=_allow_missing)

configui/tui/app.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import asyncio
+from copy import deepcopy
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, cast
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Collapsible, Footer, Header, Input, Switch, Tree
+
+from configui.config import SupportedConfigFormat
+from configui.tui.collector import map_widgets_to_config
+from configui.tui.screens import ConfirmExitScreen, ResetConfirmScreen, SaveAsScreen
+from configui.tui.widgets import map_config_to_widgets
+
+if TYPE_CHECKING:
+    from textual.widgets.tree import TreeNode
+
+_MOUNT_SETTLE_YIELDS: int = 100
+
+
+class ConfigUIApp(App[None]):
+    TITLE = "ConfigUI"
+
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 1 3;
+        grid-rows: auto 1fr auto;
+    }
+
+    #main-container {
+        layout: horizontal;
+    }
+
+    #sidebar-tree {
+        dock: left;
+        width: 30%;
+        min-width: 30;
+        max-width: 50;
+        border: round $primary;
+        overflow-y: auto;
+        margin: 0 0 0 1;
+    }
+
+    #sidebar-tree:focus-within {
+        border: round $primary;
+    }
+
+    #main-content {
+        width: 1fr;
+        height: 1fr;
+        border: round $primary;
+        overflow-y: auto;
+        padding: 1 2;
+        margin: 0 1;
+    }
+
+    #main-content:focus-within {
+        border: round $primary;
+    }
+
+    .scalar-row {
+        height: auto;
+        margin: 0 0 1 0;
+    }
+
+    .scalar-label {
+        width: auto;
+        height: 3;
+        padding: 0 1 0 0;
+        color: $text;
+        text-style: bold;
+        content-align: left middle;
+    }
+
+    .scalar-input {
+        width: 1fr;
+        height: 3;
+    }
+
+    Input.scalar-input {
+        background: $surface;
+        border: round $primary;
+    }
+
+    Input.scalar-input:focus {
+        background: $surface;
+        border: round $primary;
+    }
+
+    Switch.scalar-input {
+        width: auto;
+        height: 3;
+        border: round $primary;
+    }
+
+    Switch.scalar-input:focus {
+        border: round $primary;
+    }
+
+    .reset-btn {
+        width: auto;
+        height: 3;
+        min-width: 3;
+        margin: 0 0 0 1;
+        background: transparent;
+        border: none;
+        color: $text;
+    }
+
+    .reset-btn:hover {
+        color: $primary;
+    }
+
+    .content-wrapper {
+        height: auto;
+    }
+
+    Collapsible > .container-dict,
+    Collapsible > .container-list {
+        margin: 0 0 0 1;
+    }
+
+    Tree {
+        padding: 0 1;
+    }
+    """
+
+    BINDINGS: ClassVar[list[Binding]] = [  # type: ignore[assignment]
+        Binding("ctrl+s", "save", "Save", priority=True),
+        Binding("ctrl+shift+s", "save_as", "Save As", priority=True),
+        Binding("ctrl+r", "reset_all", "Reset All", priority=True),
+        Binding("ctrl+q", "quit", "Quit", priority=True),
+    ]
+
+    def __init__(self, path: str, *, read_only: bool = False) -> None:
+        super().__init__()
+        self._filepath = Path(path)
+        self._read_only = read_only
+        self._dirty = False
+        self._config = None
+        self._original_data: dict[str, Any] = {}
+        self._tree_nodes: dict[str, TreeNode] = {}
+        self._header: Header | None = None
+        self._mount_phase = True
+
+    def _load_config(self):
+        fmt = SupportedConfigFormat.from_filename(self._filepath.name)
+        config = fmt.get_config_cls()(self._filepath)
+        config.load()
+        return config
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        with Horizontal(id="main-container"):
+            yield Tree("config", id="sidebar-tree")
+            yield Vertical(id="main-content")
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        self._config = self._load_config()
+        data: dict[str, Any] = cast("dict[str, Any]", self._config._data)  # type: ignore[attr-defined,union-attr]  # noqa: SLF001
+        self._original_data = deepcopy(data)
+
+        self._header = self.query_one(Header)
+        content = self.query_one("#main-content", Vertical)
+        content.remove_children()
+        content.mount(map_config_to_widgets(data))
+
+        tree = self.query_one("#sidebar-tree", Tree)
+        tree.clear()
+        self._tree_nodes.clear()
+        self._populate_tree(tree.root, data)
+
+        if self._read_only:
+            self._header.sub_title = "[READ ONLY]"  # type: ignore[union-attr,attr-defined]
+        else:
+            self._header.sub_title = self._filepath.name  # type: ignore[union-attr,attr-defined]
+
+        for _ in range(_MOUNT_SETTLE_YIELDS):
+            await asyncio.sleep(0)
+
+        self.call_later(self._end_mount_phase)
+
+    def _end_mount_phase(self) -> None:
+        self._mount_phase = False
+        self._dirty = False
+        if self._read_only:
+            self._header.sub_title = "[READ ONLY]"  # type: ignore[union-attr,attr-defined]
+        else:
+            self._header.sub_title = self._filepath.name  # type: ignore[union-attr,attr-defined]
+
+    def _get_nested(self, data: dict[str, Any], dotted_path: str) -> Any:
+        parts = dotted_path.split(".")
+        current: Any = data
+        for part in parts:
+            current = current[int(part)] if isinstance(current, list) and part.isdigit() else current[part]  # type: ignore[index]
+        return current
+
+    def _populate_tree(self, node: TreeNode, data: dict[str, Any], prefix: str = "") -> None:
+        for key, value in data.items():
+            path = f"{prefix}.{key}" if prefix else key
+            if isinstance(value, dict):
+                child = node.add(key, expand=True)
+                child.data = {"path": path}
+                self._tree_nodes[path] = child
+                self._populate_tree(child, value, prefix=path)
+            else:
+                child = node.add_leaf(key)
+                child.data = {"path": path}
+                self._tree_nodes[path] = child
+
+    def _expand_tree_ancestors(self, key_path: str) -> None:
+        parts = key_path.split(".")
+        for i in range(1, len(parts)):
+            ancestor_path = ".".join(parts[:i])
+            ancestor = self._tree_nodes.get(ancestor_path)
+            if ancestor is not None:
+                ancestor.expand()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        if event.node.tree.id != "sidebar-tree":
+            return
+        data = event.node.data
+        if data is None or "path" not in data:
+            return
+        dotted_path = data["path"]
+        wid = dotted_path.replace(".", "_")
+        try:
+            widget = self.query_one(f"#{wid}")
+            if isinstance(widget, Collapsible) and widget.collapsed:
+                widget.collapsed = False
+            widget.scroll_visible()
+        except Exception:  # noqa: BLE001, S110
+            pass
+
+    def _sync_tree_from_collapsible(self, collapsible_id: str, *, expanded: bool) -> None:
+        key_path = collapsible_id.replace("_", ".")
+        node = self._tree_nodes.get(key_path)
+        if node is not None:
+            if expanded:
+                node.expand()
+            else:
+                node.collapse()
+            self._expand_tree_ancestors(key_path)
+
+    def on_collapsible_expanded(self, event: Collapsible.Expanded) -> None:
+        wid = event.collapsible.id
+        if wid:
+            self._sync_tree_from_collapsible(wid, expanded=True)
+
+    def on_collapsible_collapsed(self, event: Collapsible.Collapsed) -> None:
+        wid = event.collapsible.id
+        if wid:
+            self._sync_tree_from_collapsible(wid, expanded=False)
+
+    def _mark_dirty(self) -> None:
+        if self._mount_phase or self._read_only:
+            return
+        if not self._dirty:
+            self._dirty = True
+            self._header.sub_title = f"{self._filepath.name} *"  # type: ignore[union-attr,attr-defined]
+
+    def on_input_changed(self, _event: Input.Changed) -> None:
+        self._mark_dirty()
+
+    def on_switch_changed(self, _event: Switch.Changed) -> None:
+        self._mark_dirty()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id
+        if button_id is None:
+            return
+        if button_id.startswith("reset-") and "reset-btn" in event.button.classes:
+            widget_id = button_id[6:]
+            widget = self.query_one(f"#{widget_id}")
+            row = widget.parent if isinstance(widget.parent, Horizontal) else None
+            dotted_path = getattr(row, "reset_path", None) or widget_id.replace("_", ".")
+            original_value = self._get_nested(self._original_data, dotted_path)
+            if isinstance(widget, Switch):
+                widget.value = bool(original_value)
+            elif isinstance(widget, Input):
+                widget.value = str(original_value)
+            self._mark_dirty()
+
+    def action_save(self) -> None:
+        if self._read_only or not self._dirty:
+            return
+        try:
+            content = self.query_one("#main-content", Vertical)
+            data = map_widgets_to_config(content)
+            self._config.update(data)  # type: ignore[attr-defined]
+            self._config.save()  # type: ignore[attr-defined]
+            self._dirty = False
+            self._header.sub_title = self._filepath.name  # type: ignore[union-attr,attr-defined]
+        except Exception as exc:  # noqa: BLE001
+            self.notify(str(exc), severity="error", title="Save failed")
+
+    def action_save_as(self) -> None:
+        if self._read_only:
+            return
+        self.push_screen(SaveAsScreen(self._filepath), self._on_save_as_result)
+
+    def _on_save_as_result(self, new_path: Path | None) -> None:
+        if new_path is None:
+            return
+        try:
+            content = self.query_one("#main-content", Vertical)
+            data = map_widgets_to_config(content)
+            self._config.update(data)  # type: ignore[attr-defined]
+            self._config.save_as(new_path)  # type: ignore[attr-defined]
+            self._filepath = new_path
+            self._dirty = False
+            self._header.sub_title = self._filepath.name  # type: ignore[union-attr,attr-defined]
+        except Exception as exc:  # noqa: BLE001
+            self.notify(str(exc), severity="error", title="Save As failed")
+
+    def action_reset_all(self) -> None:
+        if self._read_only or not self._dirty:
+            return
+        self.push_screen(ResetConfirmScreen(), self._on_reset_all_result)  # type: ignore[arg-type]
+
+    def _on_reset_all_result(self, confirmed: bool) -> None:  # noqa: FBT001
+        if not confirmed:
+            return
+        content = self.query_one("#main-content", Vertical)
+        content.remove_children()
+        content.mount(map_config_to_widgets(self._original_data))
+        tree = self.query_one("#sidebar-tree", Tree)
+        tree.clear()
+        self._tree_nodes.clear()
+        self._populate_tree(tree.root, self._original_data)
+        self._dirty = False
+        self._header.sub_title = self._filepath.name  # type: ignore[union-attr,attr-defined]
+
+    def action_quit(self) -> None:  # type: ignore[override]
+        if self._dirty:
+            self.push_screen(ConfirmExitScreen(), self._on_quit_result)  # type: ignore[arg-type]
+        else:
+            self.exit()
+
+    def _on_quit_result(self, confirmed: bool) -> None:  # noqa: FBT001
+        if confirmed:
+            self.exit()

configui/tui/cli.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import click
+
+from configui.tui.app import ConfigUIApp
+
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("-r", "--read-only", is_flag=True, help="Open in read-only mode")
+def main(path: str, read_only: bool) -> None:  # noqa: FBT001
+    """Open a configuration file in the ConfigUI TUI editor."""
+    app = ConfigUIApp(path, read_only=read_only)
+    app.run()

configui/tui/collector.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Collapsible, Input, Static, Switch
+
+
+def _extract_value(widget: Switch | Input) -> Any:
+    if isinstance(widget, Switch):
+        return widget.value
+    if widget.type == "integer":
+        return int(widget.value) if widget.value else 0
+    if widget.type == "number":
+        return float(widget.value) if widget.value else 0.0
+    return widget.value
+
+
+def _content_children(coll: Collapsible):
+    """Yield actual user-provided children of a Collapsible, skipping internal wrappers."""
+    contents = list(coll.children)[1]
+    yield from contents.children
+
+
+def _collect(widget: Horizontal | Collapsible, container: dict[str, Any] | list[Any]) -> None:
+    if isinstance(widget, Horizontal):
+        label = cast("Static", widget.children[0])
+        value_widget = cast("Switch | Input", widget.children[1])
+        key = str(label.content)
+        value = _extract_value(value_widget)
+        if isinstance(container, dict):
+            container[key] = value
+        else:
+            container.append(value)
+    elif isinstance(widget, Collapsible):
+        sub: list[Any] | dict[str, Any]
+        if "container-dict" in widget.classes:
+            sub = {}
+            for child in _content_children(widget):
+                _collect(cast("Horizontal | Collapsible", child), sub)
+        elif "container-list" in widget.classes:
+            sub = []
+            for child in _content_children(widget):
+                _collect(cast("Horizontal | Collapsible", child), sub)
+        else:
+            return
+
+        if isinstance(container, dict):
+            key = str(widget.title)
+            if "container-list" in widget.classes:
+                key = key.rsplit(" [", 1)[0]
+            container[key] = sub
+        else:
+            container.append(sub)
+
+
+def _unwrap(root: Vertical) -> Vertical:
+    """Unwrap a single wrapper Vertical, if present."""
+    children = list(root.children)
+    if len(children) == 1 and isinstance(children[0], Vertical):
+        return cast("Vertical", children[0])
+    return root
+
+
+def map_widgets_to_config(root: Vertical) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    target = _unwrap(root)
+    for child in target.children:
+        _collect(cast("Horizontal | Collapsible", child), result)
+    return result

configui/tui/screens.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import Button, Input, Label, Static
+
+from configui.tui.widgets import NavigableDirectoryTree
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+class ConfirmExitScreen(Screen[bool]):
+    CSS = """
+    ConfirmExitScreen {
+        align: center middle;
+    }
+
+    #confirm-exit-box {
+        width: 50;
+        height: auto;
+        padding: 2;
+        border: round $primary;
+    }
+
+    #confirm-exit-box > Label {
+        text-align: center;
+        margin: 1 0 2 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="confirm-exit-box"):
+            yield Label("You have unsaved changes. Exit anyway?")
+            yield Button("Cancel", variant="primary", id="cancel")
+            yield Button("Exit", variant="error", id="exit")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "exit":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class ResetConfirmScreen(Screen[bool]):
+    CSS = """
+    ResetConfirmScreen {
+        align: center middle;
+    }
+
+    #reset-confirm-box {
+        width: 50;
+        height: auto;
+        padding: 2;
+        border: round $primary;
+    }
+
+    #reset-confirm-box > Label {
+        text-align: center;
+        margin: 1 0 2 0;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="reset-confirm-box"):
+            yield Label("Reset all fields to their original values?")
+            yield Button("Cancel", variant="primary", id="cancel")
+            yield Button("Reset All", variant="error", id="reset")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "reset":
+            self.dismiss(True)
+        else:
+            self.dismiss(False)
+
+
+class SaveAsScreen(Screen[Path | None]):
+    CSS = """
+    SaveAsScreen {
+        align: center middle;
+    }
+
+    #save-as-box {
+        width: 80;
+        height: auto;
+        padding: 2;
+        border: round $primary;
+    }
+
+    #save-as-box > Label {
+        text-align: center;
+        text-style: bold;
+        margin: 0 0 1 0;
+    }
+
+    #save-directory-tree {
+        height: 20;
+        width: 1fr;
+        border: round $surface;
+    }
+
+    #save-filename {
+        margin: 1 0;
+        border: round $primary;
+    }
+
+    #save-filename:focus {
+        border: round $primary;
+    }
+
+    #save-path-preview {
+        margin: 1 0;
+    }
+
+    #save-as-box > Button {
+        margin: 1 0 0 0;
+    }
+    """
+
+    def __init__(self, current_path: Path) -> None:
+        super().__init__()
+        self._current_path = current_path
+        self._selected_dir: Path = current_path.parent
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="save-as-box"):
+            yield Label("Save As")
+            yield NavigableDirectoryTree(str(self._current_path.parent), id="save-directory-tree")
+            yield Input(value=self._current_path.name, id="save-filename", placeholder="Filename")
+            yield Static(id="save-path-preview")
+            yield Button("Browse", id="browse")
+            yield Button("Save", variant="primary", id="save")
+            yield Button("Cancel", id="cancel")
+
+    def on_mount(self) -> None:
+        self._update_preview()
+
+    def _get_save_path(self) -> Path | None:
+        filename = self.query_one("#save-filename", Input).value.strip()
+        if not filename:
+            return None
+        try:
+            candidate = Path(filename).expanduser()
+        except RuntimeError:
+            return None
+        if candidate.is_absolute():
+            return candidate
+        return self._selected_dir / candidate
+
+    def _update_preview(self) -> None:
+        save_path = self._get_save_path()
+        preview = self.query_one("#save-path-preview", Static)
+        if save_path:
+            preview.update(f"Save path: {save_path}")
+        else:
+            preview.update("")
+
+    def on_input_changed(self, _event: Input.Changed) -> None:
+        self._update_preview()
+
+    def on_directory_tree_directory_selected(self, event: NavigableDirectoryTree.DirectorySelected) -> None:
+        self._selected_dir = event.path
+        tree = self.query_one("#save-directory-tree", NavigableDirectoryTree)
+        tree.path = event.path
+        self._update_preview()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "save":
+            save_path = self._get_save_path()
+            if save_path:
+                self.dismiss(save_path)
+        elif event.button.id == "cancel":
+            self.dismiss(None)
+        elif event.button.id == "browse":
+            self.query_one("#save-directory-tree", NavigableDirectoryTree).focus()

configui/tui/widgets.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Button, Collapsible, DirectoryTree, Input, Static, Switch
+from textual.widgets._directory_tree import DirEntry
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+    from pathlib import Path
+
+    from textual.widgets._tree import TreeNode
+
+DEFAULT_INT_RESTRICT: str = r"^-?\d*$"
+DEFAULT_FLOAT_RESTRICT: str = r"^-?\d*(\.\d*)?([eE][+-]?\d+)?$"
+
+
+def _safe_id(prefix: str, key: str) -> str:
+    raw = f"{prefix}_{key}" if prefix else key
+    return raw.replace(".", "_")
+
+
+def _make_scalar_row(
+    label: str,
+    value: Any,
+    *,
+    widget_id: str | None = None,
+    restrict: str | None = None,
+    dotted_path: str | None = None,
+) -> Horizontal:
+    widget: Switch | Input
+    if isinstance(value, bool):
+        widget = Switch(value=value, id=widget_id)
+    elif isinstance(value, int):
+        widget = Input(
+            type="integer",
+            value=str(value),
+            restrict=restrict or DEFAULT_INT_RESTRICT,
+            id=widget_id,
+        )
+    elif isinstance(value, float):
+        widget = Input(
+            type="number",
+            value=str(value),
+            restrict=restrict or DEFAULT_FLOAT_RESTRICT,
+            id=widget_id,
+        )
+    else:
+        widget = Input(type="text", value=str(value), id=widget_id, restrict=restrict)
+
+    widget.add_class("scalar-input")
+    reset_btn = Button("↺", id=f"reset-{widget_id}" if widget_id else None, classes="reset-btn")
+    row = Horizontal(Static(label, classes="scalar-label"), widget, reset_btn, classes="scalar-row")
+    row.reset_path = dotted_path  # type: ignore[attr-defined]
+    return row
+
+
+def _map_value(
+    key: str,
+    value: Any,
+    *,
+    prefix: str = "",
+    regex_overrides: dict[str, str] | None = None,
+) -> Horizontal | Collapsible:
+    dotted_path = f"{prefix}.{key}" if prefix else key
+    wid = _safe_id(prefix, key)
+    overrides = regex_overrides or {}
+
+    if isinstance(value, dict):
+        children = [_map_value(k, v, prefix=dotted_path, regex_overrides=overrides) for k, v in value.items()]
+        return Collapsible(*children, title=key, id=wid, classes="container-dict", collapsed=False)
+
+    if isinstance(value, list):
+        children = [
+            _map_value(str(i), item, prefix=dotted_path, regex_overrides=overrides) for i, item in enumerate(value)
+        ]
+        title = f"{key} [{len(value)}]"
+        return Collapsible(*children, title=title, id=wid, classes="container-list", collapsed=False)
+
+    restrict = overrides.get(dotted_path)
+    return _make_scalar_row(key, value, widget_id=wid, restrict=restrict, dotted_path=dotted_path)
+
+
+class NavigableDirectoryTree(DirectoryTree):
+    def _populate_node(self, node: TreeNode[DirEntry], content: Iterable[Path]) -> None:
+        node.remove_children()
+        if node.data is not None:
+            parent_path = node.data.path.parent
+            if parent_path != node.data.path:
+                node.add("..", data=DirEntry(parent_path), allow_expand=True)
+        for path in content:
+            node.add(
+                path.name,
+                data=DirEntry(path),
+                allow_expand=self._safe_is_dir(path),
+            )
+        node.expand()
+
+
+def map_config_to_widgets(
+    data: dict[str, Any],
+    *,
+    regex_overrides: dict[str, str] | None = None,
+) -> Vertical:
+    overrides = regex_overrides or {}
+    children = [_map_value(key, value, regex_overrides=overrides) for key, value in data.items()]
+    return Vertical(*children, classes="content-wrapper")

configui-1.0.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: configui
+Version: 1.0.0
+Dynamic: License
+Dynamic: License-Expression
+Summary: A tool that turns any yaml or json configs into tui
+Author-email: Chenchao Zhao <chenchao.zhao.dev+github@gmail.com>
+License-File: LICENSE
+Requires-Python: <3.14,>=3.12
+Requires-Dist: click>=8.1.0
+Requires-Dist: ruamel-yaml>=0.18.0
+Requires-Dist: textual>=1.0.0
+Requires-Dist: tomlkit>=0.13.0
+Description-Content-Type: text/markdown
+
+# ConfigUI
+
+[![CI](https://github.com/chenchaozhao/configui/actions/workflows/tests.yml/badge.svg)](https://github.com/chenchaozhao/configui/actions/workflows/tests.yml)
+[![PyPI version](https://img.shields.io/pypi/v/configui)](https://pypi.org/project/configui/)
+[![Python](https://img.shields.io/badge/python-3.12%20|%203.13-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+Turn YAML, JSON, and TOML configuration files into a terminal user interface (TUI) — no IDE required.
+
+---
+
+## Installation
+
+```bash
+# Install from PyPI
+uv tool install configui
+
+# Or with pip
+pip install configui
+```
+
+## Quickstart
+
+```bash
+configui path/to/config.yaml
+```
+
+Open a configuration file in the interactive TUI editor. Edit values, toggle booleans, navigate nested structures — everything stays type-aware. Try it with the sample configs in `samples/`:
+
+```bash
+configui samples/training_config.yaml
+configui samples/training_config.json
+configui samples/training_config.toml
+```
+
+```bash
+configui path/to/config.yaml -r  # Read-only mode
+```
+
+![ConfigUI screenshot](_assets/ConfigUI_screenshot.svg)
+
+## Features
+
+- **Type-aware editing** — booleans become checkboxes, numbers get numeric inputs, nested objects become collapsible sections.
+- **Multi-format** — YAML (with comment preservation via `ruamel.yaml`), JSON, and TOML (with `tomlkit`).
+- **Read-only mode** — inspect configs without accidental edits (`-r` flag).
+- **Save or Save As** — overwrite the original or write to a new path.
+- **Comment preservation** — your YAML and TOML comments stay intact.
+
+## Supported Formats
+
+| Format | Library | Comments preserved |
+|--------|---------|-------------------|
+| YAML   | ruamel.yaml | ✅ |
+| JSON   | stdlib json | ❌ (not supported by format) |
+| TOML   | tomlkit     | ✅ |
+
+## Development
+
+```bash
+uv tool install hatch
+hatch run release   # fmt → typing → test with coverage
+```
+
+## License
+
+MIT

configui-1.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+configui/__about__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+configui/__init__.py,sha256=Vf7-MY0K_6mZs3IxeAsj4wY0DyW_gQP6iuNhPFE5Iow,70
+configui/__main__.py,sha256=5zmNw8RQWWDg3Mb2Ihd1EyGWkdxhz1LU4m1yGraPlHc,73
+configui/config/__init__.py,sha256=eV9OesaYHtJsSpB3na1cOl9Kg4B5yvU71suddbyZT2A,345
+configui/config/_atomic.py,sha256=sfmCr1vESOaMm6YH1SozH__E8sSRaKfxxO4dagY5qe8,1470
+configui/config/_protocol.py,sha256=UgiLkZhh_-6U8rKpB2tUQrkQhZkmM3B4F6bX0yOlwro,468
+configui/config/formats.py,sha256=51iSfNOf6sEsMXErL6TL4omB2rwGbDJzi830ewVHtMQ,991
+configui/config/json_config.py,sha256=Lyua4WyLpXSG9q9nYM1F7-Uch6jruA6h-JejXAZh1VU,1521
+configui/config/toml_config.py,sha256=aNciaAYNZdTDfk6Zlzx4myYF2Po-aJKEpWGV1Gh5wgQ,1492
+configui/config/yaml_config.py,sha256=np36liRCuCk6b52bToOHANW_Vg7a1HoHE-hM2RpNjnw,1827
+configui/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+configui/tui/app.py,sha256=YB3Z4gGjGHkQut8SjwXLW4KtmTLGNcFKeMGeOVTKnQ0,11463
+configui/tui/cli.py,sha256=vdyd3TlO64_FogTpnLks7yor6O3FbhzckYgabN8YCHo,433
+configui/tui/collector.py,sha256=oGs3310RuHrkBSMcDRBB-Q1l4qEbTui2OAgCj5P5hH4,2418
+configui/tui/screens.py,sha256=f6ETw9nJQVkI9FAwFs9gKpQirv_6j6Jad7mSQr86Uzg,4903
+configui/tui/widgets.py,sha256=n-Tzw3Jo5k5WS-2-icpb-Q2uNB0bgUSJRxk7kQsBRR0,3646
+configui-1.0.0.dist-info/METADATA,sha256=pI5K9OdJXoOJF-30upWBZw5zCcxGsot45Ga1HJfhNLM,2416
+configui-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+configui-1.0.0.dist-info/entry_points.txt,sha256=7uS8KCdGBpKbHXJIQXzH_Da9IOjEoYMplByZHpCKZcw,51
+configui-1.0.0.dist-info/licenses/LICENSE,sha256=-T4MqdM5NeuybxUKObsf95pcYmKFa5QpvezUvkJc0fo,1070
+configui-1.0.0.dist-info/RECORD,,

configui-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

configui-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+configui = configui.tui.cli:main

configui-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chenchao Zhao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.