feedscope 0.1.0__py3-none-any.whl

feedscope/ui/screens/answer.py

@@ -0,0 +1,296 @@
+"""回答详情屏：多层递进的第三层（列表 -> 问题 -> 回答+评论）。
+
+从问题屏 Enter 进「视口正在阅读」的那个回答（问题屏 detail.py 定位）。
+评论按需抓取：进这一屏才调问题 loader 的 open_comments（用户不进就不花
+一次请求）；正文秒显（数据已在问题 loader 的 doc 里），评论异步补上。
+评论层与问题层共享页签：评论 loader 的 close() 只收评论区，不关底座。
+翻页动线 / 尾行状态机 / ←/→ 换楼层的机械件在 PagedReadingScreen，本屏
+只剩首载编排（评论按需）与整屏渲染。
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from rich.markup import escape
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.widget import Widget
+from textual.widgets import Footer, Header, Label, Markdown, Static
+
+from feedscope.core.models import Comment, FeedItem
+from feedscope.core.source import CommentLoader, DetailLoader, Source
+from feedscope.core.i18n import t
+from feedscope.ui import Bindings, feedback
+from feedscope.ui.screens.reading import (
+    PagedReadingScreen,
+    READING_CSS,
+    dim_line,
+    divider,
+    floor_head,
+)
+from feedscope.ui.wrap import wrap_markdown
+
+
+class AnswerScreen(PagedReadingScreen):
+    """单条回答全文 + 它的评论区（评论此刻才请求）。
+
+    Esc 返回问题屏（阅读位置不变）；Ctrl+N 加载更多评论（评论多时一层层翻）；
+    ←/→ 在已加载的回答间换（要更多回答回问题屏按 Ctrl+N）。
+    """
+
+    BINDINGS: ClassVar[Bindings] = [
+        # 键位全部非打印键（输入法免疫）：↑/↓ 滚动走焦点容器（VerticalScroll）
+        # 原生键，无需声明。标签是占位（空串）：__init__ 按源词汇表换成
+        # 「更多{评论词}/下一{楼层词}」（知乎渲染与本列表逐字相同）；
+        # Esc 返回继承自 ReadingScreen
+        Binding("ctrl+n", "more", ""),
+        Binding("ctrl+o", "open_browser", "bindings.browser"),
+        Binding("right", "next_answer", ""),
+        Binding("left", "prev_answer", ""),
+    ]
+
+    # Markdown 标题规则必须 CSS 级（见 reading.READING_CSS 的说明），其余
+    # 共享样式走 ReadingScreen.DEFAULT_CSS
+    CSS = READING_CSS + """
+    .comments-header { padding: 1 2; text-style: bold; }
+    #cm-loading { padding: 1 2; }
+    """
+
+    _worker_group = "comments"  # 评论首载/重试/翻页同组互斥（换楼层整组取消）
+
+    def __init__(
+        self, source: Source, item: FeedItem, qloader: DetailLoader, index: int
+    ) -> None:
+        super().__init__()
+        self.source = source
+        self.item = item        # 问题条目（Ctrl+O 兜底用它）
+        self.qloader = qloader  # 问题 loader（共享页签的底座）
+        self.index = index
+        self.loader: CommentLoader | None = None  # 评论 loader（契约见 core.source.CommentLoader）
+        # 词汇表归源：本屏两层各有单位词——楼层（←/→ 切换的对象，知乎「回答」、
+        # HN「评论」）与评论（Ctrl+N 翻的对象，知乎「评论」、HN「回复」）；键位
+        # 文案随词换（类级 BINDINGS 是占位，知乎渲染与内置文案逐字相同）
+        self._floor_unit = source.detail_unit
+        self._relabel_bindings(
+            {
+                "ctrl+n": t("read.binding_more_unit", unit=self._unit),
+                "right": t("read.binding_next_unit", unit=self._floor_unit),
+                "left": t("read.binding_prev_unit", unit=self._floor_unit),
+            }
+        )
+        self._floor_count = 0          # 评论楼层序号，跨 load_more 递增
+        self._comments_error: str | None = None  # 首载失败文案（resize 重排时保持失败态）
+
+    @property
+    def _answer(self):
+        return self.qloader.doc.answers[self.index]
+
+    @property
+    def _unit(self) -> str:
+        """Ctrl+N 翻页对象的单位词（评论词，源词汇表直读，与问题屏对称）。"""
+        return self.source.comment_unit
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield VerticalScroll(id="answer-body-scroll")
+        yield Footer()
+
+    def _body_scroll(self) -> VerticalScroll:
+        return self.query_one("#answer-body-scroll", VerticalScroll)
+
+    async def _mount_body(self) -> None:
+        self._body_scroll().focus()
+        await self._render_doc()
+        self._render_done()
+        self.run_worker(self._load_comments(), group="comments", exclusive=True)
+
+    def _reset_render_state(self) -> None:
+        self._floor_count = 0
+
+    # 卸载清理继承 PagedReadingScreen：只换出并关评论 loader（问题页签由问题屏管）
+
+    def _hint_widget(self) -> Static:
+        # class 不用 id：hint 会随楼层增删反复挂载，id 会在摘除延迟时撞重。
+        # 只留 Footer 没有的语义增量（加载什么）；换楼层/返回是 Footer 的键位职责
+        return Static(
+            f"[dim]── {t('read.hint_more', unit=self._unit)} ──[/dim]",
+            classes="tail-line tail-hint",
+        )
+
+    # ---- 渲染 ----
+
+    async def _render_doc(self) -> None:
+        """整个回答详情上屏（单次 mount = 单次布局）；评论未到先占位。"""
+        ans = self._answer
+        body = self._body_scroll()
+        title = Static(
+            escape(t("read.answer_title", author=ans.author, unit=self._floor_unit)),
+            id="answer-title",
+            classes="read-title",
+        )
+        widgets: list[Widget] = [title]
+        meta = " · ".join(x for x in (ans.votes, ans.comment_count, ans.time) if x)
+        if meta:
+            widgets.append(
+                Static(f"[dim]{escape(meta)}[/dim]", id="answer-meta", classes="read-meta")
+            )
+        widgets.append(
+            Markdown(wrap_markdown(ans.content_md, self._md_width()), id="answer-content",
+                     classes="read-main")
+        )
+        widgets.extend([divider(), Static(f"[b]{self._unit}[/b]", classes="comments-header")])
+        if self.loader is not None:
+            if self.loader.comments:
+                for c in self.loader.comments:
+                    widgets.extend(self._comment_floor(c))
+            else:
+                # 首批已回来但为空：到没到头都显示空态，别退回「加载中」（resize 重排
+                # 走的是同一渲染路径，状态必须与首次上屏一致）
+                widgets.append(
+                    dim_line(t("read.none", unit=self._unit), classes="tail-line tail-empty")
+                )
+            if self._exhausted:
+                widgets.append(
+                    dim_line(
+                        t("read.no_more", unit=self._unit), classes="tail-line tail-eof"
+                    )
+                )
+            else:
+                self._hint = self._hint_widget()
+                widgets.append(self._hint)
+        elif self._comments_error is not None:
+            # 首载失败：保留失败态与 Ctrl+N 重试入口（错误行本身已说明动线）
+            widgets.append(
+                Static(
+                    f"[red]{t('read.comments_failed_retry', text=escape(self._comments_error))}[/red]",  # noqa: E501
+                    id="cm-loading",
+                )
+            )
+        else:
+            widgets.append(Label(t("read.unit_loading", unit=self._unit), id="cm-loading"))
+            self._hint = self._hint_widget()
+            widgets.append(self._hint)
+        await body.mount(*widgets)
+
+    def _comment_floor(self, c: Comment) -> list[Widget]:
+        """一条顶层评论的楼层部件（头部 + 内容 + 缩进的子回复）。"""
+        self._floor_count += 1
+        widgets = [
+            divider(),
+            floor_head(
+                t("read.floor_head", unit=self._unit, n=self._floor_count),
+                c.author,
+                (c.votes, c.time),
+                classes="floor-head",
+            ),
+            Markdown(wrap_markdown(c.content_md, self._md_width()), classes="floor-body"),
+        ]
+        for r in c.replies:
+            widgets.extend(
+                [
+                    floor_head("", r.author, (r.votes, r.time), classes="floor-head sub"),
+                    Markdown(
+                        wrap_markdown(r.content_md, self._md_width(3)),
+                        classes="floor-body sub",
+                    ),
+                ]
+            )
+        return widgets
+
+    # ---- 评论加载（按需）----
+
+    async def _load_comments(self) -> None:
+        """此刻才请求：问题 loader 点开该回答的评论区（共享页签）。
+
+        sub_title 在这设而非 on_mount：worker 晚于 Header 挂载，同步设
+        不会踩 HeaderTitle 未挂的时序坑。
+        """
+        self.app.sub_title = t(
+            "read.answer_title", author=self._answer.author, unit=self._floor_unit
+        )[:50]
+        self._comments_error = None
+        try:
+            self.loader = await self.qloader.open_comments(self.index)
+        except Exception as exc:
+            # 失败文案存下来：resize 重排也要还原成失败态，不能变回「加载中」
+            self._comments_error = feedback.failure_text(self.source, exc)
+            feedback.fail(self.app, self.source, exc, action="feedback.action_comments_failed")
+            self._swap_status(
+                "cm-loading",
+                f"[red]{t('read.comments_failed_retry', text=escape(self._comments_error))}[/red]",
+            )
+            return
+        # done 与有没有评论无关：最后一页即使非空也已到头，尾行该换 EOF 标记
+        self._exhausted = self.loader.done
+        for w in self.query("#cm-loading"):
+            await w.remove()
+        if self.loader.comments:
+            await self._mount_batch(self.loader.comments)
+            await self._mount_tail()
+        else:
+            await self._mount_empty_tail()
+
+    async def _mount_empty_tail(self) -> None:
+        """首批为空的空态尾行：「（没有X）」+ EOF 标记或重试预告。"""
+        self._remove_hint()
+        tail: list[Widget] = [
+            dim_line(t("read.none", unit=self._unit), classes="tail-line tail-empty")
+        ]
+        if self._exhausted:
+            tail.append(dim_line(t("read.no_more", unit=self._unit), classes="tail-line tail-eof"))
+        else:
+            # 首批拉空但没到头（网慢）：不判死，尾行保留 Ctrl+N 重试预告
+            self._hint = self._hint_widget()
+            tail.append(self._hint)
+        await self._body_scroll().mount(*tail)
+
+    async def _mount_batch(self, comments: list[Comment]) -> None:
+        widgets: list[Widget] = []
+        for c in comments:
+            widgets.extend(self._comment_floor(c))
+        await self._body_scroll().mount(*widgets)
+        # 与问题屏同一取舍：新楼层接在底部，视口停在原阅读断点不跳
+
+    def _swap_status(self, sel: str, text: str) -> None:
+        for w in self.query(sel):
+            if isinstance(w, Static):
+                w.update(text)
+
+    async def _retry(self) -> None:
+        """评论首载失败后的原地重试（与问题屏首载重试同动线）。"""
+        for w in self.query("#cm-loading"):
+            if isinstance(w, Static):
+                w.update(t("read.unit_loading", unit=self._unit))
+        await self._load_comments()
+
+    # ---- ←/→ 换楼层（机械件在 PagedReadingScreen._retarget）----
+
+    async def action_next_answer(self) -> None:
+        await self._retarget(1)
+
+    async def action_prev_answer(self) -> None:
+        await self._retarget(-1)
+
+    def _next_target(self, delta: int) -> int | None:
+        """同问题内相邻楼层（更多楼层回问题屏按 Ctrl+N 加载）。"""
+        nxt = self.index + delta
+        return nxt if 0 <= nxt < len(self.qloader.doc.answers) else None
+
+    def _no_target_text(self, delta: int) -> str:
+        return (
+            t("read.no_next_loaded", unit=self._floor_unit)
+            if delta > 0
+            else t("read.no_prev_unit", unit=self._floor_unit)
+        )
+
+    async def _adopt_target(self, index: int) -> None:
+        self.index = index
+        self._comments_error = None
+        await self._render_doc()
+        self._render_done()
+        self.run_worker(self._load_comments(), group="comments", exclusive=True)
+
+    def _browser_url(self) -> str:
+        return self._answer.url or self.item.url

feedscope/ui/screens/detail.py

@@ -0,0 +1,274 @@
+"""问题详情屏：题目 + 描述 + 回答流，纯终端阅读。
+
+多层递进的第二层：列表 -> 这里（回答流）-> 回答详情屏（评论层）。
+Enter 进「视口正在阅读」的那个回答（读到哪进哪）；评论不随首批抓取
+（首载要快），楼层头部只带评论数引导。翻页动线 / 尾行状态机 / ←/→ 换篇
+的机械件在 PagedReadingScreen，本屏只剩首载编排、整屏渲染与 Enter 分派。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import ClassVar
+
+from rich.markup import escape
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.widget import Widget
+from textual.widgets import Footer, Header, Label, Markdown, Static
+
+from feedscope.core.models import Answer, DetailDoc, FeedItem
+from feedscope.core.source import DetailLoader, Source
+from feedscope.core.i18n import t
+from feedscope.ui import Bindings, feedback
+from feedscope.ui.screens.answer import AnswerScreen
+from feedscope.ui.screens.reading import (
+    PagedReadingScreen,
+    READING_CSS,
+    dim_line,
+    divider,
+    floor_head,
+)
+from feedscope.ui.wrap import wrap_markdown
+
+
+class DetailScreen(PagedReadingScreen):
+    """全屏阅读一个问题：Esc 返回（列表位置不变），Ctrl+N 加载更多回答，←/→ 换篇。"""
+
+    BINDINGS: ClassVar[Bindings] = [
+        # 键位全部非打印键（输入法免疫）：↑/↓ 滚动走焦点容器（VerticalScroll）
+        # 原生键，无需声明；Esc 返回继承自 ReadingScreen
+        Binding("ctrl+n", "more", "bindings.more"),
+        # Enter 的标签是占位（空串）：__init__ 换源词汇表；无评论层的源隐藏该键位
+        Binding("enter", "pick_answer", ""),
+        Binding("ctrl+o", "open_browser", "bindings.browser"),
+        Binding("right", "next_article", "bindings.next"),
+        Binding("left", "prev_article", "bindings.prev"),
+    ]
+
+    # Markdown 标题规则必须 CSS 级（见 reading.READING_CSS 的说明），其余
+    # 共享样式走 ReadingScreen.DEFAULT_CSS
+    CSS = READING_CSS + """
+    .answers-header { padding: 0 2; text-style: bold; }
+    """
+
+    _worker_group = "load"  # 首载/重试/翻页同组互斥（换篇整组取消）
+
+    def __init__(
+        self,
+        item: FeedItem,
+        source: Source,
+        step_item: Callable[[int], FeedItem | None],
+    ) -> None:
+        super().__init__()
+        self.item = item
+        self.source = source
+        # Enter 的键位文案随源词汇表（知乎「评论」、HN「回复」）；无评论层的源
+        # （supports_comments=False，如 X/RSS）Footer 不预告——键位隐藏但保留，
+        # 误按仍走 action_pick_answer 的「暂不支持」反馈，不无声（与尾行预告
+        # 同一能力判定）。
+        self._relabel_bindings(
+            {"enter": source.comment_unit},
+            hide="" if source.supports_comments else "enter",
+        )
+        self._step_item = step_item  # 向 App 要相邻的可读条目（←/→ 换篇，同步推进列表选中）
+        self.loader: DetailLoader | None = None
+        self._answer_count = 0  # 回答序号，跨 load_more 递增
+
+    @property
+    def _unit(self) -> str:
+        """楼层单位词：源词汇表（知乎「回答」、X「回复」），详情屏不硬编码。"""
+        return self.source.detail_unit
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield VerticalScroll(id="detail-body")
+        yield Footer()
+
+    def _body_scroll(self) -> VerticalScroll:
+        return self.query_one("#detail-body", VerticalScroll)
+
+    async def _mount_body(self) -> None:
+        self._body_scroll().focus()
+        # 组内互斥：换篇/重试可打断在途首载
+        self.run_worker(self._load(), group="load", exclusive=True)
+
+    def _reset_render_state(self) -> None:
+        self._answer_count = 0
+
+    # ---- 首载与整屏渲染 ----
+
+    async def _load(self) -> None:
+        body = self._body_scroll()
+        loading = Label(t("read.loading"), id="detail-loading")
+        await body.mount(loading)
+        try:
+            self.loader = await self.source.open_detail(self.item)
+        except Exception as exc:
+            # notify 给细节（瞬时），屏内留一行常驻失败态：notify 会消失，屏幕不能空着
+            feedback.fail(self.app, self.source, exc)
+            self.app.sub_title = t("read.status_failed")  # 常驻失败标记（与列表屏面包屑同一手法）
+            failure = t(
+                "read.load_failed_retry",
+                text=escape(feedback.failure_text(self.source, exc)),
+            )
+            loading.update(f"[red]{failure}[/red]")
+            return
+        loading.remove()
+        # 首批即到头（V2EX 一页全量 / HN·Reddit 楼层不足一页）：立刻按完成态渲染，
+        # 尾行给 EOF 标记而不是「Ctrl+N 加载更多」——按了也只会空跑一次
+        self._exhausted = self.loader.done
+        await self._render_doc(self.loader.doc)
+        self._render_done()
+        self.app.sub_title = self.loader.doc.title[:50]
+
+    async def _retry(self) -> None:
+        """首载失败后的原地重试：摘掉失败行，重走一遍 _load。"""
+        for w in self.query("#detail-loading"):
+            await w.remove()
+        await self._load()
+
+    async def _render_doc(self, doc: DetailDoc | None = None) -> None:
+        """把整个文档渲染上屏（单次 mount = 单次布局）；重排（resize）时也走这里。"""
+        loader = self.loader
+        if loader is None:
+            return  # 未加载完成（换篇/关闭的竞态窗口）：无内容可渲染
+        if doc is None:
+            doc = loader.doc  # 重排路径：doc 即已加载的全部内容
+        widgets: list[Widget] = [Static(escape(doc.title), id="detail-title", classes="read-title")]
+        if doc.meta or doc.time:
+            meta = " · ".join(x for x in (doc.meta, doc.time) if x)  # 正文发布时间并入元信息行
+            widgets.append(
+                Static(f"[dim]{escape(meta)}[/dim]", id="detail-meta", classes="read-meta")
+            )
+        if doc.description_md:
+            widgets.append(
+                Markdown(
+                    wrap_markdown(doc.description_md, self._md_width()),
+                    id="detail-desc",
+                    classes="read-main",
+                )
+            )
+        if doc.answers:
+            # 正文与楼层之间的边界：分隔线 + 区块标题
+            widgets.extend(
+                [divider(), Static(f"[b]{self._unit}[/b]", classes="answers-header")]
+            )
+            for ans in doc.answers:
+                widgets.extend(self._answer_widgets(ans))
+        if loader.done and not doc.answers:
+            # 天生无楼层的完整文档（RSS 全文 / Telegram 帖）：没有「更多」
+            # 也没有评论层，末尾只放纯 EOF 标记「（完）」——键位预告是常驻
+            # Footer 的职责，尾行复读键位会被短帖读者当成正文的一部分；
+            # 置 exhausted 让 Ctrl+N 走「没有更多」反馈而不是空跑 load_more
+            self._exhausted = True
+            widgets.append(dim_line(t("read.eof"), classes="tail-line tail-eof"))
+        elif self._exhausted:
+            widgets.append(
+                dim_line(t("read.no_more", unit=self._unit), classes="tail-line tail-eof")
+            )
+        else:
+            self._hint = self._hint_widget()
+            widgets.append(self._hint)
+        await self._body_scroll().mount(*widgets)
+
+    def _hint_widget(self) -> Static:
+        """尾行动线预告：只留 Footer 没有的语义增量（按了会加载/进入什么）；
+        纯键位复读（换篇/返回）是常驻 Footer 的职责——尾行复读会被短帖
+        读者当成正文的一部分。Enter 评论段只在源有评论层时列出。"""
+        segs = [t("read.hint_more", unit=self._unit)]
+        if self.source.supports_comments:
+            segs.append(t("read.hint_comments", unit=self._unit, cunit=self.source.comment_unit))
+        return Static(f"[dim]── {' · '.join(segs)} ──[/dim]", classes="tail-line tail-hint")
+
+    def _answer_widgets(self, ans: Answer) -> list[Widget]:
+        """一个楼层的完整部件（分隔线 + 头部 + 正文）；楼层序号在此推进。
+
+        头部 name 记楼层号：Enter 按可视位置定位楼层时用它取回。
+        """
+        self._answer_count += 1
+        head = floor_head(
+            t("read.floor_head", unit=self._unit, n=self._answer_count),
+            ans.author,
+            (ans.votes, ans.comment_count, ans.time),
+            classes="floor-head",
+            name=str(self._answer_count - 1),
+        )
+        return [
+            divider(),
+            head,
+            Markdown(wrap_markdown(ans.content_md, self._md_width()), classes="floor-body"),
+        ]
+
+    async def _mount_batch(self, new: list[Answer]) -> None:
+        widgets: list[Widget] = []
+        for ans in new:
+            widgets.extend(self._answer_widgets(ans))
+        await self._body_scroll().mount(*widgets)  # 单次挂载 = 单次布局
+        # 不主动滚动：新楼层就追加在旧内容正下方，视口停在原阅读断点不动，
+        # 「衔接」靠内容连续而非视口跳转。滚动到底（scroll_end）或顶对齐
+        # （scroll_to_widget top=True）都会把刚读到的楼层顶出视野、整屏跳动，
+        # 逼用户再滚回去找位置——踩过的坑，别再引入。
+
+    # ---- Enter -> 回答详情屏（多层递进的第三层入口）----
+
+    def action_pick_answer(self) -> None:
+        """Enter：进「视口正在阅读」的那个回答的评论层（读到哪进哪，评论那时才请求）。"""
+        if self.loader is None or not self._rendered:
+            feedback.info(self.app, t("read.still_loading"))
+            return
+        if not self.source.supports_comments:
+            # 键位已隐藏，这里只剩误按兜底：给一句反馈而不是无声（X/RSS 的详情没有评论层）
+            feedback.info(
+                self.app,
+                t(
+                    "read.single_floor_unsupported",
+                    label=self.source.label_text,
+                    unit=self._unit,
+                ),
+            )
+            return
+        if not self.loader.doc.answers:
+            feedback.info(self.app, t("read.no_floors_yet"))
+            return
+        self.open_answer(self._visible_answer_index())
+
+    def _visible_answer_index(self) -> int:
+        """视口顶部所在的楼层：首个底部越过视口顶的楼层。
+
+        视口还在标题/描述区时，第一个楼层自然命中（Enter 即进回答 1，
+        新手按键就有反馈，不用先滚）。
+        """
+        top = self._body_scroll().region.y
+        for head in self.query(".floor-head"):
+            if head.region.bottom > top:
+                return int(head.name or 0)
+        return 0
+
+    def open_answer(self, index: int) -> None:
+        """进第 index 条回答（问题屏保持在栈底，Esc 回来阅读位置不变）。"""
+        loader = self.loader
+        if loader is None:
+            return  # 竞态窗口（换篇在途）：action 已拦，这里兜底不炸
+        self.app.push_screen(AnswerScreen(self.source, self.item, loader, index))
+
+    # ---- ←/→ 换篇（机械件在 PagedReadingScreen._retarget）----
+
+    async def action_next_article(self) -> None:
+        await self._retarget(1)
+
+    async def action_prev_article(self) -> None:
+        await self._retarget(-1)
+
+    def _next_target(self, delta: int) -> FeedItem | None:
+        return self._step_item(delta)
+
+    def _no_target_text(self, delta: int) -> str:
+        return t("read.no_next_readable") if delta > 0 else t("read.no_prev_readable")
+
+    async def _adopt_target(self, target: FeedItem) -> None:
+        """收下相邻条目原地重载；列表选中已由 step_readable_item 同步推进，
+        Esc 回列表时正好停在读过的那一篇。"""
+        self.item = target
+        self.run_worker(self._load(), group="load", exclusive=True)

feedscope/ui/screens/language.py

@@ -0,0 +1,59 @@
+"""语言选择弹层：首启设置与日常修改（Ctrl+L）共用一屏。
+
+语言未定时无法翻译「选择语言」这件事本身——标题与提示是全 app 唯一的
+双语文案（两种语言文件里同值，见 core/i18n/*.toml 的 language 段），
+列表行用各语言的自称（[meta] name，永远以该语言书写：简体中文 / English）。
+Enter / 点击返回语言代码，Esc 返回 None：首启流程 None = 沿用缺省继续
+（完成首启时随 enabled 一并落定，不再反复问），日常修改 None = 不动。
+"""
+
+from __future__ import annotations
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import Label, OptionList
+from textual.widgets.option_list import Option
+
+from feedscope.core import i18n
+from feedscope.core.i18n import t
+from feedscope.ui.focus_nav import ArrowModalScreen
+
+
+class LanguageScreen(ArrowModalScreen[str | None]):
+    """语言选择：dismiss 值为语言代码（如 "zh-CN" / "en"），Esc / 取消 = None。"""
+
+    CSS = """
+    #language-dialog { max-width: 56; }
+    #language-title { text-style: bold; padding-bottom: 1; }
+    #language-list { width: auto; min-width: 36; height: auto; }
+    #language-hint { padding-top: 1; color: $text-muted; }
+    """
+
+    def __init__(self, highlight: str = "") -> None:
+        super().__init__()
+        self._langs = i18n.available()
+        self._highlight = highlight  # 预选项：首启传系统猜测，日常修改传当前语言
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="language-dialog", classes="modal-card"):
+            yield Label(t("language.title"), id="language-title")
+            # option id = 语言代码（dismiss 直接回传；代码唯一，id 不撞）
+            yield OptionList(
+                *[Option(lang.name, id=lang.code) for lang in self._langs],
+                id="language-list",
+            )
+            yield Label(t("language.hint"), id="language-hint")
+
+    def on_mount(self) -> None:
+        ol = self.query_one(OptionList)
+        codes = [lang.code for lang in self._langs]
+        if self._highlight in codes:
+            ol.highlighted = codes.index(self._highlight)
+        ol.focus()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        if event.option.id is not None:
+            self.dismiss(event.option.id)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)