vibe-reader 0.2.0__tar.gz → 0.2.2__tar.gz

vibe_reader-0.2.2/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "09:00"
+      timezone: "Etc/UTC"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "09:00"
+      timezone: "Etc/UTC"

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/.github/workflows/publish.yml

@@ -13,18 +13,18 @@ jobs:
       contents: read
 
     steps:
-      - uses: actions/checkout@v6.0.3
+      - uses: actions/checkout@v7.0.1
 
       - name: Set up Python
-        uses: actions/setup-python@v6.2.0
+        uses: actions/setup-python@v7.0.0
         with:
           python-version: '3.13'
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v8.2.0
+        uses: astral-sh/setup-uv@v10.2.0
 
       - name: Build package
         run: uv build
 
       - name: Publish to PyPI
-        uses: pypa/gh-action-pypi-publish@v1.14.0
+        uses: pypa/gh-action-pypi-publish@v1.14.2

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/PKG-INFO

@@ -1,19 +1,19 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: vibe-reader
-Version: 0.2.0
+Version: 0.2.2
 Summary: E-ink friendly web reader for tmux panes, project files, Markdown, and git diffs.
 Author-email: PsychArch <PsychArch@github.com>
 Requires-Python: >=3.13
-Requires-Dist: dulwich==1.2.6
-Requires-Dist: fastapi==0.136.3
-Requires-Dist: libtmux==0.58.0
-Requires-Dist: markdown==3.10.2
-Requires-Dist: pydantic==2.13.4
+Requires-Dist: dulwich==1.2.15
+Requires-Dist: fastapi==0.141.1
+Requires-Dist: libtmux==0.62.0
+Requires-Dist: markdown==3.11
+Requires-Dist: pydantic==2.13.5
 Requires-Dist: pygments==2.20.0
-Requires-Dist: uvicorn==0.49.0
+Requires-Dist: uvicorn==0.54.0
 Provides-Extra: dev
 Requires-Dist: httpx2>=2.4.0; extra == 'dev'
-Requires-Dist: pytest==9.0.3; extra == 'dev'
+Requires-Dist: pytest==9.1.1; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Vibe Reader

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/backend/files.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import AsyncIterator
 
 from fastapi import APIRouter, FastAPI, HTTPException
+from starlette.concurrency import run_in_threadpool
 
 from backend.rendering import render_text_content
 from backend.services.path_service import (
@@ -15,6 +16,9 @@ from backend.services.path_service import (
 
 # Maximum file size to read (10MB)
 MAX_FILE_SIZE = 10 * 1024 * 1024
+MAX_HIGHLIGHT_FILE_SIZE = 512 * 1024
+MAX_MARKDOWN_RENDER_FILE_SIZE = 1024 * 1024
+LARGE_FILE_RENDER_NOTE = "Large file rendered without syntax highlighting."
 
 
 def get_project_root() -> Path:
@@ -37,6 +41,28 @@ async def files_lifespan(_: FastAPI) -> AsyncIterator[None]:
 
 router = APIRouter(prefix="/api/files", tags=["files"], lifespan=files_lifespan)
 
+
+def _should_force_plain_render(path: Path, file_size: int, highlight: bool) -> bool:
+    if path.suffix.lower() in {".md", ".markdown"}:
+        return file_size > MAX_MARKDOWN_RENDER_FILE_SIZE
+    return highlight and file_size > MAX_HIGHLIGHT_FILE_SIZE
+
+
+def _read_and_render_file(target_path: Path, file_size: int, highlight: bool):
+    force_plain = _should_force_plain_render(target_path, file_size, highlight)
+    content = target_path.read_text()
+    render_result = render_text_content(
+        target_path,
+        content,
+        enable_highlighting=highlight,
+        force_plain=force_plain,
+    )
+    metadata = dict(render_result.metadata)
+    if force_plain:
+        metadata["large_file"] = "true"
+        metadata["render_note"] = LARGE_FILE_RENDER_NOTE
+    return render_result, metadata
+
 @router.get("")
 async def list_files(path: str = "."):
     """List files in a directory"""
@@ -67,14 +93,18 @@ async def get_file_content(path: str, highlight: bool = True):
         if file_size > MAX_FILE_SIZE:
             raise HTTPException(status_code=400, detail=f"File too large (max {MAX_FILE_SIZE // 1024 // 1024}MB)")
 
-        content = target_path.read_text()
-        render_result = render_text_content(target_path, content, enable_highlighting=highlight)
+        render_result, metadata = await run_in_threadpool(
+            _read_and_render_file,
+            target_path,
+            file_size,
+            highlight,
+        )
 
         return {
             "path": display_path(project_root, target_path),
             "render_mode": render_result.mode,
             "html": render_result.html,
-            "metadata": render_result.metadata,
+            "metadata": metadata,
         }
     except UnicodeDecodeError:
         raise HTTPException(status_code=400, detail="Cannot read binary file")

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/backend/rendering.py

@@ -28,9 +28,18 @@ class RenderResult:
     metadata: Dict[str, str] = field(default_factory=dict)
 
 
-def render_text_content(path: Path, content: str, enable_highlighting: bool = True) -> RenderResult:
+def render_text_content(
+    path: Path,
+    content: str,
+    enable_highlighting: bool = True,
+    *,
+    force_plain: bool = False,
+) -> RenderResult:
     """Render text content based on file type."""
 
+    if force_plain:
+        return _render_plain(content)
+
     suffix = path.suffix.lower()
     if suffix in _MARKDOWN_EXTENSIONS:
         return _render_markdown(content, enable_highlighting=enable_highlighting)

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/frontend/api.js

@@ -1,8 +1,12 @@
-export async function fetchJSON(url, errorContext) {
+export async function fetchJSON(url, errorContext, options = {}) {
     let response;
     try {
-        response = await fetch(url);
+        response = await fetch(url, options);
     } catch (networkError) {
+        if (networkError.name === 'AbortError') {
+            throw networkError;
+        }
+
         const error = new Error(`${errorContext}: ${networkError.message}`);
         error.context = errorContext;
         error.url = url;
@@ -61,10 +65,11 @@ export function loadFiles(path) {
     return fetchJSON(`/api/files?path=${encodeURIComponent(path)}`, 'load files');
 }
 
-export function loadFileContent(path, { enableHighlighting }) {
+export function loadFileContent(path, { enableHighlighting, signal } = {}) {
     return fetchJSON(
         `/api/files/content?path=${encodeURIComponent(path)}&highlight=${enableHighlighting}`,
-        'load file'
+        'load file',
+        { signal }
     );
 }
 

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/frontend/files-view.js

@@ -48,6 +48,20 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
         return source === 'staged' ? 'Staged' : 'Unstaged';
     }
 
+    function abortPendingFileContentRequest() {
+        if (!state.currentFileAbortController) {
+            return;
+        }
+
+        state.currentFileAbortController.abort();
+        state.currentFileAbortController = null;
+    }
+
+    function invalidateFileContentRequests() {
+        abortPendingFileContentRequest();
+        state.currentFileRequestId += 1;
+    }
+
     function openFile(path, { isDeleted = false } = {}) {
         if (!path) {
             return;
@@ -58,6 +72,7 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
             return;
         }
         if (isDeleted) {
+            invalidateFileContentRequests();
             callbacks.showToast('Enable diff mode to inspect deleted files.');
             contentRenderer.renderDiffPrompt();
             return;
@@ -66,6 +81,8 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
     }
 
     async function loadGitDiff(path, source = state.diffSource) {
+        invalidateFileContentRequests();
+
         if (!path) {
             contentRenderer.renderDiffPrompt();
             return;
@@ -165,6 +182,7 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
                         setCurrentDirectory(parentPath);
                         state.selectedFile = null;
                         state.selectedFileIsDeleted = false;
+                        invalidateFileContentRequests();
                         contentRenderer.resetFilePreview();
                         loadFileList({ forceStatusRefresh: true });
                     }
@@ -187,6 +205,7 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
                             setCurrentDirectory(file.path);
                             state.selectedFile = null;
                             state.selectedFileIsDeleted = false;
+                            invalidateFileContentRequests();
                             contentRenderer.resetFilePreview();
                             loadFileList();
                         } else {
@@ -241,15 +260,38 @@ export function createFilesViewController({ dom, state, viewState, api, contentR
     }
 
     async function loadFileContent(path) {
+        abortPendingFileContentRequest();
+
+        const requestId = ++state.currentFileRequestId;
+        const abortController = new AbortController();
+        state.currentFileAbortController = abortController;
+        contentRenderer.renderInlineMessage(`Loading ${path}...`);
+
         try {
             const config = readConfig();
             const data = await api.loadFileContent(path, {
-                enableHighlighting: config.enableSyntaxHighlighting
+                enableHighlighting: config.enableSyntaxHighlighting,
+                signal: abortController.signal
             });
+
+            if (requestId !== state.currentFileRequestId) {
+                return;
+            }
+
             contentRenderer.renderFileContent(data);
             dom.fileContentContainer.scrollTop = 0;
+            if (data.metadata?.render_note) {
+                callbacks.showToast(data.metadata.render_note);
+            }
         } catch (error) {
+            if (requestId !== state.currentFileRequestId || error.name === 'AbortError') {
+                return;
+            }
             contentRenderer.renderInlineMessage(error.message);
+        } finally {
+            if (requestId === state.currentFileRequestId) {
+                state.currentFileAbortController = null;
+            }
         }
     }
 

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/frontend/state.js

@@ -26,7 +26,9 @@ export function createFilesState() {
         diffSource: 'unstaged',
         currentDiffRequestId: 0,
         selectedFileIsDeleted: false,
-        currentFileRenderToken: 0
+        currentFileRenderToken: 0,
+        currentFileRequestId: 0,
+        currentFileAbortController: null
     };
 }
 

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vibe-reader"
-version = "0.2.0"
+version = "0.2.2"
 description = "E-ink friendly web reader for tmux panes, project files, Markdown, and git diffs."
 readme = "README.md"
 authors = [
@@ -8,13 +8,13 @@ authors = [
 ]
 requires-python = ">=3.13"
 dependencies = [
-    "fastapi==0.136.3",
-    "libtmux==0.58.0",
-    "uvicorn==0.49.0",
+    "fastapi==0.141.1",
+    "libtmux==0.62.0",
+    "uvicorn==0.54.0",
     "Pygments==2.20.0",
-    "markdown==3.10.2",
-    "dulwich==1.2.6",
-    "pydantic==2.13.4",
+    "markdown==3.11",
+    "dulwich==1.2.15",
+    "pydantic==2.13.5",
 ]
 
 [project.scripts]
@@ -22,7 +22,7 @@ vibe-reader = "backend.main:main"
 
 [project.optional-dependencies]
 dev = [
-    "pytest==9.0.3",
+    "pytest==9.1.1",
     "httpx2>=2.4.0",
 ]
 

{vibe_reader-0.2.0 → vibe_reader-0.2.2}/tests/test_files.py

@@ -154,6 +154,64 @@ def test_plain_mode_when_no_lexer(tmp_path):
     assert "line-code" in payload["html"]
 
 
+def test_large_code_file_skips_syntax_highlighting(tmp_path):
+    project_root = tmp_path / "proj"
+    project_root.mkdir()
+    code_file = project_root / "large.py"
+    code_file.write_text("def hello():\n    return 'world'\n" * 20000, encoding="utf-8")
+
+    with client_with_root(project_root) as client:
+        response = client.get(
+            "/api/files/content",
+            params={"path": "large.py"},
+        )
+
+    payload = response.json()
+
+    assert response.status_code == 200
+    assert payload["render_mode"] == "plain"
+    assert "tok-" not in payload["html"]
+    assert payload["metadata"]["large_file"] == "true"
+    assert payload["metadata"]["render_note"] == "Large file rendered without syntax highlighting."
+
+
+def test_large_markdown_file_skips_markdown_rendering(tmp_path):
+    project_root = tmp_path / "proj"
+    project_root.mkdir()
+    markdown_file = project_root / "large.md"
+    markdown_file.write_text("# Heading\n\n```python\nprint('ok')\n```\n\n" * 35000, encoding="utf-8")
+
+    with client_with_root(project_root) as client:
+        response = client.get(
+            "/api/files/content",
+            params={"path": "large.md"},
+        )
+
+    payload = response.json()
+
+    assert response.status_code == 200
+    assert payload["render_mode"] == "plain"
+    assert 'class="md-content"' not in payload["html"]
+    assert "tok-" not in payload["html"]
+    assert payload["metadata"]["large_file"] == "true"
+
+
+def test_file_size_limit_still_rejects_oversized_file(tmp_path):
+    project_root = tmp_path / "proj"
+    project_root.mkdir()
+    large_file = project_root / "too-large.txt"
+    large_file.write_bytes(b"x" * (10 * 1024 * 1024 + 1))
+
+    with client_with_root(project_root) as client:
+        response = client.get(
+            "/api/files/content",
+            params={"path": "too-large.txt"},
+        )
+
+    assert response.status_code == 400
+    assert response.json()["detail"] == "File too large (max 10MB)"
+
+
 def test_list_files_respects_configured_root(tmp_path):
     project_root = tmp_path / "proj"
     project_root.mkdir()

vibe_reader-0.2.2/tests/test_frontend_modules.py

@@ -0,0 +1,185 @@
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_frontend_state_and_tmux_tree_helpers():
+    node = shutil.which("node")
+    if node is None:
+        pytest.skip("node is not available")
+
+    script = r"""
+        import assert from 'node:assert/strict';
+        import {
+            createConfigState,
+            createFilesState,
+            createMermaidState,
+            createTmuxState,
+            createViewState
+        } from './frontend/state.js';
+        import { createFilesViewController } from './frontend/files-view.js';
+        import {
+            findFirstSelectablePane,
+            getSelectedPaneKey
+        } from './frontend/tmux-tree.js';
+
+        function createDeferred() {
+            let resolve;
+            let reject;
+            const promise = new Promise((promiseResolve, promiseReject) => {
+                resolve = promiseResolve;
+                reject = promiseReject;
+            });
+            return { promise, resolve, reject };
+        }
+
+        function createFileControllerHarness(apiOverrides = {}) {
+            const fileState = createFilesState();
+            const calls = {
+                inlineMessages: [],
+                renderedPayloads: [],
+                toasts: []
+            };
+            const dom = {
+                fileContentContainer: { scrollTop: 45 },
+                fileList: { querySelectorAll: () => [] },
+                pageUpFiles: { addEventListener: () => {} },
+                pageDownFiles: { addEventListener: () => {} },
+                loadFiles: { addEventListener: () => {} },
+                diffModeToggle: { addEventListener: () => {} },
+                currentPathDisplay: null
+            };
+            const contentRenderer = {
+                renderInlineMessage: (message) => calls.inlineMessages.push(message),
+                renderFileContent: (payload) => calls.renderedPayloads.push(payload),
+                renderDiffPrompt: (message) => calls.inlineMessages.push(message || 'diff prompt'),
+                resetFilePreview: () => calls.inlineMessages.push('reset')
+            };
+            const controller = createFilesViewController({
+                dom,
+                state: fileState,
+                viewState: createViewState(),
+                api: {
+                    loadFileContent: () => Promise.resolve({ render_mode: 'plain', html: '', metadata: {} }),
+                    loadFiles: () => Promise.resolve([]),
+                    loadGitDiff: () => Promise.resolve({ text: '' }),
+                    ...apiOverrides
+                },
+                contentRenderer,
+                gitStatus: {
+                    getSummary: () => Promise.resolve(null),
+                    invalidate: () => {}
+                },
+                callbacks: {
+                    markInteraction: () => {},
+                    showToast: (message) => calls.toasts.push(message)
+                }
+            });
+            return { calls, controller, dom, fileState };
+        }
+
+        assert.deepEqual(createViewState(), {
+            currentView: 'tmux',
+            sidebarCollapsed: false
+        });
+        assert.equal(createTmuxState().autoRefreshEnabled, false);
+        assert.equal(createFilesState().diffSource, 'unstaged');
+        assert.equal(createFilesState().currentFileRequestId, 0);
+        assert.equal(createFilesState().currentFileAbortController, null);
+        assert.equal(createConfigState().initialized, false);
+        assert.equal(createMermaidState().diagramId, 0);
+
+        assert.equal(getSelectedPaneKey(null), null);
+        assert.equal(
+            getSelectedPaneKey({ session: 'work', window: 1, pane: 2 }),
+            'work\u00001\u00002'
+        );
+        assert.deepEqual(
+            findFirstSelectablePane([
+                { name: 'empty', windows: [] },
+                {
+                    name: 'dev',
+                    windows: [
+                        { index: '0', panes: [] },
+                        { index: '1', panes: [{ index: '3' }] }
+                    ]
+                }
+            ]),
+            { session: 'dev', window: '1', pane: '3' }
+        );
+        assert.equal(findFirstSelectablePane([{ name: 'empty', windows: [] }]), null);
+
+        {
+            const request = createDeferred();
+            let capturedSignal = null;
+            const { calls, controller, dom } = createFileControllerHarness({
+                loadFileContent: (_path, options) => {
+                    capturedSignal = options.signal;
+                    return request.promise;
+                }
+            });
+
+            const pending = controller.loadFileContent('slow.py');
+            assert.equal(calls.inlineMessages.at(-1), 'Loading slow.py...');
+            assert.equal(capturedSignal instanceof AbortSignal, true);
+
+            request.resolve({
+                render_mode: 'plain',
+                html: '<div>ok</div>',
+                metadata: { render_note: 'Large file rendered without syntax highlighting.' }
+            });
+            await pending;
+
+            assert.equal(calls.renderedPayloads.length, 1);
+            assert.equal(dom.fileContentContainer.scrollTop, 0);
+            assert.deepEqual(calls.toasts, ['Large file rendered without syntax highlighting.']);
+        }
+
+        {
+            const requests = [];
+            const { calls, controller } = createFileControllerHarness({
+                loadFileContent: (_path, options) => {
+                    const request = createDeferred();
+                    request.signal = options.signal;
+                    requests.push(request);
+                    return request.promise;
+                }
+            });
+
+            const first = controller.loadFileContent('first.py');
+            const second = controller.loadFileContent('second.py');
+            assert.equal(requests[0].signal.aborted, true);
+
+            requests[0].resolve({ render_mode: 'plain', html: 'first', metadata: {} });
+            await first;
+            assert.equal(calls.renderedPayloads.length, 0);
+
+            requests[1].resolve({ render_mode: 'plain', html: 'second', metadata: {} });
+            await second;
+            assert.equal(calls.renderedPayloads.length, 1);
+            assert.equal(calls.renderedPayloads[0].html, 'second');
+        }
+
+        {
+            const { calls, controller } = createFileControllerHarness({
+                loadFileContent: () => Promise.reject(new DOMException('Aborted', 'AbortError'))
+            });
+
+            await controller.loadFileContent('aborted.py');
+
+            assert.deepEqual(calls.inlineMessages, ['Loading aborted.py...']);
+            assert.equal(calls.renderedPayloads.length, 0);
+        }
+    """
+
+    subprocess.run(
+        [node, "--input-type=module", "-e", script],
+        cwd=PROJECT_ROOT,
+        check=True,
+        text=True,
+    )