logtap 0.1.0__py3-none-any.whl

logtap/__init__.py

@@ -0,0 +1,7 @@
+"""logtap: 跨平台命令行工具箱。
+
+当前提供的子命令：
+    logtap read <file>  纯终端小说(.txt)阅读器
+"""
+
+__version__ = "0.1.0"

logtap/cli.py

@@ -0,0 +1,54 @@
+"""logtap 主命令行入口，负责解析子命令并分发。
+
+当前仅有 read 子命令；后续新增其他 logtap 功能时，在此文件追加新的
+subparser 即可，read 相关实现始终保持在 logtap.read 包内部，不与
+其他子命令耦合。
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import List, Optional
+
+from logtap import __version__
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="logtap",
+        description="logtap: 跨平台终端工具箱",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"logtap {__version__}"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    read_parser = subparsers.add_parser(
+        "read", help="纯终端小说(.txt)阅读器"
+    )
+    read_parser.add_argument(
+        "path",
+        nargs="?",
+        default=None,
+        help="要打开的 .txt 文件路径；留空则在当前目录选择",
+    )
+
+    return parser
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "read":
+        from logtap.read import run as run_reader
+
+        return run_reader(args.path)
+
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

logtap/read/__init__.py

@@ -0,0 +1,8 @@
+"""logtap.read 子包：纯终端小说阅读器。
+
+对外暴露 run(path) 作为 CLI 层的统一入口。
+"""
+
+from logtap.read.app import run
+
+__all__ = ["run"]

logtap/read/app.py

@@ -0,0 +1,266 @@
+"""Textual 主应用：简化版日志风格小说阅读器。
+
+核心交互：
+    - w/s 翻页
+    - ↑/↓ 滚动
+    - g 跳转行号
+    - m 添加/移除书签
+    - t 切换主题
+    - q 退出保存
+"""
+
+import os
+import time
+from typing import List, Optional, Set
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.reactive import reactive
+from textual.widgets import Footer
+
+from logtap.read import themes
+from logtap.read.log_style_render import LogStyleText
+from logtap.read.reader_core import Document
+from logtap.read.storage import Storage
+
+
+class NovelReaderApp(App):
+    """日志风格小说阅读器 Textual 应用（简化版）。"""
+
+    CSS = themes.LOG_THEME_CSS
+
+    BINDINGS = [
+        Binding("up,k", "scroll_up", "向上", show=True),
+        Binding("down,j", "scroll_down", "向下", show=True),
+        Binding("w", "page_up", "上一页", show=True),
+        Binding("s", "page_down", "下一页", show=True),
+        Binding("g", "goto_line", "跳转", show=True),
+        Binding("m", "toggle_bookmark", "书签", show=True),
+        Binding("d", "cycle_disguise", "伪装", show=True),
+        Binding("t", "cycle_theme", "主题", show=True),
+        Binding("q", "quit_app", "退出", show=True),
+    ]
+
+    # 响应式状态
+    theme_key: reactive[str] = reactive("log")
+    disguise_mode: reactive[str] = reactive("log")  # "log" / "ai" / "off"
+    current_line: reactive[int] = reactive(0)
+
+    def __init__(
+        self,
+        novel_path: str,
+        storage: Storage,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.novel_path = novel_path
+        self.storage = storage
+        self.document: Optional[Document] = None
+        self.text_widget: Optional[LogStyleText] = None
+        self.scroll_container: Optional[VerticalScroll] = None
+        self.bookmarks: Set[int] = set()
+        self._lines: List[tuple] = []
+        self._lines_per_page = 20  # 每页显示行数
+
+    def compose(self) -> ComposeResult:
+        """构建 UI 组件树。"""
+        with VerticalScroll(id="text-container") as scroll:
+            self.scroll_container = scroll
+            self.text_widget = LogStyleText(id="log-text")
+            yield self.text_widget
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """应用启动时加载文档并恢复进度。"""
+        try:
+            self.document = Document(self.novel_path)
+        except Exception as e:
+            self.exit(message=f"文件加载失败: {e}")
+            return
+
+        # 恢复进度和书签
+        record = self.storage.get_book_record(self.novel_path)
+        self.current_line = record.progress.line_index
+        self.bookmarks = {bm.line_index for bm in record.bookmarks}
+
+        # 恢复主题
+        saved_theme = self.storage.settings.theme
+        if saved_theme in themes.THEME_KEYS:
+            self.theme_key = saved_theme
+            self.CSS = themes.get_theme_css(saved_theme)
+
+        # 加载全部文本行
+        self._load_text_lines()
+        self._render_current_page()
+
+        # 启动定时更新状态行
+        self.set_interval(5.0, self._update_status_line)
+
+    def _load_text_lines(self) -> None:
+        """从 Document 加载所有行，标记类型（章节/正文/空行）。
+
+        性能优化：不预加载全部内容到内存，只构建行索引。
+        实际渲染时才调用 document.get_line() 按需读取。
+        """
+        lines = []
+        chapter_starts = {ch.start_line for ch in self.document.chapters}
+        # 只构建元数据，不读取实际内容
+        for i in range(self.document.line_count):
+            if i in chapter_starts:
+                lines.append(("chapter", i))  # 存储行号而非内容
+            else:
+                lines.append(("text", i))  # 存储行号而非内容
+        self._lines = lines
+
+    def _render_current_page(self) -> None:
+        """渲染当前页的文本行（按需读取内容，不预加载）。"""
+        if not self.text_widget or not self.document:
+            return
+
+        start = max(0, self.current_line)
+        end = min(len(self._lines), start + self._lines_per_page)
+
+        # 按需读取当前页的实际内容
+        page_lines = []
+        for line_type, line_index in self._lines[start:end]:
+            raw_content = self.document.get_line(line_index)
+            if line_type == "chapter":
+                page_lines.append(("chapter", raw_content))
+            elif raw_content.strip() == "":
+                page_lines.append(("empty", ""))
+            else:
+                page_lines.append(("text", raw_content))
+
+        self.text_widget.set_lines(page_lines)
+        self.text_widget.set_bookmarks(self.bookmarks)
+        self.text_widget.set_disguise_mode(self.disguise_mode)  # 同步伪装模式
+        self._update_status_line()
+
+    def _update_status_line(self) -> None:
+        """更新状态栏，显示进度/章节/时间/伪装模式。"""
+        if not self.document or not self.text_widget:
+            return
+        progress = (self.current_line / max(self.document.line_count, 1)) * 100
+        chapter = self.document.chapter_at_line(self.current_line)
+        chapter_name = chapter.title if chapter else "N/A"
+        time_str = time.strftime("%H:%M:%S")
+
+        # 伪装模式标签
+        mode_labels = {"log": "日志模式", "ai": "AI模式", "off": "关闭"}
+        mode_label = mode_labels.get(self.disguise_mode, "未知")
+
+        status = (
+            f"Progress: {progress:.1f}% | Chapter: {chapter_name} | "
+            f"Line: {self.current_line + 1}/{self.document.line_count} | "
+            f"Disguise: {mode_label} | Time: {time_str}"
+        )
+        self.text_widget.set_status(status)
+
+    # ----------------------------------------------------------------
+    # 快捷键动作
+    # ----------------------------------------------------------------
+    def action_scroll_up(self) -> None:
+        """向上滚动一行。"""
+        if self.current_line > 0:
+            self.current_line -= 1
+            self._render_current_page()
+
+    def action_scroll_down(self) -> None:
+        """向下滚动一行。"""
+        if self.current_line < self.document.line_count - 1:
+            self.current_line += 1
+            self._render_current_page()
+
+    def action_page_up(self) -> None:
+        """向上翻页。"""
+        self.current_line = max(0, self.current_line - self._lines_per_page)
+        self._render_current_page()
+
+    def action_page_down(self) -> None:
+        """向下翻页。"""
+        self.current_line = min(
+            self.document.line_count - 1,
+            self.current_line + self._lines_per_page
+        )
+        self._render_current_page()
+
+    def action_goto_line(self) -> None:
+        """跳转到指定行号（简化：直接通知输入提示，不弹窗）。"""
+        # 移除复杂的 push_screen 弹窗，改用通知提示用户
+        self.notify("跳转功能：输入 'g数字' 如 'g100' 跳转到第100行（开发中）", severity="information")
+
+    def _do_goto(self, value: str) -> None:
+        """执行跳转（保留接口，暂不使用）。"""
+        if value.isdigit():
+            line_num = int(value) - 1
+            if 0 <= line_num < self.document.line_count:
+                self.current_line = line_num
+                self._render_current_page()
+                self.notify(f"已跳转到行 {line_num + 1}")
+
+    def action_toggle_bookmark(self) -> None:
+        """在当前行添加/移除书签。"""
+        if self.current_line in self.bookmarks:
+            self.bookmarks.remove(self.current_line)
+            self.storage.get_book_record(self.novel_path).bookmarks = [
+                bm for bm in self.storage.get_book_record(self.novel_path).bookmarks
+                if bm.line_index != self.current_line
+            ]
+            self.storage.save()
+            self.notify(f"已移除书签 (行 {self.current_line + 1})")
+        else:
+            self.bookmarks.add(self.current_line)
+            self.storage.add_bookmark(self.novel_path, self.current_line, "")
+            self.notify(f"已添加书签 (行 {self.current_line + 1})")
+        self._render_current_page()
+
+    def action_cycle_theme(self) -> None:
+        """循环切换主题。"""
+        self.theme_key = themes.next_theme_key(self.theme_key)
+        new_css = themes.get_theme_css(self.theme_key)
+        self.stylesheet.parse(new_css)
+        self.storage.set_theme(self.theme_key)
+        label = themes.get_theme_label(self.theme_key)
+        self.notify(f"主题: {label}")
+
+    def action_cycle_disguise(self) -> None:
+        """循环切换伪装模式：日志 → AI → 关闭 → 日志。"""
+        modes = ["log", "ai", "off"]
+        try:
+            idx = modes.index(self.disguise_mode)
+        except ValueError:
+            idx = 0
+        self.disguise_mode = modes[(idx + 1) % len(modes)]
+
+        mode_labels = {"log": "日志模式", "ai": "AI助手模式", "off": "关闭伪装"}
+        self.notify(f"伪装: {mode_labels[self.disguise_mode]}")
+        self._render_current_page()  # 重新渲染以应用新模式
+
+    def action_quit_app(self) -> None:
+        """退出并保存进度。"""
+        if self.document:
+            self.storage.save_progress(
+                self.novel_path, self.current_line, self.document.encoding
+            )
+        self.exit()
+
+
+def run(path: Optional[str] = None) -> int:
+    """logtap read 子命令入口（Textual 版本）。"""
+    if path is None:
+        print("请指定要打开的 .txt 文件路径")
+        return 1
+
+    if not os.path.exists(path):
+        print(f"文件不存在: {path}")
+        return 1
+
+    if not path.lower().endswith(".txt"):
+        print("仅支持 .txt 文本文件")
+        return 1
+
+    storage = Storage()
+    app = NovelReaderApp(novel_path=os.path.abspath(path), storage=storage)
+    app.run()
+    return 0

logtap/read/disguise.py

@@ -0,0 +1,141 @@
+"""伪装模式渲染逻辑：日志模式 / AI助手模式。
+
+核心设计：
+    - 日志模式：强制分段 + 每行时间戳 + 日志级别 + 高频噪音（40%）
+    - AI模式：连续thinking/diff块 + 段落化输出 + 高频噪音（50%）
+    - 真实感优先：模拟实际工作场景的输出特征
+"""
+
+import random
+import re
+import time
+from typing import List, Tuple
+
+# 模拟系统日志噪音库（日志模式）
+LOG_NOISE_TEMPLATES = [
+    "[INFO] Database connection pool: 8/20 active",
+    "[DEBUG] Cache hit ratio: {:.1f}%",
+    "[INFO] Request processed in {:.2f}ms",
+    "[WARN] Memory usage: {}MB / 2048MB",
+    "[DEBUG] Session cleanup completed",
+    "[INFO] Background task scheduler running",
+    "[DEBUG] API rate limit: {}/1000 requests",
+    "[INFO] Health check passed",
+    "[WARN] Slow query detected: {}ms",
+    "[DEBUG] Connection from {}",
+]
+
+# 模拟AI思考/状态噪音库（AI模式）
+AI_NOISE_TEMPLATES = [
+    "<thinking>分析需求中...</thinking>",
+    "<thinking>检查代码结构...</thinking>",
+    "# 生成实现方案",
+    "# 验证逻辑正确性",
+    "[assistant] 好的，我来帮你实现这个功能。",
+    "[user] 这段代码有什么问题？",
+    "```diff",
+    "// 重构后的实现",
+    "/* 优化性能 */",
+]
+
+# 随机IP地址池
+IP_POOL = ["192.168.1.{}".format(i) for i in range(10, 50)]
+
+
+def generate_timestamp() -> str:
+    """生成当前时间戳（日志格式）。"""
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def generate_log_noise() -> str:
+    """生成一条随机系统日志噪音。"""
+    template = random.choice(LOG_NOISE_TEMPLATES)
+    if "{}" in template or "{:" in template:
+        # 填充随机数据
+        if "Cache hit" in template:
+            return template.format(random.uniform(75.0, 95.0))
+        elif "processed in" in template:
+            return template.format(random.uniform(5.0, 50.0))
+        elif "Memory usage" in template:
+            return template.format(random.randint(512, 1800))
+        elif "rate limit" in template:
+            return template.format(random.randint(100, 800))
+        elif "Slow query" in template:
+            return template.format(random.randint(200, 800))
+        elif "Connection from" in template:
+            return template.format(random.choice(IP_POOL))
+    return template
+
+
+def generate_ai_noise() -> str:
+    """生成一条随机AI助手状态/思考噪音。"""
+    return random.choice(AI_NOISE_TEMPLATES)
+
+
+def should_insert_noise(probability: float = 0.4) -> bool:
+    """根据概率决定是否插入噪音行（提升到40%）。"""
+    return random.random() < probability
+
+
+def should_add_timestamp(probability: float = 1.0) -> bool:
+    """根据概率决定是否给正文行加时间戳（日志模式必加）。"""
+    return random.random() < probability
+
+
+def should_render_as_diff(probability: float = 0.5) -> bool:
+    """根据概率决定是否将正文渲染成diff格式（AI模式提升到50%）。"""
+    return random.random() < probability
+
+
+def get_random_log_level() -> Tuple[str, str]:
+    """随机返回一个日志级别标签及其颜色样式。
+
+    返回: (标签, Rich样式)
+    """
+    levels = [
+        ("[INFO]", "blue"),
+        ("[DEBUG]", "dim cyan"),
+        ("[WARN]", "yellow"),
+        ("[ERROR]", "red"),
+    ]
+    weights = [0.5, 0.3, 0.15, 0.05]  # INFO最常见，ERROR最少
+    choice = random.choices(levels, weights=weights, k=1)[0]
+    return choice
+
+
+def wrap_as_diff_line(content: str, is_add: bool) -> Tuple[str, str]:
+    """将正文包装成diff格式。
+
+    Args:
+        content: 原始文本
+        is_add: True=新增行(+绿色), False=删除行(-红色)
+
+    Returns:
+        (prefix, style) 例如 ("+ ", "green") 或 ("- ", "red")
+    """
+    if is_add:
+        return ("+ ", "green")
+    else:
+        return ("- ", "red")
+
+
+def insert_ai_thinking_block(lines: List[Tuple[str, str]], index: int) -> None:
+    """在指定位置插入一条AI思考链路噪音。
+
+    Args:
+        lines: 待渲染的行列表 [(line_type, content), ...]
+        index: 插入位置
+    """
+    thinking = generate_ai_noise()
+    lines.insert(index, ("ai_noise", thinking))
+
+
+def insert_log_noise_line(lines: List[Tuple[str, str]], index: int) -> None:
+    """在指定位置插入一条系统日志噪音。
+
+    Args:
+        lines: 待渲染的行列表 [(line_type, content), ...]
+        index: 插入位置
+    """
+    log_line = generate_log_noise()
+    lines.insert(index, ("log_noise", log_line))