vii 0.1.0a1__tar.gz

vii-0.1.0a1/.github/workflows/workflow.yml

@@ -0,0 +1,126 @@
+name: CI/CD
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      publish_to:
+        description: 'Where to publish the package'
+        required: true
+        type: choice
+        options:
+          - 'none'
+          - 'testpypi'
+          - 'pypi'
+        default: 'none'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run pre-commit hooks
+        run: pre-commit run --all-files
+
+      - name: Run tests
+        run: pytest tests/ -v --tb=short
+
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' || github.event_name == 'workflow_dispatch'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    name: Publish to PyPI
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_to == 'pypi')
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/vii
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-to-testpypi:
+    name: Publish to TestPyPI
+    needs: [build]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.publish_to == 'testpypi')
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/vii
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+      - name: Publish distribution to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/

vii-0.1.0a1/.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+.venv
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# OS
+.DS_Store
+Thumbs.db

vii-0.1.0a1/.pre-commit-config.yaml

@@ -0,0 +1,27 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: debug-statements
+      - id: mixed-line-ending
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.5
+    hooks:
+      # Run the linter
+      - id: ruff
+        args: [--fix]
+      # Run the formatter
+      - id: ruff-format
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.19.1
+    hooks:
+      - id: mypy
+        args: ["--ignore-missing-imports", "--no-strict-optional"]

vii-0.1.0a1/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: vii
+Version: 0.1.0a1
+Summary: vii - A terminal-based file browser that opens files in your editor
+Author: Alex Clark
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.0.0
+Requires-Dist: textual>=0.50.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Requires-Dist: textual-dev>=1.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# vii
+
+A terminal-based file browser that opens selected files in your preferred editor.
+
+## Features
+
+- 🗂️ Interactive file browser using Textual's DirectoryTree
+- 🚀 Opens files in your preferred editor (VS Code, Sublime, Vim, etc.)
+- ⌨️ Keyboard-driven interface
+- 🎨 Clean, terminal-based UI
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Run vii from any directory:
+
+```bash
+vii
+```
+
+Or specify a directory to browse:
+
+```bash
+vii /path/to/project
+```
+
+## Keyboard Shortcuts
+
+Vi-style navigation (arrow keys also work):
+
+- `j/k` - Navigate down/up
+- `h/l` - Collapse/expand directories
+- `g` - Jump to top
+- `G` - Jump to bottom
+- `Enter` - Open selected file in editor
+- `q` - Quit
+- `Ctrl+C` - Quit
+
+## Editor Detection
+
+vii automatically detects your preferred editor by checking:
+1. `$VISUAL` environment variable
+2. `$EDITOR` environment variable
+3. Common editors: `code`, `subl`, `atom`, `vim`, `nvim`, `nano`
+4. Falls back to `open` (macOS default)
+
+### Editor Behavior
+
+- **GUI Editors** (VS Code, Sublime, etc.): Opens in the background while vii continues running
+- **Terminal Editors** (vim, nvim, nano, etc.): vii suspends and the editor takes over full screen. When you quit the editor, vii resumes automatically
+
+## Development
+
+Run with Textual's development console:
+
+```bash
+textual console
+textual run --dev src/vii/app.py
+```
+
+## License
+
+MIT

vii-0.1.0a1/README.md

@@ -0,0 +1,74 @@
+# vii
+
+A terminal-based file browser that opens selected files in your preferred editor.
+
+## Features
+
+- 🗂️ Interactive file browser using Textual's DirectoryTree
+- 🚀 Opens files in your preferred editor (VS Code, Sublime, Vim, etc.)
+- ⌨️ Keyboard-driven interface
+- 🎨 Clean, terminal-based UI
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+For development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Usage
+
+Run vii from any directory:
+
+```bash
+vii
+```
+
+Or specify a directory to browse:
+
+```bash
+vii /path/to/project
+```
+
+## Keyboard Shortcuts
+
+Vi-style navigation (arrow keys also work):
+
+- `j/k` - Navigate down/up
+- `h/l` - Collapse/expand directories
+- `g` - Jump to top
+- `G` - Jump to bottom
+- `Enter` - Open selected file in editor
+- `q` - Quit
+- `Ctrl+C` - Quit
+
+## Editor Detection
+
+vii automatically detects your preferred editor by checking:
+1. `$VISUAL` environment variable
+2. `$EDITOR` environment variable
+3. Common editors: `code`, `subl`, `atom`, `vim`, `nvim`, `nano`
+4. Falls back to `open` (macOS default)
+
+### Editor Behavior
+
+- **GUI Editors** (VS Code, Sublime, etc.): Opens in the background while vii continues running
+- **Terminal Editors** (vim, nvim, nano, etc.): vii suspends and the editor takes over full screen. When you quit the editor, vii resumes automatically
+
+## Development
+
+Run with Textual's development console:
+
+```bash
+textual console
+textual run --dev src/vii/app.py
+```
+
+## License
+
+MIT

vii-0.1.0a1/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vii"
+version = "0.1.0a1"
+description = "vii - A terminal-based file browser that opens files in your editor"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Alex Clark"},
+]
+dependencies = [
+    "textual>=0.50.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "textual-dev>=1.0.0",
+    "pre-commit>=3.0.0",
+    "ruff>=0.8.0",
+    "mypy>=1.0.0",
+]
+
+[project.scripts]
+vii = "vii.app:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/vii"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "UP",  # pyupgrade
+]
+ignore = []
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

vii-0.1.0a1/src/vii/__init__.py

@@ -0,0 +1,3 @@
+"""vii - A terminal-based file browser."""
+
+__version__ = "0.1.0a1"

vii-0.1.0a1/src/vii/app.py

@@ -0,0 +1,227 @@
+"""Main application entry point for vii."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from textual import events
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import DirectoryTree, Footer, Header, Static
+
+
+class Vii(App):
+    """vii - Terminal file browser."""
+
+    TITLE = "vii"
+
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 2 1;
+        grid-columns: 1fr 2fr;
+    }
+
+    #sidebar {
+        width: 100%;
+        height: 100%;
+        border-right: solid $primary;
+    }
+
+    #main-content {
+        width: 100%;
+        height: 100%;
+        padding: 1 2;
+    }
+
+    DirectoryTree {
+        width: 100%;
+        height: 100%;
+    }
+
+    .info-text {
+        color: $text-muted;
+        text-style: italic;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", priority=True),
+        Binding("ctrl+c", "quit", "Quit", show=False),
+        # Vi-style navigation (shown in footer)
+        Binding("j", "cursor_down", "Down"),
+        Binding("k", "cursor_up", "Up"),
+        Binding("h", "cursor_left", "Collapse"),
+        Binding("l", "cursor_right", "Expand"),
+        Binding("g", "scroll_home", "Top"),
+        Binding("G", "scroll_end", "Bottom"),
+        # Arrow keys still work but hidden from footer
+        Binding("down", "cursor_down", "Down", show=False),
+        Binding("up", "cursor_up", "Up", show=False),
+        Binding("left", "cursor_left", "Left", show=False),
+        Binding("right", "cursor_right", "Right", show=False),
+    ]
+
+    def __init__(self, start_path: Path | None = None):
+        super().__init__()
+        self.start_path = start_path or Path.cwd()
+        self.editor_command = self._detect_editor()
+        self.is_terminal_editor = self._is_terminal_editor()
+
+    def _detect_editor(self) -> list[str]:
+        """Detect the user's preferred editor."""
+        # Check common environment variables
+        editor = None
+        for env_var in ["VISUAL", "EDITOR"]:
+            editor = os.environ.get(env_var)
+            if editor:
+                break
+
+        if not editor:
+            # Try common GUI editors first, then terminal editors
+            for cmd in ["code", "subl", "atom", "vim", "nvim", "nano"]:
+                try:
+                    subprocess.run(
+                        ["which", cmd],
+                        capture_output=True,
+                        check=True,
+                    )
+                    editor = cmd
+                    break
+                except subprocess.CalledProcessError:
+                    continue
+
+        return [editor] if editor else ["open"]
+
+    def _is_terminal_editor(self) -> bool:
+        """Check if the detected editor is a terminal-based editor."""
+        if not self.editor_command:
+            return False
+
+        terminal_editors = {
+            "vim",
+            "nvim",
+            "vi",
+            "nano",
+            "emacs",
+            "micro",
+            "helix",
+            "hx",
+            "joe",
+            "ne",
+            "ed",
+            "ex",
+        }
+
+        editor_name = Path(self.editor_command[0]).name
+        return editor_name in terminal_editors
+
+    def compose(self) -> ComposeResult:
+        """Compose the UI."""
+        yield Header()
+
+        with Horizontal():
+            with Vertical(id="sidebar"):
+                yield DirectoryTree(str(self.start_path))
+
+            with Vertical(id="main-content"):
+                editor_type = "terminal" if self.is_terminal_editor else "GUI"
+                yield Static(
+                    "Select a file from the tree to open it in your editor.\n\n"
+                    f"Editor: {' '.join(self.editor_command)} ({editor_type})",
+                    classes="info-text",
+                )
+
+        yield Footer()
+
+    def on_key(self, event: events.Key) -> None:
+        """Handle key presses for vi-style navigation."""
+        tree = self.query_one(DirectoryTree)
+
+        # Map vi keys to actions
+        key_map = {
+            "j": "down",
+            "k": "up",
+            "h": "left",
+            "l": "right",
+            "g": "home",
+            "G": "end",
+        }
+
+        if event.key in key_map:
+            # Prevent the key from being processed further
+            event.prevent_default()
+            # Simulate the corresponding arrow key or action
+            action_key = key_map[event.key]
+            if action_key == "down":
+                tree.action_cursor_down()
+            elif action_key == "up":
+                tree.action_cursor_up()
+            elif action_key == "left":
+                tree.action_cursor_left()
+            elif action_key == "right":
+                tree.action_cursor_right()
+            elif action_key == "home":
+                tree.action_scroll_home()
+            elif action_key == "end":
+                tree.action_scroll_end()
+
+    def on_directory_tree_file_selected(self, event: DirectoryTree.FileSelected) -> None:
+        """Handle file selection from the directory tree."""
+        file_path = event.path
+        self._open_in_editor(file_path)
+
+    def _open_in_editor(self, file_path: Path) -> None:
+        """Open a file in the user's editor."""
+        if self.is_terminal_editor:
+            self._open_in_terminal_editor(file_path)
+        else:
+            self._open_in_gui_editor(file_path)
+
+    def _open_in_terminal_editor(self, file_path: Path) -> None:
+        """Open a file in a terminal editor by suspending the app."""
+        try:
+            # Suspend the Textual app to give control back to the terminal
+            with self.suspend():
+                # Run the editor and wait for it to complete
+                result = subprocess.run(
+                    [*self.editor_command, str(file_path)],
+                )
+                if result.returncode != 0:
+                    self.notify(
+                        f"Editor exited with code {result.returncode}",
+                        severity="warning",
+                    )
+        except Exception as e:
+            self.notify(f"Error opening file: {e}", severity="error")
+
+    def _open_in_gui_editor(self, file_path: Path) -> None:
+        """Open a file in a GUI editor (non-blocking)."""
+        try:
+            subprocess.Popen(
+                [*self.editor_command, str(file_path)],
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+            self.notify(f"Opened: {file_path.name}", severity="information")
+        except Exception as e:
+            self.notify(f"Error opening file: {e}", severity="error")
+
+
+def main():
+    """Main entry point."""
+    start_path = Path(sys.argv[1]) if len(sys.argv) > 1 else Path.cwd()
+
+    if not start_path.exists():
+        print(f"Error: Path '{start_path}' does not exist", file=sys.stderr)
+        sys.exit(1)
+
+    app = Vii(start_path=start_path)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

vii-0.1.0a1/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for vii."""

vii-0.1.0a1/tests/test_app.py

@@ -0,0 +1,269 @@
+"""Tests for the main vii application."""
+
+import os
+import subprocess
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import pytest
+from textual.widgets import DirectoryTree
+
+from vii.app import Vii, main
+
+
+class TestVii:
+    """Test cases for the Vii class."""
+
+    def test_init_with_default_path(self):
+        """Test initialization with default path."""
+        app = Vii()
+        assert app.start_path == Path.cwd()
+        assert isinstance(app.editor_command, list)
+        assert len(app.editor_command) > 0
+
+    def test_init_with_custom_path(self, tmp_path):
+        """Test initialization with custom path."""
+        app = Vii(start_path=tmp_path)
+        assert app.start_path == tmp_path
+
+    @patch.dict(os.environ, {"VISUAL": "vim"})
+    def test_detect_editor_visual_env(self):
+        """Test editor detection using VISUAL environment variable."""
+        app = Vii()
+        assert app.editor_command == ["vim"]
+
+    @patch.dict(os.environ, {"EDITOR": "nano"}, clear=True)
+    def test_detect_editor_editor_env(self):
+        """Test editor detection using EDITOR environment variable."""
+        app = Vii()
+        assert app.editor_command == ["nano"]
+
+    @patch.dict(os.environ, {}, clear=True)
+    @patch("subprocess.run")
+    def test_detect_editor_which_code(self, mock_run):
+        """Test editor detection using 'which' command for VS Code."""
+        # First call to 'which code' succeeds
+        mock_run.return_value = Mock(returncode=0)
+        app = Vii()
+        assert app.editor_command == ["code"]
+
+    @patch.dict(os.environ, {}, clear=True)
+    @patch("subprocess.run")
+    def test_detect_editor_fallback_to_open(self, mock_run):
+        """Test editor detection fallback to 'open'."""
+        # All 'which' commands fail
+        mock_run.side_effect = subprocess.CalledProcessError(1, "which")
+        app = Vii()
+        assert app.editor_command == ["open"]
+
+    def test_is_terminal_editor_vim(self):
+        """Test detection of vim as terminal editor."""
+        app = Vii()
+        app.editor_command = ["vim"]
+        assert app._is_terminal_editor() is True
+
+    def test_is_terminal_editor_nvim(self):
+        """Test detection of nvim as terminal editor."""
+        app = Vii()
+        app.editor_command = ["nvim"]
+        assert app._is_terminal_editor() is True
+
+    def test_is_terminal_editor_code(self):
+        """Test detection of VS Code as GUI editor."""
+        app = Vii()
+        app.editor_command = ["code"]
+        assert app._is_terminal_editor() is False
+
+    def test_is_terminal_editor_with_path(self):
+        """Test detection works with full paths."""
+        app = Vii()
+        app.editor_command = ["/usr/bin/vim"]
+        assert app._is_terminal_editor() is True
+
+    def test_open_in_gui_editor_success(self, tmp_path):
+        """Test successfully opening a file in GUI editor."""
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("test content")
+
+        app = Vii(start_path=tmp_path)
+        app.editor_command = ["test-editor"]
+        app.is_terminal_editor = False
+
+        # Mock Popen and notify after app initialization
+        with (
+            patch("subprocess.Popen") as mock_popen,
+            patch.object(app, "notify") as mock_notify,
+        ):
+            app._open_in_editor(test_file)
+
+            # Verify Popen was called with correct arguments
+            mock_popen.assert_called_once_with(
+                ["test-editor", str(test_file)],
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+
+            # Verify notification was sent
+            mock_notify.assert_called_once_with(f"Opened: {test_file.name}", severity="information")
+
+    @patch("subprocess.run")
+    def test_open_in_terminal_editor_success(self, mock_run, tmp_path):
+        """Test successfully opening a file in terminal editor."""
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("test content")
+
+        # Mock successful editor run
+        mock_run.return_value = Mock(returncode=0)
+
+        app = Vii(start_path=tmp_path)
+        app.editor_command = ["vim"]
+        app.is_terminal_editor = True
+
+        # Mock the suspend method to avoid actually suspending
+        with patch.object(app, "suspend") as mock_suspend:
+            mock_suspend.return_value.__enter__ = Mock()
+            mock_suspend.return_value.__exit__ = Mock(return_value=False)
+
+            app._open_in_editor(test_file)
+
+            # Verify subprocess.run was called with the file
+            # Note: mock_run is called during __init__ for editor detection too
+            # So we check the last call
+            assert mock_run.call_args == ((["vim", str(test_file)],), {})
+
+    @patch("subprocess.run")
+    def test_open_in_terminal_editor_nonzero_exit(self, mock_run, tmp_path):
+        """Test terminal editor with non-zero exit code."""
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("test content")
+
+        # Mock editor run with non-zero exit
+        mock_run.return_value = Mock(returncode=1)
+
+        app = Vii(start_path=tmp_path)
+        app.editor_command = ["vim"]
+        app.is_terminal_editor = True
+
+        with (
+            patch.object(app, "suspend") as mock_suspend,
+            patch.object(app, "notify") as mock_notify,
+        ):
+            mock_suspend.return_value.__enter__ = Mock()
+            mock_suspend.return_value.__exit__ = Mock(return_value=False)
+
+            app._open_in_editor(test_file)
+
+            # Verify warning notification was sent
+            mock_notify.assert_called_once()
+            call_args = mock_notify.call_args
+            assert "exited with code" in call_args[0][0]
+            assert call_args[1]["severity"] == "warning"
+
+    def test_open_in_gui_editor_failure(self, tmp_path):
+        """Test handling of GUI editor opening failure."""
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("test content")
+
+        app = Vii(start_path=tmp_path)
+        app.editor_command = ["nonexistent-editor"]
+        app.is_terminal_editor = False
+
+        # Mock Popen to raise an exception and notify after app initialization
+        with (
+            patch("subprocess.Popen") as mock_popen,
+            patch.object(app, "notify") as mock_notify,
+        ):
+            # Make Popen raise an exception
+            mock_popen.side_effect = OSError("Editor not found")
+
+            app._open_in_editor(test_file)
+
+            # Verify error notification was sent
+            mock_notify.assert_called_once()
+            call_args = mock_notify.call_args
+            assert "Error opening file" in call_args[0][0]
+            assert call_args[1]["severity"] == "error"
+
+    async def test_compose(self, tmp_path):
+        """Test UI composition."""
+        app = Vii(start_path=tmp_path)
+        async with app.run_test():
+            # Check that the directory tree is present
+            tree = app.query_one(DirectoryTree)
+            assert tree is not None
+
+            # Check that the static info text is present
+            from textual.widgets import Static
+
+            statics = app.query(Static)
+            # Should have at least one Static widget with our info text
+            assert len(statics) > 0
+            # Find the one with our text
+            found_info_text = False
+            for static in statics:
+                if hasattr(static, "render") and "Select a file" in str(static.render()):
+                    found_info_text = True
+                    break
+            assert found_info_text
+
+    async def test_file_selection(self, tmp_path):
+        """Test file selection triggers editor opening."""
+        # Create a test file
+        test_file = tmp_path / "test.txt"
+        test_file.write_text("test content")
+
+        app = Vii(start_path=tmp_path)
+
+        with patch.object(app, "_open_in_editor") as mock_open:
+            async with app.run_test():
+                # Simulate file selection
+                tree = app.query_one(DirectoryTree)
+                event = DirectoryTree.FileSelected(tree, test_file)
+                app.on_directory_tree_file_selected(event)
+
+                # Verify _open_in_editor was called
+                mock_open.assert_called_once_with(test_file)
+
+
+class TestMain:
+    """Test cases for the main entry point."""
+
+    @patch("vii.app.Vii")
+    def test_main_default_path(self, mock_vii_class):
+        """Test main function with default path."""
+        mock_app = Mock()
+        mock_vii_class.return_value = mock_app
+
+        with patch("sys.argv", ["vii"]):
+            main()
+
+        mock_vii_class.assert_called_once()
+        call_args = mock_vii_class.call_args
+        assert call_args[1]["start_path"] == Path.cwd()
+        mock_app.run.assert_called_once()
+
+    @patch("vii.app.Vii")
+    def test_main_custom_path(self, mock_vii_class, tmp_path):
+        """Test main function with custom path."""
+        mock_app = Mock()
+        mock_vii_class.return_value = mock_app
+
+        with patch("sys.argv", ["vii", str(tmp_path)]):
+            main()
+
+        mock_vii_class.assert_called_once()
+        call_args = mock_vii_class.call_args
+        assert call_args[1]["start_path"] == tmp_path
+        mock_app.run.assert_called_once()
+
+    def test_main_nonexistent_path(self, capsys):
+        """Test main function with nonexistent path."""
+        with patch("sys.argv", ["vii", "/nonexistent/path"]):
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+
+            assert exc_info.value.code == 1
+
+            captured = capsys.readouterr()
+            assert "does not exist" in captured.err