chore: govulncheck bumps (#1004)

Signed-off-by: drew <me@andrinoff.com>

.editorconfig

@@ -0,0 +1,18 @@
+# https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+
+[*.go]
+indent_style = tab
+indent_size = 8
+
+[*.golden]
+insert_final_newline = false
+trim_trailing_whitespace = false

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Setup**
+Please complete the following information along with version numbers, if applicable.
+ - OS [e.g. Ubuntu, macOS]
+ - Shell [e.g. zsh, fish]
+ - Terminal Emulator [e.g. kitty, iterm]
+ - Terminal Multiplexer [e.g. tmux]
+ - Locale [e.g. en_US.UTF-8, zh_CN.UTF-8, etc.]
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Source Code**
+Please include source code if needed to reproduce the behavior. 
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+Add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+- name: Discord
+  url: https://charm.sh/discord
+  about: Chat on our Discord.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/dependabot.yml

@@ -0,0 +1,57 @@
+version: 2
+
+updates:
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "05:00"
+      timezone: "America/New_York"
+    labels:
+      - "dependencies"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      all:
+        patterns:
+          - "*"
+    ignore:
+      - dependency-name: github.com/charmbracelet/bubbletea/v2
+        versions:
+          - v2.0.0-beta1
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "05:00"
+      timezone: "America/New_York"
+    labels:
+      - "dependencies"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      all:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "05:00"
+      timezone: "America/New_York"
+    labels:
+      - "dependencies"
+    commit-message:
+      prefix: "chore"
+      include: "scope"
+    groups:
+      all:
+        patterns:
+          - "*"

.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    uses: charmbracelet/meta/.github/workflows/build.yml@main
+
+  snapshot:
+    uses: charmbracelet/meta/.github/workflows/snapshot.yml@main
+    secrets:
+      goreleaser_key: ${{ secrets.GORELEASER_KEY }}
+
+  govulncheck:
+    uses: charmbracelet/meta/.github/workflows/govulncheck.yml@main
+    with:
+      go-version: stable
+
+  semgrep:
+    uses: charmbracelet/meta/.github/workflows/semgrep.yml@main
+
+  ruleguard:
+    uses: charmbracelet/meta/.github/workflows/ruleguard.yml@main
+    with:
+      go-version: stable

.github/workflows/coverage.yml

@@ -0,0 +1,24 @@
+name: coverage
+on: [push, pull_request]
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    env:
+      GO111MODULE: "on"
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Install Go
+        uses: actions/setup-go@v6
+        with:
+          go-version: stable
+
+      - name: Coverage
+        env:
+          COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          go test -race -covermode atomic -coverprofile=profile.cov ./...
+          go install github.com/mattn/goveralls@latest
+          goveralls -coverprofile=profile.cov -service=github

.github/workflows/dependabot-sync.yml

@@ -0,0 +1,17 @@
+name: dependabot-sync
+on:
+  schedule:
+    - cron: "0 0 * * 0" # every Sunday at midnight
+  workflow_dispatch: # allows manual triggering
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot-sync:
+    uses: charmbracelet/meta/.github/workflows/dependabot-sync.yml@main
+    with:
+      repo_name: ${{ github.event.repository.name }}
+    secrets:
+      gh_token: ${{ secrets.PERSONAL_ACCESS_TOKEN }}

.github/workflows/go.yml

@@ -1,43 +0,0 @@
-name: build
-on: [push, pull_request]
-jobs:
-  test:
-    strategy:
-      matrix:
-        go-version: [1.13.x, 1.14.x, 1.15.x]
-        platform: [ubuntu-latest, macos-latest]
-    runs-on: ${{ matrix.platform }}
-    env:
-      GO111MODULE: "on"
-    steps:
-
-    - name: Configure git for private modules
-      env:
-        TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
-      run: git config --global url."https://meowgorithm:${TOKEN}@github.com".insteadOf "https://github.com"
-
-    - name: Install Go
-      uses: actions/setup-go@v1
-      with:
-        go-version: ${{ matrix.go-version }}
-
-    - name: Checkout code
-      uses: actions/checkout@v1
-
-    - name: Download Go modules
-      run: go mod download
-
-    - name: Build
-      run: go build -v ./...
-
-    - name: Test
-      run: go test ./...
-
-    - name: Coverage
-      env:
-        COVERALLS_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        go test -race -covermode atomic -coverprofile=profile.cov ./...
-        GO111MODULE=off go get github.com/mattn/goveralls
-        $(go env GOPATH)/bin/goveralls -coverprofile=profile.cov -service=github
-      if: matrix.go-version == '1.15.x' && matrix.platform == 'ubuntu-latest'

.github/workflows/goreleaser.yml

@@ -0,0 +1,25 @@
+# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+
+name: goreleaser
+
+on:
+  push:
+    tags:
+      - v*.*.*
+
+concurrency:
+  group: goreleaser
+  cancel-in-progress: true
+
+jobs:
+  goreleaser:
+    uses: charmbracelet/meta/.github/workflows/goreleaser.yml@main
+    secrets:
+      docker_username: ${{ secrets.DOCKERHUB_USERNAME }}
+      docker_token: ${{ secrets.DOCKERHUB_TOKEN }}
+      gh_pat: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+      goreleaser_key: ${{ secrets.GORELEASER_KEY }}
+      fury_token: ${{ secrets.FURY_TOKEN }}
+      nfpm_gpg_key: ${{ secrets.NFPM_GPG_KEY }}
+      nfpm_passphrase: ${{ secrets.NFPM_PASSPHRASE }}
+      snapcraft_token: ${{ secrets.SNAPCRAFT_TOKEN }}

.github/workflows/lint-sync.yml

@@ -0,0 +1,13 @@
+name: lint-sync
+on:
+  schedule:
+    - cron: "0 0 * * 0" # every sunday at midnight
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  lint:
+    uses: charmbracelet/meta/.github/workflows/lint-sync.yml@main

.github/workflows/lint.yml

@@ -0,0 +1,18 @@
+name: lint
+on:
+  push:
+  pull_request:
+
+jobs:
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v9.2.0
+        with:
+          # Optional: golangci-lint command line arguments.
+          args: --issues-exit-code=0
+          # Optional: show only new issues if it's a pull request. The default value is `false`.
+          only-new-issues: true

.gitignore

@@ -1,2 +1,5 @@
 glow
 dist/
+.envrc
+completions/
+manpages/

.golangci.yml

@@ -1,26 +1,44 @@
+version: "2"
 run:
   tests: false
-
-issues:
-  max-issues-per-linter: 0
-  max-same-issues: 0
-
 linters:
   enable:
     - bodyclose
-    - dupl
-    - exportloopref
+    - exhaustive
     - goconst
     - godot
-    - godox
-    - goimports
-    - gomnd
+    - gomoddirectives
     - goprintffuncname
     - gosec
     - misspell
+    - nakedret
+    - nestif
+    - nilerr
+    - noctx
+    - nolintlint
     - prealloc
+    - revive
     - rowserrcheck
     - sqlclosecheck
+    - tparallel
     - unconvert
     - unparam
     - whitespace
+    - wrapcheck
+  exclusions:
+    rules:
+      - text: '(slog|log)\.\w+'
+        linters:
+          - noctx
+    generated: lax
+    presets:
+      - common-false-positives
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
+formatters:
+  enable:
+    - gofumpt
+    - goimports
+  exclusions:
+    generated: lax

.goreleaser.yml

@@ -1,78 +1,14 @@
-env:
-  - GO111MODULE=on
-  - CGO_ENABLED=0
-before:
-  hooks:
-    - go mod download
-builds:
-  - id: "glow"
-    binary: glow
-    ldflags: -s -w -X main.Version={{ .Version }} -X main.CommitSHA={{ .Commit }}
-    goos:
-      - linux
-      - freebsd
-      - openbsd
-      - darwin
-      - windows
-    goarch:
-      - amd64
-      - arm64
-      - 386
-      - arm
-    goarm:
-      - 6
-      - 7
+# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
 
-archives:
-  - id: default
-    builds:
-      - glow
-    format_overrides:
-      - goos: windows
-        format: zip
-    replacements:
-      windows: Windows
-      darwin: Darwin
-      386: i386
-      amd64: x86_64
+version: 2
 
-nfpms:
-  - builds:
-      - glow
+includes:
+  - from_url:
+      url: charmbracelet/meta/main/goreleaser-glow.yaml
 
-    vendor: charmbracelet
-    homepage: "https://charm.sh/"
-    maintainer: "Christian Muehlhaeuser <muesli@gmail.com>"
-    description: "Render markdown on the CLI"
-    license: MIT
-    formats:
-      - apk
-      - deb
-      - rpm
-    bindir: /usr/bin
-
-brews:
-  - goarm: 6
-    tap:
-      owner: charmbracelet
-      name: homebrew-tap
-    commit_author:
-      name: "Christian Muehlhaeuser"
-      email: "muesli@gmail.com"
-    homepage: "https://charm.sh/"
-    description: "Render markdown on the CLI"
-    # skip_upload: true
-
-signs:
-  - artifacts: checksum
-
-checksum:
-  name_template: "checksums.txt"
-snapshot:
-  name_template: "{{ .Tag }}-next"
-changelog:
-  sort: asc
-  filters:
-    exclude:
-      - "^docs:"
-      - "^test:"
+variables:
+  description: "Render markdown on the CLI, with pizzazz!"
+  github_url: "https://github.com/charmbracelet/glow"
+  maintainer: "Christian Muehlhaeuser <muesli@charm.sh>"
+  brew_commit_author_name: "Christian Muehlhaeuser"
+  brew_commit_author_email: "muesli@charm.sh"

Dockerfile

@@ -0,0 +1,3 @@
+FROM gcr.io/distroless/static
+COPY glow /usr/local/bin/glow
+ENTRYPOINT [ "/usr/local/bin/glow" ]

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 Charmbracelet, Inc
+Copyright (c) 2019-2024 Charmbracelet, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -1,20 +0,0 @@
-# This Makefile is just for development purposes
-
-.PHONY: default clean glow run log
-
-LOGFILE := debug.log
-
-default: glow
-
-clean:
-	rm -f ./glow
-
-glow:
-	go build
-
-run: clean glow
-	GLOW_LOGFILE=$(LOGFILE) ./glow
-
-log:
-	> $(LOGFILE)
-	tail -f $(LOGFILE)

README.md

@@ -3,15 +3,15 @@
 Render markdown on the CLI, with _pizzazz_!
 
 <p align="center">
-    <img src="https://stuff.charm.sh/glow-github.gif" alt="Glow Logo">
+    <img src="https://stuff.charm.sh/glow/glow-banner-github.gif" alt="Glow Logo">
     <a href="https://github.com/charmbracelet/glow/releases"><img src="https://img.shields.io/github/release/charmbracelet/glow.svg" alt="Latest Release"></a>
     <a href="https://pkg.go.dev/github.com/charmbracelet/glow?tab=doc"><img src="https://godoc.org/github.com/golang/gddo?status.svg" alt="GoDoc"></a>
     <a href="https://github.com/charmbracelet/glow/actions"><img src="https://github.com/charmbracelet/glow/workflows/build/badge.svg" alt="Build Status"></a>
-    <a href="http://goreportcard.com/report/github.com/charmbracelet/glow"><img src="http://goreportcard.com/badge/charmbracelet/glow" alt="Go ReportCard"></a>
+    <a href="https://goreportcard.com/report/github.com/charmbracelet/glow"><img src="https://goreportcard.com/badge/charmbracelet/glow" alt="Go ReportCard"></a>
 </p>
 
 <p align="center">
-    <img src="https://stuff.charm.sh/glow2-ui-github.gif" width="600" alt="Glow UI Demo">
+    <img src="https://github.com/user-attachments/assets/c2246366-f84b-4847-b431-32a61ca07b74" width="800" alt="Glow UI Demo">
 </p>
 
 ## What is it?
@@ -20,77 +20,117 @@ Glow is a terminal based markdown reader designed from the ground up to bring
 out the beauty—and power—of the CLI.
 
 Use it to discover markdown files, read documentation directly on the command
-line and stash markdown files to your own private collection so you can read
-them anywhere. Glow will find local markdown files in subdirectories or a local
+line. Glow will find local markdown files in subdirectories or a local
 Git repository.
 
-By the way, all data stashed is encrypted end-to-end: only you can decrypt it.
-More on that below.
-
 ## Installation
 
-Use your fave package manager:
+### Package Manager
 
 ```bash
 # macOS or Linux
 brew install glow
+```
 
+```bash
+# macOS (with MacPorts)
+sudo port install glow
+```
+
+```bash
 # Arch Linux (btw)
-yay -S glow
+pacman -S glow
+```
 
+```bash
 # Void Linux
 xbps-install -S glow
+```
 
-# Nix
-nix-env -iA nixpkgs.glow
+```bash
+# Nix shell
+nix-shell -p glow --command glow
+```
 
+```bash
 # FreeBSD
 pkg install glow
 ```
 
-Or download a binary from the [releases][releases] page. MacOS, Linux, FreeBSD
-binaries are available, as well as Debian and RPM packages. ARM builds are also
-available for Linux and FreeBSD.
-
-Or just use `go get`:
+```bash
+# Solus
+eopkg install glow
+```
 
 ```bash
-go get github.com/charmbracelet/glow
+# Windows (with Chocolatey, Scoop, or Winget)
+choco install glow
+scoop install glow
+winget install charmbracelet.glow
+```
+
+```bash
+# Android (with termux)
+pkg install glow
+```
+
+```bash
+# Ubuntu (Snapcraft)
+sudo snap install glow
+```
+
+```bash
+# Debian/Ubuntu
+sudo mkdir -p /etc/apt/keyrings
+curl -fsSL https://repo.charm.sh/apt/gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/charm.gpg
+echo "deb [signed-by=/etc/apt/keyrings/charm.gpg] https://repo.charm.sh/apt/ * *" | sudo tee /etc/apt/sources.list.d/charm.list
+sudo apt update && sudo apt install glow
+```
+
+```bash
+# Fedora/RHEL
+echo '[charm]
+name=Charm
+baseurl=https://repo.charm.sh/yum/
+enabled=1
+gpgcheck=1
+gpgkey=https://repo.charm.sh/yum/gpg.key' | sudo tee /etc/yum.repos.d/charm.repo
+sudo yum install glow
+```
+
+Or download a binary from the [releases][releases] page. MacOS, Linux, Windows,
+FreeBSD and OpenBSD binaries are available, as well as Debian, RPM, and Alpine
+packages. ARM builds are also available for macOS, Linux, FreeBSD and OpenBSD.
+
+### Go
+
+Or just install it with `go`:
+
+```bash
+go install github.com/charmbracelet/glow/v2@latest
+```
+
+### Build (requires Go 1.21+)
+
+```bash
+git clone https://github.com/charmbracelet/glow.git
+cd glow
+go build
 ```
 
 [releases]: https://github.com/charmbracelet/glow/releases
 
-
 ## The TUI
 
-Simply run `glow` without arguments to start the textual user iterface and
-browse local and stashed markdown. Glow will find local markdown files it the
+Simply run `glow` without arguments to start the textual user interface and
+browse local. Glow will find local markdown files in the
 current directory and below or, if you’re in a Git repository, Glow will search
 the repo.
 
 Markdown files can be read with Glow's high-performance pager. Most of the
-keystokes you know from `less` are the same, but you can press `?` to list
+keystrokes you know from `less` are the same, but you can press `?` to list
 the hotkeys.
 
-### Stashing
-
-Glow works with the Charm Cloud to allow you to store any markdown files in
-your own private collection. You can stash a local document from the Glow TUI by
-pressing `s`.
-
-You can also stash from the CLI:
-
-```bash
-glow stash README.md
-```
-
-Then, when you run `glow` without arguments will you can browse through your
-stashed documents. This is a great way to keep track of things that you need to
-reference often.
-
-Stashing is private, its contents will not be exposed publicly, and it's
-encrypted end-to-end. More on encryption below.
-
 ## The CLI
 
 In addition to a TUI, Glow has a CLI for working with Markdown. To format a
@@ -101,7 +141,7 @@ document use a markdown source as the primary argument:
 glow README.md
 
 # Read from stdin
-glow -
+echo "[Glow](https://github.com/charmbracelet/glow)" | glow -
 
 # Fetch README from GitHub / GitLab
 glow github.com/charmbracelet/glow
@@ -110,18 +150,6 @@ glow github.com/charmbracelet/glow
 glow https://host.tld/file.md
 ```
 
-### Stashing
-
-You can also stash documents from the CLI:
-
-```bash
-glow stash README.md
-```
-
-Then, when you run `glow` without arguments will you can browse through your
-stashed documents. This is a great way to keep track of things that you need to
-reference often.
-
 ### Word Wrapping
 
 The `-w` flag lets you set a maximum width at which the output will be wrapped:
@@ -160,25 +188,55 @@ glow --help
 Check out the [Glamour Style Section](https://github.com/charmbracelet/glamour/blob/master/styles/gallery/README.md)
 to find more styles. Or [make your own](https://github.com/charmbracelet/glamour/tree/master/styles)!
 
-## 🔒 Encryption: How It Works
+## The Config File
 
-Encryption works by issuing symmetric keys (basically a generated password) and
-encrypting it with the local SSH public key generated by the open-source
-[charm][charmlib] library. That encrypted key is then sent up to our server.
-We can’t read it since we don’t have your private key. When you want to decrypt
-something or view your stash, that key is downloaded from our server and
-decrypted locally using the SSH private key. When you link accounts, the
-symmetric key is encrypted for each new public key. This happens on your
-machine and not our server, so we never see any unencrypted data.
+If you find yourself supplying the same flags to `glow` all the time, it's
+probably a good idea to create a config file. Run `glow config`, which will open
+it in your favorite $EDITOR. Alternatively you can manually put a file named
+`glow.yml` in the default config path of you platform. If you're not sure where
+that is, please refer to `glow --help`.
 
-[charmlib]: https://github.com/charmbracelet/charm
+Here's an example config:
+
+```yaml
+# style name or JSON path (default "auto")
+style: "light"
+# mouse wheel support (TUI-mode only)
+mouse: true
+# use pager to display markdown
+pager: true
+# at which column should we word wrap?
+width: 80
+# show all files, including hidden and ignored.
+all: false
+# show line numbers (TUI-mode only)
+showLineNumbers: false
+# preserve newlines in the output
+preserveNewLines: false
+```
+
+## Contributing
+
+See [contributing][contribute].
+
+[contribute]: https://github.com/charmbracelet/glow/contribute
+
+## Feedback
+
+We’d love to hear your thoughts on this project. Feel free to drop us a note!
+
+- [Twitter](https://twitter.com/charmcli)
+- [The Fediverse](https://mastodon.social/@charmcli)
+- [Discord](https://charm.sh/chat)
 
 ## License
 
 [MIT](https://github.com/charmbracelet/glow/raw/master/LICENSE)
 
+---
+
 Part of [Charm](https://charm.sh).
 
-<img alt="the Charm logo" src="https://stuff.charm.sh/charm-badge.jpg" width="400">
+<a href="https://charm.sh/"><img alt="The Charm logo" src="https://stuff.charm.sh/charm-badge.jpg" width="400"></a>
 
-Charm热爱开源! / Charm loves open source!
+Charm热爱开源 • Charm loves open source

Taskfile.yaml

@@ -0,0 +1,23 @@
+# https://taskfile.dev
+
+version: '3'
+
+tasks:
+  lint:
+    desc: Run base linters
+    cmds:
+      - golangci-lint run
+
+  test:
+    desc: Run tests
+    cmds:
+      - go test ./... {{.CLI_ARGS}}
+
+  log:
+    desc: Watch for glow logs
+    aliases: [tail]
+    cmds:
+      - cmd: tail -f ~/Library/Caches/glow/glow.log
+        platforms: [darwin]
+      - cmd: tail -f ~/.cache/glow/glow.log
+        platforms: [linux, windows]

config_cmd.go

@@ -0,0 +1,88 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io/fs"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/charmbracelet/x/editor"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+const defaultConfig = `# style name or JSON path (default "auto")
+style: "auto"
+# mouse support (TUI-mode only)
+mouse: false
+# use pager to display markdown
+pager: false
+# word-wrap at width
+width: 80
+# show all files, including hidden and ignored.
+all: false
+`
+
+var configCmd = &cobra.Command{
+	Use:     "config",
+	Hidden:  false,
+	Short:   "Edit the glow config file",
+	Long:    paragraph(fmt.Sprintf("\n%s the glow config file. We’ll use EDITOR to determine which editor to use. If the config file doesn't exist, it will be created.", keyword("Edit"))),
+	Example: paragraph("glow config\nglow config --config path/to/config.yml"),
+	Args:    cobra.NoArgs,
+	RunE: func(*cobra.Command, []string) error {
+		if err := ensureConfigFile(); err != nil {
+			return err
+		}
+
+		c, err := editor.Cmd("Glow", configFile)
+		if err != nil {
+			return fmt.Errorf("unable to set config file: %w", err)
+		}
+		c.Stdin = os.Stdin
+		c.Stdout = os.Stdout
+		c.Stderr = os.Stderr
+		if err := c.Run(); err != nil {
+			return fmt.Errorf("unable to run command: %w", err)
+		}
+
+		fmt.Println("Wrote config file to:", configFile)
+		return nil
+	},
+}
+
+func ensureConfigFile() error {
+	if configFile == "" {
+		configFile = viper.GetViper().ConfigFileUsed()
+		if err := os.MkdirAll(filepath.Dir(configFile), 0o755); err != nil { //nolint:gosec
+			return fmt.Errorf("could not write configuration file: %w", err)
+		}
+	}
+
+	if ext := path.Ext(configFile); ext != ".yaml" && ext != ".yml" {
+		return fmt.Errorf("'%s' is not a supported configuration type: use '%s' or '%s'", ext, ".yaml", ".yml")
+	}
+
+	if _, err := os.Stat(configFile); errors.Is(err, fs.ErrNotExist) {
+		// File doesn't exist yet, create all necessary directories and
+		// write the default config file
+		if err := os.MkdirAll(filepath.Dir(configFile), 0o700); err != nil {
+			return fmt.Errorf("unable create directory: %w", err)
+		}
+
+		f, err := os.Create(configFile)
+		if err != nil {
+			return fmt.Errorf("unable to create config file: %w", err)
+		}
+		defer func() { _ = f.Close() }()
+
+		if _, err := f.WriteString(defaultConfig); err != nil {
+			return fmt.Errorf("unable to write config file: %w", err)
+		}
+	} else if err != nil { // some other error occurred
+		return fmt.Errorf("unable to stat config file: %w", err)
+	}
+	return nil
+}

formatting.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	"github.com/muesli/reflow/indent"
-	"github.com/muesli/reflow/wordwrap"
-)
-
-const (
-	wrapAt       = 78
-	indentAmount = 2
-)
-
-func formatBlock(s string) string {
-	return indent.String(wordwrap.String(s, wrapAt-indentAmount), indentAmount)
-}

github.go

@@ -1,45 +1,55 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
 )
 
-// isGitHubURL tests a string to determine if it is a well-structured GitHub URL
-func isGitHubURL(s string) (string, bool) {
-	if strings.HasPrefix(s, "github.com/") {
-		s = "https://" + s
+// findGitHubREADME tries to find the correct README filename in a repository using GitHub API.
+func findGitHubREADME(u *url.URL) (*source, error) {
+	owner, repo, ok := strings.Cut(strings.TrimPrefix(u.Path, "/"), "/")
+	if !ok {
+		return nil, fmt.Errorf("invalid url: %s", u.String())
 	}
 
-	u, err := url.ParseRequestURI(s)
+	type readme struct {
+		DownloadURL string `json:"download_url"`
+	}
+
+	apiURL := fmt.Sprintf("https://api.%s/repos/%s/%s/readme", u.Hostname(), owner, repo)
+
+	//nolint:bodyclose
+	// it is closed on the caller
+	res, err := http.Get(apiURL) //nolint: gosec,noctx
 	if err != nil {
-		return "", false
+		return nil, fmt.Errorf("unable to get url: %w", err)
 	}
 
-	return u.String(), strings.ToLower(u.Host) == "github.com"
-}
-
-// findGitHubREADME tries to find the correct README filename in a repository
-func findGitHubREADME(s string) (*source, error) {
-	u, err := url.ParseRequestURI(s)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("unable to read http response body: %w", err)
 	}
-	u.Host = "raw.githubusercontent.com"
 
-	for _, r := range readmeNames {
-		v := u
-		v.Path += "/master/" + r
+	var result readme
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("unable to parse json: %w", err)
+	}
 
-		resp, err := http.Get(v.String())
+	if res.StatusCode == http.StatusOK {
+		//nolint:bodyclose
+		// it is closed on the caller
+		resp, err := http.Get(result.DownloadURL) //nolint: noctx
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("unable to get url: %w", err)
 		}
 
 		if resp.StatusCode == http.StatusOK {
-			return &source{resp.Body, v.String()}, nil
+			return &source{resp.Body, result.DownloadURL}, nil
 		}
 	}
 

gitlab.go

@@ -1,44 +1,59 @@
 package main
 
 import (
+	"encoding/json"
 	"errors"
+	"fmt"
+	"io"
 	"net/http"
 	"net/url"
 	"strings"
 )
 
-// isGitLabURL tests a string to determine if it is a well-structured GitLab URL
-func isGitLabURL(s string) (string, bool) {
-	if strings.HasPrefix(s, "gitlab.com/") {
-		s = "https://" + s
+// findGitLabREADME tries to find the correct README filename in a repository using GitLab API.
+func findGitLabREADME(u *url.URL) (*source, error) {
+	owner, repo, ok := strings.Cut(strings.TrimPrefix(u.Path, "/"), "/")
+	if !ok {
+		return nil, fmt.Errorf("invalid url: %s", u.String())
 	}
 
-	u, err := url.ParseRequestURI(s)
+	projectPath := url.QueryEscape(owner + "/" + repo)
+
+	type readme struct {
+		ReadmeURL string `json:"readme_url"`
+	}
+
+	apiURL := fmt.Sprintf("https://%s/api/v4/projects/%s", u.Hostname(), projectPath)
+
+	//nolint:bodyclose
+	// it is closed on the caller
+	res, err := http.Get(apiURL) //nolint: gosec,noctx
 	if err != nil {
-		return "", false
+		return nil, fmt.Errorf("unable to get url: %w", err)
 	}
 
-	return u.String(), strings.ToLower(u.Host) == "gitlab.com"
-}
-
-// findGitLabREADME tries to find the correct README filename in a repository
-func findGitLabREADME(s string) (*source, error) {
-	u, err := url.ParseRequestURI(s)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("unable to read http response body: %w", err)
 	}
 
-	for _, r := range readmeNames {
-		v := u
-		v.Path += "/raw/master/" + r
+	var result readme
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("unable to parse json: %w", err)
+	}
 
-		resp, err := http.Get(v.String())
+	readmeRawURL := strings.ReplaceAll(result.ReadmeURL, "blob", "raw")
+
+	if res.StatusCode == http.StatusOK {
+		//nolint:bodyclose
+		// it is closed on the caller
+		resp, err := http.Get(readmeRawURL) //nolint: gosec,noctx
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("unable to get url: %w", err)
 		}
 
 		if resp.StatusCode == http.StatusOK {
-			return &source{resp.Body, v.String()}, nil
+			return &source{resp.Body, readmeRawURL}, nil
 		}
 	}
 

glow_test.go

@@ -1,31 +1,9 @@
 package main
 
 import (
-	"bytes"
 	"testing"
 )
 
-func TestGlowSources(t *testing.T) {
-	tt := []string{
-		".",
-		"README.md",
-		"github.com/charmbracelet/glow",
-		"https://github.com/charmbracelet/glow",
-	}
-
-	for _, v := range tt {
-		buf := &bytes.Buffer{}
-		err := executeArg(rootCmd, v, buf)
-
-		if err != nil {
-			t.Errorf("Error during execution (args: %s): %v", v, err)
-		}
-		if buf.Len() == 0 {
-			t.Errorf("Output buffer should not be empty (args: %s)", v)
-		}
-	}
-}
-
 func TestGlowFlags(t *testing.T) {
 	tt := []struct {
 		args  []string

go.mod

@@ -1,23 +1,75 @@
-module github.com/charmbracelet/glow
+module github.com/charmbracelet/glow/v2
 
-go 1.13
+go 1.25.12
+
+toolchain go1.26.5
 
 require (
-	github.com/alecthomas/chroma v0.8.0 // indirect
-	github.com/charmbracelet/bubbles v0.6.1
-	github.com/charmbracelet/bubbletea v0.11.1
-	github.com/charmbracelet/charm v0.8.2
-	github.com/charmbracelet/glamour v0.2.1-0.20200829234023-6c0e29c4dae5
-	github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac
-	github.com/google/uuid v1.1.2 // indirect
-	github.com/mattn/go-runewidth v0.0.9
-	github.com/meowgorithm/babyenv v1.3.0
-	github.com/microcosm-cc/bluemonday v1.0.4 // indirect
-	github.com/muesli/gitcha v0.1.2-0.20200908172931-5aa4fdccf2f6
-	github.com/muesli/reflow v0.1.1-0.20200715144030-a312cb5b2d8d
-	github.com/muesli/termenv v0.7.4
-	github.com/spf13/cobra v1.0.0
-	golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee
-	golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc // indirect
-	golang.org/x/sys v0.0.0-20201013132646-2da7054afaeb
+	github.com/atotto/clipboard v0.1.4
+	github.com/caarlos0/env/v11 v11.3.1
+	github.com/charmbracelet/bubbles v0.21.0
+	github.com/charmbracelet/bubbletea v1.3.10
+	github.com/charmbracelet/glamour v0.10.0
+	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834
+	github.com/charmbracelet/log v0.4.2
+	github.com/charmbracelet/x/editor v0.1.0
+	github.com/dustin/go-humanize v1.0.1
+	github.com/fsnotify/fsnotify v1.9.0
+	github.com/mattn/go-runewidth v0.0.19
+	github.com/mitchellh/go-homedir v1.1.0
+	github.com/muesli/gitcha v0.3.0
+	github.com/muesli/go-app-paths v0.2.2
+	github.com/muesli/mango-cobra v1.3.0
+	github.com/muesli/reflow v0.3.0
+	github.com/muesli/roff v0.1.0
+	github.com/muesli/termenv v0.16.0
+	github.com/sahilm/fuzzy v0.1.1
+	github.com/spf13/cobra v1.10.2
+	github.com/spf13/viper v1.21.0
+	golang.org/x/sys v0.43.0
+	golang.org/x/term v0.42.0
+	golang.org/x/text v0.39.0
+	mvdan.cc/sh/v3 v3.13.1
+)
+
+require (
+	github.com/alecthomas/chroma/v2 v2.14.0 // indirect
+	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
+	github.com/aymerick/douceur v0.2.0 // indirect
+	github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc // indirect
+	github.com/charmbracelet/x/ansi v0.10.1 // indirect
+	github.com/charmbracelet/x/cellbuf v0.0.13 // indirect
+	github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf // indirect
+	github.com/charmbracelet/x/term v0.2.1 // indirect
+	github.com/clipperhouse/uax29/v2 v2.2.0 // indirect
+	github.com/dlclark/regexp2 v1.11.0 // indirect
+	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
+	github.com/go-logfmt/logfmt v0.6.0 // indirect
+	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+	github.com/gorilla/css v1.0.1 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/microcosm-cc/bluemonday v1.0.27 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/mango v0.2.0 // indirect
+	github.com/muesli/mango-pflag v0.1.0 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94 // indirect
+	github.com/sagikazarmark/locafero v0.11.0 // indirect
+	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
+	github.com/spf13/afero v1.15.0 // indirect
+	github.com/spf13/cast v1.10.0 // indirect
+	github.com/spf13/pflag v1.0.10 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
+	github.com/yuin/goldmark v1.7.17 // indirect
+	github.com/yuin/goldmark-emoji v1.0.5 // indirect
+	go.yaml.in/yaml/v3 v3.0.4 // indirect
+	golang.org/x/exp v0.0.0-20240604190554-fc45aab8b7f8 // indirect
+	golang.org/x/net v0.53.0 // indirect
+	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 )

go.sum

@@ -1,254 +1,177 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38 h1:smF2tmSOzy2Mm+0dGI2AIUHY+w0BUc+4tn40djz7+6U=
-github.com/alecthomas/assert v0.0.0-20170929043011-405dbfeb8e38/go.mod h1:r7bzyVFMNntcxPZXK3/+KdruV1H5KSlyVY0gc+NgInI=
-github.com/alecthomas/chroma v0.7.3/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM=
-github.com/alecthomas/chroma v0.8.0 h1:HS+HE97sgcqjQGu5uVr8jIE55Mmh5UeQ7kckAhHg2pY=
-github.com/alecthomas/chroma v0.8.0/go.mod h1:sko8vR34/90zvl5QdcUdvzL3J8NKjAUx9va9jPuFNoM=
-github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721 h1:JHZL0hZKJ1VENNfmXvHbgYlbUOvpzYzvy2aZU5gXVeo=
-github.com/alecthomas/colour v0.0.0-20160524082231-60882d9e2721/go.mod h1:QO9JBoKquHd+jz9nshCh40fOfO+JzsoXy8qTHF68zU0=
-github.com/alecthomas/kong v0.2.4/go.mod h1:kQOmtJgV+Lb4aj+I2LEn40cbtawdWJ9Y8QLq+lElKxE=
-github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897 h1:p9Sln00KOTlrYkxI1zYWl1QLnEqAqEARBEYa8FQnQcY=
-github.com/alecthomas/repr v0.0.0-20180818092828-117648cd9897/go.mod h1:xTS7Pm1pD1mvyM075QCDSRqH6qRLXylzS24ZTpRiSzQ=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
-github.com/atotto/clipboard v0.1.2 h1:YZCtFu5Ie8qX2VmVTBnrqLSiU9XOWwqNRmdT3gIQzbY=
-github.com/atotto/clipboard v0.1.2/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/alecthomas/assert/v2 v2.7.0 h1:QtqSACNS3tF7oasA8CU6A6sXZSBDqnm7RfpLl9bZqbE=
+github.com/alecthomas/assert/v2 v2.7.0/go.mod h1:Bze95FyfUr7x34QZrjL+XP+0qgp/zg8yS+TtBj1WA3k=
+github.com/alecthomas/chroma/v2 v2.14.0 h1:R3+wzpnUArGcQz7fCETQBzO5n9IMNi13iIs46aU4V9E=
+github.com/alecthomas/chroma/v2 v2.14.0/go.mod h1:QolEbTfmUHIMVpBqxeDnNBj2uoeI4EbYP4i6n68SG4I=
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
+github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWpi6yML8=
+github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
-github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
-github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
-github.com/calmh/randomart v1.1.0 h1:evl+iwc10LXtHdMZhzLxmsCQVmWnkXs44SbC6Uk0Il8=
-github.com/calmh/randomart v1.1.0/go.mod h1:DQUbPVyP+7PAs21w/AnfMKG5NioxS3TbZ2F9MSK/jFM=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/charmbracelet/bubbles v0.6.0 h1:i884UciNkSDSOQKgYrMFCLcVN8r0tX5K4pthOwBkZ7Q=
-github.com/charmbracelet/bubbles v0.6.0/go.mod h1:MxySU+YRGbAhZQJavZlW2os+fIeOW69MI3iXqA+2/WA=
-github.com/charmbracelet/bubbles v0.6.1 h1:SnyRY9vJMXW1sjECGUVdbec4O6V425ImAkIdwX3HkK8=
-github.com/charmbracelet/bubbles v0.6.1/go.mod h1:MxySU+YRGbAhZQJavZlW2os+fIeOW69MI3iXqA+2/WA=
-github.com/charmbracelet/bubbletea v0.10.3/go.mod h1:fB1bVmlaXBYYv4G0jtuGSP/m8V2sMM97pq7QqQnubWI=
-github.com/charmbracelet/bubbletea v0.10.5/go.mod h1:Nay5oWkkSZvc6E/be+W3nDFXAsVytNUNKV9jbXcuae0=
-github.com/charmbracelet/bubbletea v0.11.1 h1:A+1+YqYN0j/ghKfGZ27LJo+Vg80fGDP+MTudHO56t2o=
-github.com/charmbracelet/bubbletea v0.11.1/go.mod h1:3gZkYELUOiEUOp0bTInkxguucy/xRbGSOcbMs1geLxg=
-github.com/charmbracelet/charm v0.8.2 h1:sYJhP7YopJUvjWE8VKlNrcAHAaRZsEgKn8z2FoIhHOI=
-github.com/charmbracelet/charm v0.8.2/go.mod h1:xi3evUxj8hw+dMApaXRczb2SiEzrn8a3NYobj0off+c=
-github.com/charmbracelet/glamour v0.2.1-0.20200829234023-6c0e29c4dae5 h1:XgXVfMdJTNTq/ajMvwiB1OW3Tg/TXHtM3tYr/vYF76w=
-github.com/charmbracelet/glamour v0.2.1-0.20200829234023-6c0e29c4dae5/go.mod h1:CGH6KT1ovzvGpaQFxkm9ulKx6BlfV4dThCDaOMi54qI=
-github.com/chris-ramon/douceur v0.2.0 h1:IDMEdxlEUUBYBKE4z/mJnFyVXox+MjuEVDJNN27glkU=
-github.com/chris-ramon/douceur v0.2.0/go.mod h1:wDW5xjJdeoMm1mRt4sD4c/LbF/mWdEpRXQKjTR8nIBE=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/containerd/console v1.0.1 h1:u7SFAJyRqWcG6ogaMAx3KjSTy1e3hT9QxqX7Jco7dRc=
-github.com/containerd/console v1.0.1/go.mod h1:XUsP6YE/mKtz6bxc+I8UiKKTP04qjQL4qcS3XoQ5xkw=
-github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
-github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
-github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
-github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
-github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
-github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
-github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964 h1:y5HC9v93H5EPKqaS1UYVg1uYah5Xf51mBfIoWehClUQ=
-github.com/danwakefield/fnmatch v0.0.0-20160403171240-cbb64ac3d964/go.mod h1:Xd9hchkHSWYkEqJwUGisez3G1QY8Ryz0sdWrLPMGjLk=
+github.com/caarlos0/env/v11 v11.3.1 h1:cArPWC15hWmEt+gWk7YBi7lEXTXCvpaSdCiZE2X5mCA=
+github.com/caarlos0/env/v11 v11.3.1/go.mod h1:qupehSf/Y0TUTsxKywqRt/vJjN5nz6vauiYEUUr8P4U=
+github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
+github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
+github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc h1:4pZI35227imm7yK2bGPcfpFEmuY1gc2YSTShr4iJBfs=
+github.com/charmbracelet/colorprofile v0.2.3-0.20250311203215-f60798e515dc/go.mod h1:X4/0JoqgTIPSFcRA/P6INZzIuyqdFY5rm8tb41s9okk=
+github.com/charmbracelet/glamour v0.10.0 h1:MtZvfwsYCx8jEPFJm3rIBFIMZUfUJ765oX8V6kXldcY=
+github.com/charmbracelet/glamour v0.10.0/go.mod h1:f+uf+I/ChNmqo087elLnVdCiVgjSKWuXa/l6NU2ndYk=
+github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834 h1:ZR7e0ro+SZZiIZD7msJyA+NjkCNNavuiPBLgerbOziE=
+github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834/go.mod h1:aKC/t2arECF6rNOnaKaVU6y4t4ZeHQzqfxedE/VkVhA=
+github.com/charmbracelet/log v0.4.2 h1:hYt8Qj6a8yLnvR+h7MwsJv/XvmBJXiueUcI3cIxsyig=
+github.com/charmbracelet/log v0.4.2/go.mod h1:qifHGX/tc7eluv2R6pWIpyHDDrrb/AG71Pf2ysQu5nw=
+github.com/charmbracelet/x/ansi v0.10.1 h1:rL3Koar5XvX0pHGfovN03f5cxLbCF2YvLeyz7D2jVDQ=
+github.com/charmbracelet/x/ansi v0.10.1/go.mod h1:3RQDQ6lDnROptfpWuUVIUG64bD2g2BgntdxH0Ya5TeE=
+github.com/charmbracelet/x/cellbuf v0.0.13 h1:/KBBKHuVRbq1lYx5BzEHBAFBP8VcQzJejZ/IA3iR28k=
+github.com/charmbracelet/x/cellbuf v0.0.13/go.mod h1:xe0nKWGd3eJgtqZRaN9RjMtK7xUYchjzPr7q6kcvCCs=
+github.com/charmbracelet/x/editor v0.1.0 h1:p69/dpvlwRTs9uYiPeAWruwsHqTFzHhTvQOd/WVSX98=
+github.com/charmbracelet/x/editor v0.1.0/go.mod h1:oivrEbcP/AYt/Hpvk5pwDXXrQ933gQS6UzL6fxqAGSA=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91 h1:payRxjMjKgx2PaCWLZ4p3ro9y97+TVLZNaRZgJwSVDQ=
+github.com/charmbracelet/x/exp/golden v0.0.0-20241011142426-46044092ad91/go.mod h1:wDlXFlCrmJ8J+swcL/MnGUuYnqgQdW9rhSD61oNMb6U=
+github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf h1:rLG0Yb6MQSDKdB52aGX55JT1oi0P0Kuaj7wi1bLUpnI=
+github.com/charmbracelet/x/exp/slice v0.0.0-20250327172914-2fdc97757edf/go.mod h1:B3UgsnsBZS/eX42BlaNiJkD1pPOUa+oF1IYC6Yd2CEU=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/clipperhouse/uax29/v2 v2.2.0 h1:ChwIKnQN3kcZteTXMgb1wztSgaU+ZemkgWdohwgs8tY=
+github.com/clipperhouse/uax29/v2 v2.2.0/go.mod h1:EFJ2TJMRUaplDxHKj1qAEhCtQPW2tJSwu5BF98AuoVM=
+github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
-github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
-github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
-github.com/dlclark/regexp2 v1.2.0 h1:8sAhBGEM0dRWogWqWyQeIJnxjWO6oIjl8FKqREDsGfk=
-github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc=
-github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac h1:opbrjaN/L8gg6Xh5D04Tem+8xVcz6ajZlGCs49mQgyg=
-github.com/dustin/go-humanize v1.0.1-0.20200219035652-afde56e7acac/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/goterm v0.0.0-20190703233501-fc88cf888a3f/go.mod h1:nOFQdrUlIlx6M6ODdSpBj1NVA+VgLC6kmw60mkw34H4=
-github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gorilla/css v1.0.0 h1:BQqNyPTi50JCFMTw/b67hByjMVXZRwGha6wxVGkeihY=
-github.com/gorilla/css v1.0.0/go.mod h1:Dn721qIggHpt4+EFCcTLTU/vk5ySda2ReITrtgBl60c=
-github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
-github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
-github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
-github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
-github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
-github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/dlclark/regexp2 v1.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI=
+github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-quicktest/qt v1.101.0 h1:O1K29Txy5P2OK0dGo59b7b0LR6wKfIhttaAhHUyn7eI=
+github.com/go-quicktest/qt v1.101.0/go.mod h1:14Bz/f7NwaXPtdYEgzsx46kqSxVwTbzVZsDC26tQJow=
+github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
+github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/gorilla/css v1.0.1 h1:ntNaBIghp6JmvWnxbZKANoLyuXTPZ4cAMlo6RyhlbO8=
+github.com/gorilla/css v1.0.1/go.mod h1:BvnYkspnSzMmwRK+b8/xgNPLiIuNZr6vbZBTPQ2A3b0=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/lucasb-eyer/go-colorful v1.0.3 h1:QIbQXiugsb+q10B+MI+7DI1oQLdmnep86tWFlaaUAac=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
-github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
-github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
-github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/meowgorithm/babyenv v1.2.1/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
-github.com/meowgorithm/babyenv v1.3.0 h1:klb7ugoZt0/Xlqkd5kLxM7eLZX8waiwxHZWW5nfEZ0Q=
-github.com/meowgorithm/babyenv v1.3.0/go.mod h1:lwNX+J6AGBFqNrMZ2PTLkM6SO+W4X8DOg9zBDO4j3Ig=
-github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
-github.com/microcosm-cc/bluemonday v1.0.4 h1:p0L+CTpo/PLFdkoPcJemLXG+fpMD7pYOoDEq1axMbGg=
-github.com/microcosm-cc/bluemonday v1.0.4/go.mod h1:8iwZnFn2CDDNZ0r6UXhF4xawGvzaqzCRa1n3/lO3W2w=
-github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a h1:eU8j/ClY2Ty3qdHnn0TyW3ivFoPC/0F1gQZz8yTxbbE=
-github.com/mikesmitty/edkey v0.0.0-20170222072505-3356ea4e686a/go.mod h1:v8eSC2SMp9/7FTKUncp7fH9IwPfw+ysMObcEz5FWheQ=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
+github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
+github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/microcosm-cc/bluemonday v1.0.27 h1:MpEUotklkwCSLeH+Qdx1VJgNqLlpY2KXwXFM08ygZfk=
+github.com/microcosm-cc/bluemonday v1.0.27/go.mod h1:jFi9vgW+H7c3V0lb6nR74Ib/DIB5OBs92Dimizgw2cA=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/muesli/gitcha v0.1.2-0.20200908172931-5aa4fdccf2f6 h1:CUOAyrZoFRlGHfl6vljna20J++p8sPRlw9KF7fySgpA=
-github.com/muesli/gitcha v0.1.2-0.20200908172931-5aa4fdccf2f6/go.mod h1:Ri8m9TZS4+ORG4JVmVKUQcWZuxDvUW3UKxMdQfzG2zI=
-github.com/muesli/go-app-paths v0.2.1 h1:Qi+2igkDX2aPqyRddp7P0sMQIBwBqhkfQfNcjdGjL6Y=
-github.com/muesli/go-app-paths v0.2.1/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
-github.com/muesli/reflow v0.1.0/go.mod h1:I9bWAt7QTg/que/qmUCJBGlj7wEq8OAFBjPNjc6xK4I=
-github.com/muesli/reflow v0.1.1-0.20200715144030-a312cb5b2d8d h1:ok5jhmKQze1yERN73u46EZhUH4vgC1z4qfeFJ8iOwvg=
-github.com/muesli/reflow v0.1.1-0.20200715144030-a312cb5b2d8d/go.mod h1:I9bWAt7QTg/que/qmUCJBGlj7wEq8OAFBjPNjc6xK4I=
-github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a h1:Hw/15RYEOUD6T9UCRkUmNBa33kJkH33Fui6hE4sRLKU=
-github.com/muesli/sasquatch v0.0.0-20200811221207-66979d92330a/go.mod h1:+XG0ne5zXWBTSbbe7Z3/RWxaT8PZY6zaZ1dX6KjprYY=
-github.com/muesli/termenv v0.7.0/go.mod h1:SohX91w6swWA4AYU+QmPx+aSgXhWO0juiyID9UZmbpA=
-github.com/muesli/termenv v0.7.2 h1:r1raklL3uKE7rOvWgSenmEm2px+dnc33OTisZ8YR1fw=
-github.com/muesli/termenv v0.7.2/go.mod h1:ct2L5N2lmix82RaY3bMWwVu/jUFc9Ule0KGDCiKYPh8=
-github.com/muesli/termenv v0.7.4 h1:/pBqvU5CpkY53tU0vVn+xgs2ZTX63aH5nY+SSps5Xa8=
-github.com/muesli/termenv v0.7.4/go.mod h1:pZ7qY9l3F7e5xsAOS0zCew2tME+p7bWeBkotCEcIIcc=
-github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
-github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
-github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8=
-github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA=
-github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/term v0.0.0-20200520122047-c3ffed290a03/go.mod h1:Z9+Ul5bCbBKnbCvdOWbLqTHhJiYV414CURZJba6L8qA=
-github.com/pkg/term v1.1.0 h1:xIAAdCMh3QIAy+5FrE8Ad8XoDhEU4ufwbaSozViP9kk=
-github.com/pkg/term v1.1.0/go.mod h1:E25nymQcrSllhX42Ok8MRm1+hyBdHY0dCeiKZ9jpNGw=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/gitcha v0.3.0 h1:+PJkVKrDXVB0VgRn/yVx2CqSVSDGMSepzvohsCrPYtQ=
+github.com/muesli/gitcha v0.3.0/go.mod h1:vX3jFL+XcEUq1uY74RCjLSZfAV+ZuvLg70/NGPdXn84=
+github.com/muesli/go-app-paths v0.2.2 h1:NqG4EEZwNIhBq/pREgfBmgDmt3h1Smr1MjZiXbpZUnI=
+github.com/muesli/go-app-paths v0.2.2/go.mod h1:SxS3Umca63pcFcLtbjVb+J0oD7cl4ixQWoBKhGEtEho=
+github.com/muesli/mango v0.2.0 h1:iNNc0c5VLQ6fsMgAqGQofByNUBH2Q2nEbD6TaI+5yyQ=
+github.com/muesli/mango v0.2.0/go.mod h1:5XFpbC8jY5UUv89YQciiXNlbi+iJgt29VDC5xbzrLL4=
+github.com/muesli/mango-cobra v1.3.0 h1:vQy5GvPg3ndOSpduxutqFoINhWk3vD5K2dXo5E8pqec=
+github.com/muesli/mango-cobra v1.3.0/go.mod h1:Cj1ZrBu3806Qw7UjxnAUgE+7tllUBj1NCLQDwwGx19E=
+github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe7Sg=
+github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
+github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
+github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
+github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
+github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
+github.com/muesli/termenv v0.16.0/go.mod h1:ZRfOIKPFDYQoDFF4Olj7/QJbW60Ol/kL1pU3VfY/Cnk=
+github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
+github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
-github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
-github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
-github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
-github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
-github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
-github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
-github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
-github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94 h1:G04eS0JkAIVZfaJLjla9dNxkJCPiKIGZlw9AfOhzOD0=
 github.com/sabhiram/go-gitignore v0.0.0-20180611051255-d3107576ba94/go.mod h1:b18R55ulyQ/h3RaWyloPyER7fWQVZvimKKhnI5OfrJQ=
-github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
-github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
-github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
-github.com/spf13/cobra v1.0.0 h1:6m/oheQuQ13N9ks4hubMG6BnvwOeaJrqSPLahSnczz8=
-github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHNrgE=
-github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
+github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
+github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
+github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
+github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
+github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
+github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
+github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
+github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
+github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
+github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
+github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
+github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
-github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
-github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
-github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
-github.com/yuin/goldmark v1.2.1 h1:ruQGxdhGHe7FWOJPT0mKs5+pD2Xs1Bm/kdGlHO04FmM=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
-go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
-go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 h1:hb9wdF1z5waM+dSIICn1l0DkLVDT3hqhhQsDNUmHPRE=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee h1:4yd7jl+vXjalO5ztz6Vc1VADv+S/80LGJmyl1ROJ2AI=
-golang.org/x/crypto v0.0.0-20201012173705-84dcc777aaee/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc h1:zK/HqS5bZxDptfPJNq8v7vJfXtkU7r9TLIoSr1bXaP4=
-golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200819171115-d785dc25833f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200916030750-2334cc1a136f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634 h1:bNEHhJCnrwMKNMmOx3yAynp5vs5/gRy+XWFtZFu7NBM=
-golang.org/x/sys v0.0.0-20201009025420-dfb3f7c4e634/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201013132646-2da7054afaeb h1:HS9IzC4UFbpMBLQUDSQcU+ViVT1vdFCQVjdPVpTlZrs=
-golang.org/x/sys v0.0.0-20201013132646-2da7054afaeb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
+github.com/yuin/goldmark v1.7.1/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
+github.com/yuin/goldmark v1.7.17 h1:p36OVWwRb246iHxA/U4p8OPEpOTESm4n+g+8t0EE5uA=
+github.com/yuin/goldmark v1.7.17/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg=
+github.com/yuin/goldmark-emoji v1.0.5 h1:EMVWyCGPlXJfUXBXpuMu+ii3TIaxbVBnEX9uaDC4cIk=
+github.com/yuin/goldmark-emoji v1.0.5/go.mod h1:tTkZEbwu5wkPmgTcitqddVxY9osFZiavD+r4AzQrh1U=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
+golang.org/x/exp v0.0.0-20240604190554-fc45aab8b7f8 h1:LoYXNGAShUG3m/ehNk4iFctuhGX/+R1ZpfJ4/ia80JM=
+golang.org/x/exp v0.0.0-20240604190554-fc45aab8b7f8/go.mod h1:jj3sYF3dwk5D+ghuXyeI3r5MFf+NT2An6/9dOA95KSI=
+golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
+golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/term v0.42.0 h1:UiKe+zDFmJobeJ5ggPwOshJIVt6/Ft0rcfrXZDLWAWY=
+golang.org/x/term v0.42.0/go.mod h1:Dq/D+snpsbazcBG5+F9Q1n2rXV8Ma+71xEjTRufARgY=
+golang.org/x/text v0.39.0 h1:UbZz4pLOvn600D6Oh6GGEI6VAmndrEBLv8/6BEXzyus=
+golang.org/x/text v0.39.0/go.mod h1:3UwRclnC2g0TU9x8PZiyfOajCd1zaUNHF9cvqcQZ+ZM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
-gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+mvdan.cc/sh/v3 v3.13.1 h1:DP3TfgZhDkT7lerUdnp6PTGKyxxzz6T+cOlY/xEvfWk=
+mvdan.cc/sh/v3 v3.13.1/go.mod h1:lXJ8SexMvEVcHCoDvAGLZgFJ9Wsm2sulmoNEXGhYZD0=

log.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/charmbracelet/log"
+	gap "github.com/muesli/go-app-paths"
+)
+
+func getLogFilePath() (string, error) {
+	dir, err := gap.NewScope(gap.User, "glow").CacheDir()
+	if err != nil {
+		return "", fmt.Errorf("unable to get cache dir: %w", err)
+	}
+	return filepath.Join(dir, "glow.log"), nil
+}
+
+func setupLog() (func() error, error) {
+	log.SetOutput(io.Discard)
+	// Log to file, if set
+	logFile, err := getLogFilePath()
+	if err != nil {
+		return nil, err
+	}
+	if err := os.MkdirAll(filepath.Dir(logFile), 0o755); err != nil { //nolint:gosec
+		// log disabled
+		return func() error { return nil }, nil //nolint:nilerr
+	}
+	f, err := os.OpenFile(logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o644) //nolint:gosec
+	if err != nil {
+		// log disabled
+		return func() error { return nil }, nil //nolint:nilerr
+	}
+	log.SetOutput(f)
+	log.SetLevel(log.DebugLevel)
+	return f.Close, nil
+}

main.go

@@ -1,10 +1,11 @@
+// Package main provides the entry point for the Glow CLI application.
 package main
 
 import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
+	"io/fs"
 	"net/http"
 	"net/url"
 	"os"
@@ -12,34 +13,55 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/meowgorithm/babyenv"
-	"github.com/spf13/cobra"
-	"golang.org/x/crypto/ssh/terminal"
+	"mvdan.cc/sh/v3/shell"
 
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/charm/ui/common"
+	"github.com/caarlos0/env/v11"
 	"github.com/charmbracelet/glamour"
-	"github.com/charmbracelet/glow/ui"
+	"github.com/charmbracelet/glamour/styles"
+	"github.com/charmbracelet/glow/v2/ui"
+	"github.com/charmbracelet/glow/v2/utils"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/log"
+	gap "github.com/muesli/go-app-paths"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"golang.org/x/term"
 )
 
 var (
-	Version   = ""
+	// Version as provided by goreleaser.
+	Version = ""
+	// CommitSHA as provided by goreleaser.
 	CommitSHA = ""
 
-	readmeNames  = []string{"README.md", "README"}
-	pager        bool
-	style        string
-	width        uint
-	showAllFiles bool
+	readmeNames      = []string{"README.md", "README", "Readme.md", "Readme", "readme.md", "readme"}
+	configFile       string
+	pager            bool
+	tui              bool
+	style            string
+	width            uint
+	showAllFiles     bool
+	showLineNumbers  bool
+	preserveNewLines bool
+	mouse            bool
 
 	rootCmd = &cobra.Command{
-		Use:              "glow SOURCE",
-		Short:            "Render markdown on the CLI, with pizzazz!",
-		Long:             formatBlock(fmt.Sprintf("\nRender markdown on the CLI, %s!", common.Keyword("with pizzazz"))),
+		Use:   "glow [SOURCE|DIR]",
+		Short: "Render markdown on the CLI, with pizzazz!",
+		Long: paragraph(
+			fmt.Sprintf("\nRender markdown on the CLI, %s!", keyword("with pizzazz")),
+		),
 		SilenceErrors:    false,
-		SilenceUsage:     false,
+		SilenceUsage:     true,
 		TraverseChildren: true,
-		RunE:             execute,
+		Args:             cobra.MaximumNArgs(1),
+		ValidArgsFunction: func(*cobra.Command, []string, string) ([]string, cobra.ShellCompDirective) {
+			return nil, cobra.ShellCompDirectiveDefault
+		},
+		PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
+			return validateOptions(cmd)
+		},
+		RunE: execute,
 	}
 )
 
@@ -57,31 +79,22 @@ func sourceFromArg(arg string) (*source, error) {
 	}
 
 	// a GitHub or GitLab URL (even without the protocol):
-	if u, ok := isGitHubURL(arg); ok {
-		src, err := findGitHubREADME(u)
-		if err != nil {
-			return nil, err
-		}
-		return src, nil
-	}
-	if u, ok := isGitLabURL(arg); ok {
-		src, err := findGitLabREADME(u)
-		if err != nil {
-			return nil, err
-		}
+	src, err := readmeURL(arg)
+	if src != nil && err == nil {
+		// if there's an error, try next methods...
 		return src, nil
 	}
 
 	// HTTP(S) URLs:
-	if u, err := url.ParseRequestURI(arg); err == nil {
+	if u, err := url.ParseRequestURI(arg); err == nil && strings.Contains(arg, "://") { //nolint:nestif
 		if u.Scheme != "" {
 			if u.Scheme != "http" && u.Scheme != "https" {
 				return nil, fmt.Errorf("%s is not a supported protocol", u.Scheme)
 			}
-
-			resp, err := http.Get(u.String())
+			// consumer of the source is responsible for closing the ReadCloser.
+			resp, err := http.Get(u.String()) //nolint: noctx,bodyclose
 			if err != nil {
-				return nil, err
+				return nil, fmt.Errorf("unable to get url: %w", err)
 			}
 			if resp.StatusCode != http.StatusOK {
 				return nil, fmt.Errorf("HTTP status %d", resp.StatusCode)
@@ -96,9 +109,12 @@ func sourceFromArg(arg string) (*source, error) {
 		arg = "."
 	}
 	st, err := os.Stat(arg)
-	if err == nil && st.IsDir() {
+	if err == nil && st.IsDir() { //nolint:nestif
 		var src *source
-		_ = filepath.Walk(arg, func(path string, info os.FileInfo, err error) error {
+		_ = filepath.Walk(arg, func(path string, _ os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
 			for _, v := range readmeNames {
 				if strings.EqualFold(filepath.Base(path), v) {
 					r, err := os.Open(path)
@@ -123,14 +139,52 @@ func sourceFromArg(arg string) (*source, error) {
 		return nil, errors.New("missing markdown source")
 	}
 
-	// a file:
 	r, err := os.Open(arg)
-	u, _ := filepath.Abs(arg)
-	return &source{r, u}, err
+	if err != nil {
+		return nil, fmt.Errorf("unable to open file: %w", err)
+	}
+	u, err := filepath.Abs(arg)
+	if err != nil {
+		return nil, fmt.Errorf("unable to get absolute path: %w", err)
+	}
+	return &source{r, u}, nil
 }
 
-func validateOptions(cmd *cobra.Command) {
-	isTerminal := terminal.IsTerminal(int(os.Stdout.Fd()))
+// validateStyle checks if the style is a default style, if not, checks that
+// the custom style exists.
+func validateStyle(style string) error {
+	if style != "auto" && styles.DefaultStyles[style] == nil {
+		style = utils.ExpandPath(style)
+		if _, err := os.Stat(style); errors.Is(err, fs.ErrNotExist) {
+			return fmt.Errorf("specified style does not exist: %s", style)
+		} else if err != nil {
+			return fmt.Errorf("unable to stat file: %w", err)
+		}
+	}
+	return nil
+}
+
+func validateOptions(cmd *cobra.Command) error {
+	// grab config values from Viper
+	width = viper.GetUint("width")
+	mouse = viper.GetBool("mouse")
+	pager = viper.GetBool("pager")
+	tui = viper.GetBool("tui")
+	showAllFiles = viper.GetBool("all")
+	preserveNewLines = viper.GetBool("preserveNewLines")
+	showLineNumbers = viper.GetBool("showLineNumbers")
+
+	if pager && tui {
+		return errors.New("cannot use both pager and tui")
+	}
+
+	// validate the glamour style
+	style = viper.GetString("style")
+	if err := validateStyle(style); err != nil {
+		return err
+	}
+
+	isTerminal := term.IsTerminal(int(os.Stdout.Fd()))
 	// We want to use a special no-TTY style, when stdout is not a terminal
 	// and there was no specific style passed by arg
 	if !isTerminal && !cmd.Flags().Changed("style") {
@@ -138,53 +192,94 @@ func validateOptions(cmd *cobra.Command) {
 	}
 
 	// Detect terminal width
-	if isTerminal && !cmd.Flags().Changed("width") {
-		w, _, err := terminal.GetSize(int(os.Stdout.Fd()))
-		if err == nil {
-			width = uint(w)
+	if !cmd.Flags().Changed("width") { //nolint:nestif
+		if isTerminal && width == 0 {
+			w, _, err := term.GetSize(int(os.Stdout.Fd()))
+			if err == nil {
+				width = uint(w) //nolint:gosec
+			}
+
+			if width > 120 {
+				width = 120
+			}
 		}
-	}
-	if width == 0 {
-		width = 80
-	}
-	if width > 120 {
-		width = 120
-	}
-}
-
-func execute(cmd *cobra.Command, args []string) error {
-	validateOptions(cmd)
-
-	if len(args) == 0 {
-		return executeArg(cmd, "", os.Stdout)
-	}
-
-	for _, arg := range args {
-		if err := executeArg(cmd, arg, os.Stdout); err != nil {
-			return err
+		if width == 0 {
+			width = 80
 		}
 	}
 	return nil
 }
 
-func executeArg(cmd *cobra.Command, arg string, w io.Writer) error {
+func stdinIsPipe() (bool, error) {
+	stat, err := os.Stdin.Stat()
+	if err != nil {
+		return false, fmt.Errorf("unable to open file: %w", err)
+	}
+	if stat.Mode()&os.ModeCharDevice == 0 || stat.Size() > 0 {
+		return true, nil
+	}
+	return false, nil
+}
 
-	// Only run TUI if there are no arguments (excluding flags)
-	if arg == "" {
-		return runTUI(false)
+func execute(cmd *cobra.Command, args []string) error {
+	// if stdin is a pipe then use stdin for input. note that you can also
+	// explicitly use a - to read from stdin.
+	if yes, err := stdinIsPipe(); err != nil {
+		return err
+	} else if yes {
+		src := &source{reader: os.Stdin}
+		defer src.reader.Close() //nolint:errcheck
+		return executeCLI(cmd, src, os.Stdout)
 	}
 
+	switch len(args) {
+	// TUI running on cwd
+	case 0:
+		return runTUI("", "")
+
+	// TUI with possible dir argument
+	case 1:
+		// Validate that the argument is a directory. If it's not treat it as
+		// an argument to the non-TUI version of Glow (via fallthrough).
+		info, err := os.Stat(args[0])
+		if err == nil && info.IsDir() {
+			p, err := filepath.Abs(args[0])
+			if err == nil {
+				return runTUI(p, "")
+			}
+		}
+		fallthrough
+
+	// CLI
+	default:
+		for _, arg := range args {
+			if err := executeArg(cmd, arg, os.Stdout); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func executeArg(cmd *cobra.Command, arg string, w io.Writer) error {
 	// create an io.Reader from the markdown source in cli-args
 	src, err := sourceFromArg(arg)
 	if err != nil {
 		return err
 	}
-	defer src.reader.Close()
-	b, err := ioutil.ReadAll(src.reader)
+	defer src.reader.Close() //nolint:errcheck
+	return executeCLI(cmd, src, w)
+}
+
+func executeCLI(cmd *cobra.Command, src *source, w io.Writer) error {
+	b, err := io.ReadAll(src.reader)
 	if err != nil {
-		return err
+		return fmt.Errorf("unable to read from reader: %w", err)
 	}
 
+	b = utils.RemoveFrontmatter(b)
+
 	// render
 	var baseURL string
 	u, err := url.ParseRequestURI(src.URL)
@@ -193,100 +288,106 @@ func executeArg(cmd *cobra.Command, arg string, w io.Writer) error {
 		baseURL = u.String() + "/"
 	}
 
-	// initialize glamour
-	var gs glamour.TermRendererOption
-	if style == "auto" {
-		gs = glamour.WithEnvironmentConfig()
-	} else {
-		gs = glamour.WithStylePath(style)
-	}
+	isCode := !utils.IsMarkdownFile(src.URL)
 
+	// initialize glamour
 	r, err := glamour.NewTermRenderer(
-		gs,
-		glamour.WithWordWrap(int(width)),
+		glamour.WithColorProfile(lipgloss.ColorProfile()),
+		utils.GlamourStyle(style, isCode),
+		glamour.WithWordWrap(int(width)), //nolint:gosec
 		glamour.WithBaseURL(baseURL),
+		glamour.WithPreservedNewLines(),
 	)
 	if err != nil {
-		return err
+		return fmt.Errorf("unable to create renderer: %w", err)
 	}
 
-	out, err := r.RenderBytes(b)
+	content := string(b)
+	ext := filepath.Ext(src.URL)
+	if isCode {
+		content = utils.WrapCodeBlock(string(b), ext)
+	}
+
+	out, err := r.Render(content)
 	if err != nil {
-		return err
-	}
-
-	// trim lines
-	lines := strings.Split(string(out), "\n")
-	var content string
-	for i, s := range lines {
-		content += strings.TrimSpace(s)
-
-		// don't add an artificial newline after the last split
-		if i+1 < len(lines) {
-			content += "\n"
-		}
+		return fmt.Errorf("unable to render markdown: %w", err)
 	}
 
 	// display
-	if cmd.Flags().Changed("pager") {
-		pager := os.Getenv("PAGER")
-		if pager == "" {
-			pager = "less -r"
+	switch {
+	case pager || cmd.Flags().Changed("pager"):
+		pagerCmd := os.Getenv("PAGER")
+		if pagerCmd == "" {
+			pagerCmd = "less -r"
 		}
 
-		pa := strings.Split(pager, " ")
-		c := exec.Command(pa[0], pa[1:]...)
-		c.Stdin = strings.NewReader(content)
+		fields, err := shell.Fields(pagerCmd, os.Getenv)
+		if err != nil || len(fields) == 0 {
+			return fmt.Errorf("unable to parse PAGER command: %s", pagerCmd)
+		}
+		c := exec.Command(fields[0], fields[1:]...) //nolint:gosec
+		c.Stdin = strings.NewReader(out)
 		c.Stdout = os.Stdout
-		return c.Run()
+		if err := c.Run(); err != nil {
+			return fmt.Errorf("unable to run command: %w", err)
+		}
+		return nil
+	case tui || cmd.Flags().Changed("tui"):
+		path := ""
+		if !isURL(src.URL) {
+			path = src.URL
+		}
+		return runTUI(path, content)
+	default:
+		if _, err = fmt.Fprint(w, out); err != nil {
+			return fmt.Errorf("unable to write to writer: %w", err)
+		}
+		return nil
 	}
-
-	fmt.Fprint(w, content)
-	return nil
 }
 
-func runTUI(stashedOnly bool) error {
+func runTUI(path string, content string) error {
 	// Read environment to get debugging stuff
-	var cfg ui.Config
-	if err := babyenv.Parse(&cfg); err != nil {
+	cfg, err := env.ParseAs[ui.Config]()
+	if err != nil {
 		return fmt.Errorf("error parsing config: %v", err)
 	}
 
-	// Log to file, if set
-	if cfg.Logfile != "" {
-		f, err := tea.LogToFile(cfg.Logfile, "glow")
-		if err != nil {
-			return err
-		}
-		defer f.Close()
+	// use style set in env, or auto if unset
+	if err := validateStyle(cfg.GlamourStyle); err != nil {
+		cfg.GlamourStyle = style
 	}
 
+	cfg.Path = path
 	cfg.ShowAllFiles = showAllFiles
-	if stashedOnly {
-		cfg.StashedOnly = true
-	}
+	cfg.ShowLineNumbers = showLineNumbers
+	cfg.GlamourMaxWidth = width
+	cfg.EnableMouse = mouse
+	cfg.PreserveNewLines = preserveNewLines
 
 	// Run Bubble Tea program
-	p := ui.NewProgram(style, cfg)
-	p.EnterAltScreen()
-	if err := p.Start(); err != nil {
-		return err
+	if _, err := ui.NewProgram(cfg, content).Run(); err != nil {
+		return fmt.Errorf("unable to run tui program: %w", err)
 	}
-	p.ExitAltScreen()
-	p.DisableMouseCellMotion()
 
-	// Exit message
-	fmt.Printf("\n  Thanks for using Glow!\n\n")
 	return nil
 }
 
 func main() {
-	if err := rootCmd.Execute(); err != nil {
-		os.Exit(-1)
+	closer, err := setupLog()
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
 	}
+	if err := rootCmd.Execute(); err != nil {
+		_ = closer()
+		os.Exit(1)
+	}
+	_ = closer()
 }
 
 func init() {
+	tryLoadConfigFromDefaultPlaces()
 	if len(CommitSHA) >= 7 {
 		vt := rootCmd.VersionTemplate()
 		rootCmd.SetVersionTemplate(vt[:len(vt)-1] + " (" + CommitSHA[0:7] + ")\n")
@@ -295,14 +396,78 @@ func init() {
 		Version = "unknown (built from source)"
 	}
 	rootCmd.Version = Version
+	rootCmd.InitDefaultCompletionCmd()
 
 	// "Glow Classic" cli arguments
+	rootCmd.PersistentFlags().StringVar(&configFile, "config", "", fmt.Sprintf("config file (default %s)", viper.GetViper().ConfigFileUsed()))
 	rootCmd.Flags().BoolVarP(&pager, "pager", "p", false, "display with pager")
-	rootCmd.Flags().StringVarP(&style, "style", "s", "auto", "style name or JSON path")
-	rootCmd.Flags().UintVarP(&width, "width", "w", 0, "word-wrap at width")
+	rootCmd.Flags().BoolVarP(&tui, "tui", "t", false, "display with tui")
+	rootCmd.Flags().StringVarP(&style, "style", "s", styles.AutoStyle, "style name or JSON path")
+	rootCmd.Flags().UintVarP(&width, "width", "w", 0, "word-wrap at width (set to 0 to disable)")
 	rootCmd.Flags().BoolVarP(&showAllFiles, "all", "a", false, "show system files and directories (TUI-mode only)")
+	rootCmd.Flags().BoolVarP(&showLineNumbers, "line-numbers", "l", false, "show line numbers (TUI-mode only)")
+	rootCmd.Flags().BoolVarP(&preserveNewLines, "preserve-new-lines", "n", false, "preserve newlines in the output")
+	rootCmd.Flags().BoolVarP(&mouse, "mouse", "m", false, "enable mouse wheel (TUI-mode only)")
+	_ = rootCmd.Flags().MarkHidden("mouse")
 
-	// Stash
-	stashCmd.PersistentFlags().StringVarP(&memo, "memo", "m", "", "memo/note for stashing")
-	rootCmd.AddCommand(stashCmd)
+	// Config bindings
+	_ = viper.BindPFlag("pager", rootCmd.Flags().Lookup("pager"))
+	_ = viper.BindPFlag("tui", rootCmd.Flags().Lookup("tui"))
+	_ = viper.BindPFlag("style", rootCmd.Flags().Lookup("style"))
+	_ = viper.BindPFlag("width", rootCmd.Flags().Lookup("width"))
+	_ = viper.BindPFlag("debug", rootCmd.Flags().Lookup("debug"))
+	_ = viper.BindPFlag("mouse", rootCmd.Flags().Lookup("mouse"))
+	_ = viper.BindPFlag("preserveNewLines", rootCmd.Flags().Lookup("preserve-new-lines"))
+	_ = viper.BindPFlag("showLineNumbers", rootCmd.Flags().Lookup("line-numbers"))
+	_ = viper.BindPFlag("all", rootCmd.Flags().Lookup("all"))
+
+	viper.SetDefault("style", styles.AutoStyle)
+	viper.SetDefault("width", 0)
+	viper.SetDefault("all", true)
+
+	rootCmd.AddCommand(configCmd, manCmd)
+}
+
+func tryLoadConfigFromDefaultPlaces() {
+	scope := gap.NewScope(gap.User, "glow")
+	dirs, err := scope.ConfigDirs()
+	if err != nil {
+		fmt.Println("Could not load find configuration directory.")
+		os.Exit(1)
+	}
+
+	if c := os.Getenv("XDG_CONFIG_HOME"); c != "" {
+		dirs = append([]string{filepath.Join(c, "glow")}, dirs...)
+	}
+
+	if c := os.Getenv("GLOW_CONFIG_HOME"); c != "" {
+		dirs = append([]string{c}, dirs...)
+	}
+
+	for _, v := range dirs {
+		viper.AddConfigPath(v)
+	}
+
+	viper.SetConfigName("glow")
+	viper.SetConfigType("yaml")
+	viper.SetEnvPrefix("glow")
+	viper.AutomaticEnv()
+
+	if err := viper.ReadInConfig(); err != nil {
+		if _, ok := err.(viper.ConfigFileNotFoundError); !ok {
+			log.Warn("Could not parse configuration file", "err", err)
+		}
+	}
+
+	if used := viper.ConfigFileUsed(); used != "" {
+		log.Debug("Using configuration file", "path", viper.ConfigFileUsed())
+		return
+	}
+
+	if viper.ConfigFileUsed() == "" {
+		configFile = filepath.Join(dirs[0], "glow.yml")
+	}
+	if err := ensureConfigFile(); err != nil {
+		log.Error("Could not create default configuration", "error", err)
+	}
 }

man_cmd.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	mcobra "github.com/muesli/mango-cobra"
+	"github.com/muesli/roff"
+	"github.com/spf13/cobra"
+)
+
+var manCmd = &cobra.Command{
+	Use:                   "man",
+	Short:                 "Generates manpages",
+	SilenceUsage:          true,
+	DisableFlagsInUseLine: true,
+	Hidden:                true,
+	Args:                  cobra.NoArgs,
+	RunE: func(*cobra.Command, []string) error {
+		manPage, err := mcobra.NewManPage(1, rootCmd)
+		if err != nil {
+			return fmt.Errorf("unable to instantiate man page: %w", err)
+		}
+		if _, err := fmt.Fprint(os.Stdout, manPage.Build(roff.NewDocument())); err != nil {
+			return fmt.Errorf("unable to build man page: %w", err)
+		}
+		return nil
+	},
+}

stash_cmd.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/charmbracelet/charm"
-	"github.com/charmbracelet/charm/ui/common"
-	"github.com/muesli/termenv"
-	"github.com/spf13/cobra"
-)
-
-var (
-	memo string
-
-	stashCmd = &cobra.Command{
-		Use:     "stash [SOURCE]",
-		Hidden:  false,
-		Short:   "Stash a markdown",
-		Long:    formatBlock(fmt.Sprintf("\nDo %s stuff. Run with no arguments to browse your stash or pass a path to a markdown file to stash it.", common.Keyword("stash"))),
-		Example: formatBlock("glow stash\nglow stash README.md\nglow stash -m \"secret notes\" path/to/notes.md"),
-		Args:    cobra.MaximumNArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) == 0 {
-				return runTUI(true)
-			}
-
-			filePath := args[0]
-
-			if memo == "" {
-				memo = strings.Replace(path.Base(filePath), path.Ext(filePath), "", 1)
-			}
-
-			cc := initCharmClient()
-			f, err := os.Open(filePath)
-			if err != nil {
-				return fmt.Errorf("bad filename")
-			}
-
-			defer f.Close()
-			b, err := ioutil.ReadAll(f)
-			if err != nil {
-				return fmt.Errorf("error reading file")
-			}
-
-			_, err = cc.StashMarkdown(memo, string(b))
-			if err != nil {
-				return fmt.Errorf("error stashing markdown")
-			}
-
-			dot := termenv.String("•").Foreground(common.Green.Color()).String()
-			fmt.Println(dot + " Stashed!")
-			return nil
-		},
-	}
-)
-
-func getCharmConfig() *charm.Config {
-	cfg, err := charm.ConfigFromEnv()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	return cfg
-}
-
-func initCharmClient() *charm.Client {
-	cfg := getCharmConfig()
-	cc, err := charm.NewClient(cfg)
-	if err == charm.ErrMissingSSHAuth {
-		fmt.Println(formatBlock("We had some trouble authenticating via SSH. If this continues to happen the Charm tool may be able to help you. More info at https://github.com/charmbracelet/charm."))
-		os.Exit(1)
-	} else if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	return cc
-}

style.go

@@ -0,0 +1,14 @@
+package main
+
+import "github.com/charmbracelet/lipgloss"
+
+var (
+	keyword = lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#04B575")).
+		Render
+
+	paragraph = lipgloss.NewStyle().
+			Width(78).
+			Padding(0, 0, 0, 2).
+			Render
+)

ui/config.go

@@ -0,0 +1,20 @@
+package ui
+
+// Config contains TUI-specific configuration.
+type Config struct {
+	ShowAllFiles     bool
+	ShowLineNumbers  bool
+	Gopath           string `env:"GOPATH"`
+	HomeDir          string `env:"HOME"`
+	GlamourMaxWidth  uint
+	GlamourStyle     string `env:"GLAMOUR_STYLE"`
+	EnableMouse      bool
+	PreserveNewLines bool
+
+	// Working directory or file path
+	Path string
+
+	// For debugging the UI
+	HighPerformancePager bool `env:"GLOW_HIGH_PERFORMANCE_PAGER" envDefault:"true"`
+	GlamourEnabled       bool `env:"GLOW_ENABLE_GLAMOUR"         envDefault:"true"`
+}

ui/consts_unix.go

@@ -1,7 +0,0 @@
-// +build !windows
-
-package ui
-
-const (
-	pagerStashIcon = "🔒"
-)

ui/consts_windows.go

@@ -1,7 +0,0 @@
-// +build windows
-
-package ui
-
-const (
-	pagerStashIcon = "•"
-)

ui/editor.go

@@ -0,0 +1,19 @@
+package ui
+
+import (
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/editor"
+)
+
+type editorFinishedMsg struct{ err error }
+
+func openEditor(path string, lineno int) tea.Cmd {
+	cb := func(err error) tea.Msg {
+		return editorFinishedMsg{err}
+	}
+	cmd, err := editor.Cmd("Glow", path, editor.LineNumber(uint(lineno))) //nolint:gosec
+	if err != nil {
+		return func() tea.Msg { return cb(err) }
+	}
+	return tea.ExecProcess(cmd, cb)
+}

ui/ignore_darwin.go

@@ -1,10 +1,11 @@
+//go:build darwin
 // +build darwin
 
 package ui
 
 import "path/filepath"
 
-func ignorePatterns(m model) []string {
+func ignorePatterns(m commonModel) []string {
 	return []string{
 		filepath.Join(m.cfg.HomeDir, "Library"),
 		m.cfg.Gopath,

ui/ignore_general.go

@@ -1,8 +1,9 @@
+//go:build !darwin
 // +build !darwin
 
 package ui
 
-func ignorePatterns(m model) []string {
+func ignorePatterns(m commonModel) []string {
 	return []string{
 		m.cfg.Gopath,
 		"node_modules",

ui/keys.go

@@ -0,0 +1,6 @@
+package ui
+
+const (
+	keyEnter = "enter"
+	keyEsc   = "esc"
+)

ui/markdown.go

@@ -1,64 +1,88 @@
 package ui
 
 import (
-	"strings"
+	"fmt"
+	"math"
+	"time"
+	"unicode"
 
-	"github.com/charmbracelet/charm"
+	"github.com/charmbracelet/log"
+	"github.com/dustin/go-humanize"
+	"golang.org/x/text/runes"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
 )
 
-// markdownType allows us to differentiate between the types of markdown
-// documents we're dealing with.
-type markdownType int
-
-const (
-	stashedMarkdown markdownType = iota
-	newsMarkdown
-	localMarkdown
-	convertedMarkdown // used to be local, now its stashed
-)
-
-// markdown wraps charm.Markdown.
 type markdown struct {
-	markdownType markdownType
-	localPath    string // only relevant to local files and converted files that are newly stashed
-	displayPath  string // what we show in the note field
-	charm.Markdown
+	// Full path of a local markdown file. Only relevant to local documents and
+	// those that have been stashed in this session.
+	localPath string
+
+	// Value we filter against. This exists so that we can maintain positions
+	// of filtered items if notes are edited while a filter is active. This
+	// field is ephemeral, and should only be referenced during filtering.
+	filterValue string
+
+	Body    string
+	Note    string
+	Modtime time.Time
 }
 
-// sortAsLocal returns whether or not this markdown should be sorted as though
-// it's a local markdown document.
-func (m markdown) sortAsLocal() bool {
-	return m.markdownType == localMarkdown || m.markdownType == convertedMarkdown
+// Generate the value we're doing to filter against.
+func (m *markdown) buildFilterValue() {
+	note, err := normalize(m.Note)
+	if err != nil {
+		log.Error("error normalizing", "note", m.Note, "error", err)
+		m.filterValue = m.Note
+	}
+
+	m.filterValue = note
 }
 
-// Sort documents with local files first, then by date.
-type markdownsByLocalFirst []*markdown
-
-func (m markdownsByLocalFirst) Len() int      { return len(m) }
-func (m markdownsByLocalFirst) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
-func (m markdownsByLocalFirst) Less(i, j int) bool {
-	iIsLocal := m[i].sortAsLocal()
-	jIsLocal := m[j].sortAsLocal()
-
-	// Local files (and files that used to be local) come first
-	if iIsLocal && !jIsLocal {
-		return true
-	}
-	if !iIsLocal && jIsLocal {
-		return false
-	}
-
-	// If both are local files, sort by filename. Note that we should never
-	// hit equality here since two files can't have the same path.
-	if iIsLocal && jIsLocal {
-		return strings.Compare(m[i].localPath, m[j].localPath) == -1
-	}
-
-	// Neither are local files so sort by date descending
-	if !m[i].CreatedAt.Equal(m[j].CreatedAt) {
-		return m[i].CreatedAt.After(m[j].CreatedAt)
-	}
-
-	// If the timestamps also match, sort by ID.
-	return m[i].ID > m[j].ID
+func (m markdown) relativeTime() string {
+	return relativeTime(m.Modtime)
+}
+
+// Normalize text to aid in the filtering process. In particular, we remove
+// diacritics, "ö" becomes "o". Note that Mn is the unicode key for nonspacing
+// marks.
+func normalize(in string) (string, error) {
+	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
+	out, _, err := transform.String(t, in)
+	if err != nil {
+		return "", fmt.Errorf("error normalizing: %w", err)
+	}
+	return out, nil
+}
+
+// Return the time in a human-readable format relative to the current time.
+func relativeTime(then time.Time) string {
+	now := time.Now()
+	if ago := now.Sub(then); ago < time.Minute {
+		return "just now"
+	} else if ago < humanize.Week {
+		return humanize.CustomRelTime(then, now, "ago", "from now", magnitudes)
+	}
+	return then.Format("02 Jan 2006 15:04 MST")
+}
+
+// Magnitudes for relative time.
+var magnitudes = []humanize.RelTimeMagnitude{
+	{D: time.Second, Format: "now", DivBy: time.Second},
+	{D: 2 * time.Second, Format: "1 second %s", DivBy: 1},
+	{D: time.Minute, Format: "%d seconds %s", DivBy: time.Second},
+	{D: 2 * time.Minute, Format: "1 minute %s", DivBy: 1},
+	{D: time.Hour, Format: "%d minutes %s", DivBy: time.Minute},
+	{D: 2 * time.Hour, Format: "1 hour %s", DivBy: 1},
+	{D: humanize.Day, Format: "%d hours %s", DivBy: time.Hour},
+	{D: 2 * humanize.Day, Format: "1 day %s", DivBy: 1},
+	{D: humanize.Week, Format: "%d days %s", DivBy: humanize.Day},
+	{D: 2 * humanize.Week, Format: "1 week %s", DivBy: 1},
+	{D: humanize.Month, Format: "%d weeks %s", DivBy: humanize.Week},
+	{D: 2 * humanize.Month, Format: "1 month %s", DivBy: 1},
+	{D: humanize.Year, Format: "%d months %s", DivBy: humanize.Month},
+	{D: 18 * humanize.Month, Format: "1 year %s", DivBy: 1},
+	{D: 2 * humanize.Year, Format: "2 years %s", DivBy: 1},
+	{D: humanize.LongTime, Format: "%d years %s", DivBy: humanize.Year},
+	{D: math.MaxInt64, Format: "a long while %s", DivBy: 1},
 }

ui/pager.go

@@ -2,103 +2,98 @@ package ui
 
 import (
 	"fmt"
-	"log"
 	"math"
+	"path/filepath"
 	"strings"
 	"time"
 
-	"github.com/charmbracelet/bubbles/spinner"
-	"github.com/charmbracelet/bubbles/textinput"
+	"github.com/atotto/clipboard"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/charm"
-	"github.com/charmbracelet/charm/ui/common"
 	"github.com/charmbracelet/glamour"
+	"github.com/charmbracelet/glow/v2/utils"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/log"
+	"github.com/fsnotify/fsnotify"
 	runewidth "github.com/mattn/go-runewidth"
 	"github.com/muesli/reflow/ansi"
-	te "github.com/muesli/termenv"
+	"github.com/muesli/reflow/truncate"
+	"github.com/muesli/termenv"
 )
 
 const (
-	maxDocumentWidth = 120
-	statusBarHeight  = 1
-	gray             = "#333333"
-	yellowGreen      = "#ECFD65"
-	fuschia          = "#EE6FF8"
-	mintGreen        = "#89F0CB"
-	darkGreen        = "#1C8760"
-	noteHeadingText  = " Set Memo "
-	notePromptText   = " > "
+	statusBarHeight = 1
+	lineNumberWidth = 4
 )
 
 var (
-	pagerHelpHeight = strings.Count(pagerHelpView(pagerModel{}, 0), "\n")
+	pagerHelpHeight int
 
-	noteHeading = te.String(noteHeadingText).
-			Foreground(common.Cream.Color()).
-			Background(common.Green.Color()).
-			String()
+	mintGreen = lipgloss.AdaptiveColor{Light: "#89F0CB", Dark: "#89F0CB"}
+	darkGreen = lipgloss.AdaptiveColor{Light: "#1C8760", Dark: "#1C8760"}
 
-	statusBarBg     = common.NewColorPair("#242424", "#E6E6E6")
-	statusBarNoteFg = common.NewColorPair("#7D7D7D", "#656565")
+	lineNumberFg = lipgloss.AdaptiveColor{Light: "#656565", Dark: "#7D7D7D"}
 
-	// Styling functions.
-	statusBarScrollPosStyle        = newStyle(common.NewColorPair("#5A5A5A", "#949494").String(), statusBarBg.String())
-	statusBarNoteStyle             = newStyle(statusBarNoteFg.String(), statusBarBg.String())
-	statusBarHelpStyle             = newStyle(statusBarNoteFg.String(), common.NewColorPair("#323232", "#DCDCDC").String())
-	statusBarStashDotStyle         = newStyle(common.Green.String(), statusBarBg.String())
-	statusBarMessageStyle          = newStyle(mintGreen, darkGreen)
-	statusBarMessageStashIconStyle = newStyle(mintGreen, darkGreen)
-	statusBarMessageScrollPosStyle = newStyle(mintGreen, darkGreen)
-	statusBarMessageHelpStyle      = newStyle("#B6FFE4", common.Green.String())
+	statusBarNoteFg = lipgloss.AdaptiveColor{Light: "#656565", Dark: "#7D7D7D"}
+	statusBarBg     = lipgloss.AdaptiveColor{Light: "#E6E6E6", Dark: "#242424"}
 
-	helpViewStyle = newStyle(statusBarNoteFg.String(), common.NewColorPair("#1B1B1B", "#f2f2f2").String())
+	statusBarScrollPosStyle = lipgloss.NewStyle().
+				Foreground(lipgloss.AdaptiveColor{Light: "#949494", Dark: "#5A5A5A"}).
+				Background(statusBarBg).
+				Render
+
+	statusBarNoteStyle = lipgloss.NewStyle().
+				Foreground(statusBarNoteFg).
+				Background(statusBarBg).
+				Render
+
+	statusBarHelpStyle = lipgloss.NewStyle().
+				Foreground(statusBarNoteFg).
+				Background(lipgloss.AdaptiveColor{Light: "#DCDCDC", Dark: "#323232"}).
+				Render
+
+	statusBarMessageStyle = lipgloss.NewStyle().
+				Foreground(mintGreen).
+				Background(darkGreen).
+				Render
+
+	statusBarMessageScrollPosStyle = lipgloss.NewStyle().
+					Foreground(mintGreen).
+					Background(darkGreen).
+					Render
+
+	statusBarMessageHelpStyle = lipgloss.NewStyle().
+					Foreground(lipgloss.Color("#B6FFE4")).
+					Background(green).
+					Render
+
+	helpViewStyle = lipgloss.NewStyle().
+			Foreground(statusBarNoteFg).
+			Background(lipgloss.AdaptiveColor{Light: "#f2f2f2", Dark: "#1B1B1B"}).
+			Render
+
+	lineNumberStyle = lipgloss.NewStyle().
+			Foreground(lineNumberFg).
+			Render
 )
 
-// Create a new termenv styling function.
-func newStyle(fg, bg string) func(string) string {
-	return te.Style{}.
-		Foreground(te.ColorProfile().Color(fg)).
-		Background(te.ColorProfile().Color(bg)).
-		Styled
-}
-
-// MSG
-
-type contentRenderedMsg string
-type noteSavedMsg *charm.Markdown
-type stashSuccessMsg markdown
-type stashErrMsg struct {
-	err error
-}
-
-func (s stashErrMsg) Error() string {
-	return s.err.Error()
-}
-
-// MODEL
+type (
+	contentRenderedMsg string
+	reloadMsg          struct{}
+)
 
 type pagerState int
 
 const (
 	pagerStateBrowse pagerState = iota
-	pagerStateSetNote
-	pagerStateStashing
-	pagerStateStashSuccess
 	pagerStateStatusMessage
 )
 
 type pagerModel struct {
-	cc           *charm.Client
-	authStatus   authStatus
-	viewport     viewport.Model
-	state        pagerState
-	glamourStyle string
-	width        int
-	height       int
-	showHelp     bool
-	textInput    textinput.Model
-	spinner      spinner.Model
+	common   *commonModel
+	viewport viewport.Model
+	state    pagerState
+	showHelp bool
 
 	statusMessage      string
 	statusMessageTimer *time.Timer
@@ -107,53 +102,32 @@ type pagerModel struct {
 	// it here so we can re-render it on resize.
 	currentDocument markdown
 
-	// Newly stashed markdown. We store it here temporarily so we can replace
-	// currentDocument above after a stash.
-	stashedDocument *markdown
+	watcher *fsnotify.Watcher
 }
 
-func newPagerModel(as authStatus, glamourStyle string) pagerModel {
+func newPagerModel(common *commonModel) pagerModel {
 	// Init viewport
-	vp := viewport.Model{}
+	vp := viewport.New(0, 0)
 	vp.YPosition = 0
 	vp.HighPerformanceRendering = config.HighPerformancePager
 
-	// Init text input UI for notes/memos
-	ti := textinput.NewModel()
-	ti.Prompt = te.String(notePromptText).
-		Foreground(te.ColorProfile().Color(gray)).
-		Background(te.ColorProfile().Color(yellowGreen)).
-		String()
-	ti.TextColor = gray
-	ti.BackgroundColor = yellowGreen
-	ti.CursorColor = fuschia
-	ti.CharLimit = noteCharacterLimit
-	ti.Focus()
-
-	sp := spinner.NewModel()
-	sp.ForegroundColor = statusBarNoteFg.String()
-	sp.BackgroundColor = statusBarBg.String()
-	sp.HideFor = time.Millisecond * 50
-	sp.MinimumLifetime = time.Millisecond * 180
-
-	return pagerModel{
-		state:        pagerStateBrowse,
-		authStatus:   as,
-		glamourStyle: glamourStyle,
-		textInput:    ti,
-		viewport:     vp,
-		spinner:      sp,
+	m := pagerModel{
+		common:   common,
+		state:    pagerStateBrowse,
+		viewport: vp,
 	}
+	m.initWatcher()
+	return m
 }
 
 func (m *pagerModel) setSize(w, h int) {
-	m.width = w
-	m.height = h
 	m.viewport.Width = w
 	m.viewport.Height = h - statusBarHeight
-	m.textInput.Width = w - len(noteHeadingText) - len(notePromptText) - 1
 
 	if m.showHelp {
+		if pagerHelpHeight == 0 {
+			pagerHelpHeight = strings.Count(m.helpView(), "\n")
+		}
 		m.viewport.Height -= (statusBarHeight + pagerHelpHeight)
 	}
 }
@@ -164,19 +138,24 @@ func (m *pagerModel) setContent(s string) {
 
 func (m *pagerModel) toggleHelp() {
 	m.showHelp = !m.showHelp
-	m.setSize(m.width, m.height)
+	m.setSize(m.common.width, m.common.height)
 	if m.viewport.PastBottom() {
 		m.viewport.GotoBottom()
 	}
 }
 
+type pagerStatusMessage struct {
+	message string
+	isError bool
+}
+
 // Perform stuff that needs to happen after a successful markdown stash. Note
-// that the the returned command should be sent back the through the pager
+// that the returned command should be sent back the through the pager
 // update function.
-func (m *pagerModel) showStatusMessage(statusMessage string) tea.Cmd {
+func (m *pagerModel) showStatusMessage(msg pagerStatusMessage) tea.Cmd {
 	// Show a success message to the user
 	m.state = pagerStateStatusMessage
-	m.statusMessage = statusMessage
+	m.statusMessage = msg.message
 	if m.statusMessageTimer != nil {
 		m.statusMessageTimer.Stop()
 	}
@@ -186,6 +165,7 @@ func (m *pagerModel) showStatusMessage(statusMessage string) tea.Cmd {
 }
 
 func (m *pagerModel) unload() {
+	log.Debug("unload")
 	if m.showHelp {
 		m.toggleHelp()
 	}
@@ -195,12 +175,10 @@ func (m *pagerModel) unload() {
 	m.state = pagerStateBrowse
 	m.viewport.SetContent("")
 	m.viewport.YOffset = 0
-	m.textInput.Reset()
+	m.unwatchFile()
 }
 
-// UPDATE
-
-func pagerUpdate(msg tea.Msg, m pagerModel) (pagerModel, tea.Cmd) {
+func (m pagerModel) update(msg tea.Msg) (pagerModel, tea.Cmd) {
 	var (
 		cmd  tea.Cmd
 		cmds []tea.Cmd
@@ -208,182 +186,124 @@ func pagerUpdate(msg tea.Msg, m pagerModel) (pagerModel, tea.Cmd) {
 
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
-		switch m.state {
-		case pagerStateSetNote:
-			switch msg.String() {
-			case "esc":
+		switch msg.String() {
+		case "q", keyEsc:
+			if m.state != pagerStateBrowse {
 				m.state = pagerStateBrowse
 				return m, nil
-			case "enter":
-				var cmd tea.Cmd
-				if m.textInput.Value() != m.currentDocument.Note { // don't update if the note didn't change
-					m.currentDocument.Note = m.textInput.Value() // update optimistically
-					cmd = saveDocumentNote(m.cc, m.currentDocument.ID, m.currentDocument.Note)
-				}
-				m.state = pagerStateBrowse
-				m.textInput.Reset()
-				return m, cmd
 			}
-		default:
-			switch msg.String() {
-			case "q", "esc":
-				if m.state != pagerStateBrowse {
-					m.state = pagerStateBrowse
-					return m, nil
-				}
-			case "home", "g":
-				m.viewport.GotoTop()
-				if m.viewport.HighPerformanceRendering {
-					cmds = append(cmds, viewport.Sync(m.viewport))
-				}
-			case "end", "G":
-				m.viewport.GotoBottom()
-				if m.viewport.HighPerformanceRendering {
-					cmds = append(cmds, viewport.Sync(m.viewport))
-				}
-			case "m":
-				isStashed := m.currentDocument.markdownType == stashedMarkdown ||
-					m.currentDocument.markdownType == convertedMarkdown
-
-				// Users can only set the note on user-stashed markdown
-				if !isStashed {
-					break
-				}
-
-				m.state = pagerStateSetNote
-
-				// Stop the timer for hiding a status message since changing
-				// the state above will have cleared it.
-				if m.statusMessageTimer != nil {
-					m.statusMessageTimer.Stop()
-				}
-
-				// Pre-populate note with existing value
-				if m.textInput.Value() == "" {
-					m.textInput.SetValue(m.currentDocument.Note)
-					m.textInput.CursorEnd()
-				}
-
-				return m, textinput.Blink(m.textInput)
-			case "s":
-				if m.authStatus != authOK {
-					break
-				}
-
-				// Stash a local document
-				if m.state != pagerStateStashing && m.currentDocument.markdownType == localMarkdown {
-					m.state = pagerStateStashing
-					m.spinner.Start()
-					cmds = append(
-						cmds,
-						stashDocument(m.cc, m.currentDocument),
-						spinner.Tick(m.spinner),
-					)
-				}
-			case "?":
-				m.toggleHelp()
-				if m.viewport.HighPerformanceRendering {
-					cmds = append(cmds, viewport.Sync(m.viewport))
-				}
+		case "home", "g":
+			m.viewport.GotoTop()
+			if m.viewport.HighPerformanceRendering {
+				cmds = append(cmds, viewport.Sync(m.viewport))
+			}
+		case "end", "G":
+			m.viewport.GotoBottom()
+			if m.viewport.HighPerformanceRendering {
+				cmds = append(cmds, viewport.Sync(m.viewport))
 			}
-		}
 
-	case spinner.TickMsg:
-		if m.state == pagerStateStashing || m.spinner.Visible() {
-			newSpinnerModel, cmd := spinner.Update(msg, m.spinner)
-			m.spinner = newSpinnerModel
-			cmds = append(cmds, cmd)
-		} else if m.state == pagerStateStashSuccess && !m.spinner.Visible() {
-			m.state = pagerStateBrowse
-			m.currentDocument = *m.stashedDocument
-			m.stashedDocument = nil
-			cmd := m.showStatusMessage("Stashed!")
-			cmds = append(cmds, cmd)
+		case "d":
+			m.viewport.HalfViewDown()
+			if m.viewport.HighPerformanceRendering {
+				cmds = append(cmds, viewport.Sync(m.viewport))
+			}
+
+		case "u":
+			m.viewport.HalfViewUp()
+			if m.viewport.HighPerformanceRendering {
+				cmds = append(cmds, viewport.Sync(m.viewport))
+			}
+
+		case "e":
+			lineno := int(math.RoundToEven(float64(m.viewport.TotalLineCount()) * m.viewport.ScrollPercent()))
+			if m.viewport.AtTop() {
+				lineno = 0
+			}
+			log.Info(
+				"opening editor",
+				"file", m.currentDocument.localPath,
+				"line", fmt.Sprintf("%d/%d", lineno, m.viewport.TotalLineCount()),
+			)
+			return m, openEditor(m.currentDocument.localPath, lineno)
+
+		case "c":
+			// Copy using OSC 52
+			termenv.Copy(m.currentDocument.Body)
+			// Copy using native system clipboard
+			_ = clipboard.WriteAll(m.currentDocument.Body)
+			cmds = append(cmds, m.showStatusMessage(pagerStatusMessage{"Copied contents", false}))
+
+		case "r":
+			return m, loadLocalMarkdown(&m.currentDocument)
+
+		case "?":
+			m.toggleHelp()
+			if m.viewport.HighPerformanceRendering {
+				cmds = append(cmds, viewport.Sync(m.viewport))
+			}
 		}
 
 	// Glow has rendered the content
 	case contentRenderedMsg:
+		log.Info("content rendered", "state", m.state)
+
 		m.setContent(string(msg))
 		if m.viewport.HighPerformanceRendering {
 			cmds = append(cmds, viewport.Sync(m.viewport))
 		}
+		cmds = append(cmds, m.watchFile)
 
-	// We've reveived terminal dimensions, either for the first time or
+	// The file was changed on disk and we're reloading it
+	case reloadMsg:
+		return m, loadLocalMarkdown(&m.currentDocument)
+
+	// We've finished editing the document, potentially making changes. Let's
+	// retrieve the latest version of the document so that we display
+	// up-to-date contents.
+	case editorFinishedMsg:
+		return m, loadLocalMarkdown(&m.currentDocument)
+
+	// We've received terminal dimensions, either for the first time or
 	// after a resize
 	case tea.WindowSizeMsg:
 		return m, renderWithGlamour(m, m.currentDocument.Body)
 
-	case stashSuccessMsg:
-		// Stashing was successful. Convert the loaded document to a stashed
-		// one and show a status message. Note that we're also handling this
-		// message in the main update function where we're adding this stashed
-		// item to the stash listing.
-		m.state = pagerStateStashSuccess
-		if !m.spinner.Visible() {
-			m.state = pagerStateBrowse
-			m.currentDocument = markdown(msg)
-			cmd := m.showStatusMessage("Stashed!")
-			cmds = append(cmds, cmd)
-		} else {
-			md := markdown(msg)
-			m.stashedDocument = &md
-		}
-
-	case stashErrMsg:
-		// TODO
-
 	case statusMessageTimeoutMsg:
-		// Hide the status message bar
 		m.state = pagerStateBrowse
 	}
 
-	switch m.state {
-	case pagerStateSetNote:
-		m.textInput, cmd = textinput.Update(msg, m.textInput)
-		cmds = append(cmds, cmd)
-	default:
-		m.viewport, cmd = viewport.Update(msg, m.viewport)
-		cmds = append(cmds, cmd)
-	}
+	m.viewport, cmd = m.viewport.Update(msg)
+	cmds = append(cmds, cmd)
 
 	return m, tea.Batch(cmds...)
 }
 
-// VIEW
-
-func pagerView(m pagerModel) string {
+func (m pagerModel) View() string {
 	var b strings.Builder
-
-	fmt.Fprint(&b, viewport.View(m.viewport)+"\n")
+	fmt.Fprint(&b, m.viewport.View()+"\n")
 
 	// Footer
-	switch m.state {
-	case pagerStateSetNote:
-		pagerSetNoteView(&b, m)
-	default:
-		pagerStatusBarView(&b, m)
-	}
+	m.statusBarView(&b)
 
 	if m.showHelp {
-		fmt.Fprint(&b, pagerHelpView(m, m.width))
+		fmt.Fprint(&b, "\n"+m.helpView())
 	}
 
 	return b.String()
 }
 
-func pagerStatusBarView(b *strings.Builder, m pagerModel) {
+func (m pagerModel) statusBarView(b *strings.Builder) {
 	const (
 		minPercent               float64 = 0.0
 		maxPercent               float64 = 1.0
 		percentToStringMagnitude float64 = 100.0
 	)
-	var (
-		isStashed         bool = m.currentDocument.markdownType == stashedMarkdown || m.currentDocument.markdownType == convertedMarkdown
-		showStatusMessage bool = m.state == pagerStateStatusMessage
-	)
+
+	showStatusMessage := m.state == pagerStateStatusMessage
 
 	// Logo
-	logo := glowLogoView(" Glow ")
+	logo := glowLogoView()
 
 	// Scroll percent
 	percent := math.Max(minPercent, math.Min(maxPercent, m.viewport.ScrollPercent()))
@@ -402,35 +322,19 @@ func pagerStatusBarView(b *strings.Builder, m pagerModel) {
 		helpNote = statusBarHelpStyle(" ? Help ")
 	}
 
-	// Status indicator; spinner or stash dot
-	var statusIndicator string
-	if m.state == pagerStateStashing || m.state == pagerStateStashSuccess {
-		if m.spinner.Visible() {
-			statusIndicator = statusBarNoteStyle(" ") + spinner.View(m.spinner)
-		}
-	} else if isStashed && showStatusMessage {
-		statusIndicator = statusBarMessageStashIconStyle(" " + pagerStashIcon)
-	} else if isStashed {
-		statusIndicator = statusBarStashDotStyle(" " + pagerStashIcon)
-	}
-
 	// Note
 	var note string
 	if showStatusMessage {
-		note = "Stashed!"
+		note = m.statusMessage
 	} else {
 		note = m.currentDocument.Note
-		if len(note) == 0 {
-			note = "(No memo)"
-		}
 	}
-	note = truncate(" "+note+" ", max(0,
-		m.width-
+	note = truncate.StringWithTail(" "+note+" ", uint(max(0, //nolint:gosec
+		m.common.width-
 			ansi.PrintableRuneWidth(logo)-
-			ansi.PrintableRuneWidth(statusIndicator)-
 			ansi.PrintableRuneWidth(scrollPercent)-
 			ansi.PrintableRuneWidth(helpNote),
-	))
+	)), ellipsis)
 	if showStatusMessage {
 		note = statusBarMessageStyle(note)
 	} else {
@@ -439,9 +343,8 @@ func pagerStatusBarView(b *strings.Builder, m pagerModel) {
 
 	// Empty space
 	padding := max(0,
-		m.width-
+		m.common.width-
 			ansi.PrintableRuneWidth(logo)-
-			ansi.PrintableRuneWidth(statusIndicator)-
 			ansi.PrintableRuneWidth(note)-
 			ansi.PrintableRuneWidth(scrollPercent)-
 			ansi.PrintableRuneWidth(helpNote),
@@ -453,9 +356,8 @@ func pagerStatusBarView(b *strings.Builder, m pagerModel) {
 		emptySpace = statusBarNoteStyle(emptySpace)
 	}
 
-	fmt.Fprintf(b, "%s%s%s%s%s%s",
+	fmt.Fprintf(b, "%s%s%s%s%s",
 		logo,
-		statusIndicator,
 		note,
 		emptySpace,
 		scrollPercent,
@@ -463,23 +365,16 @@ func pagerStatusBarView(b *strings.Builder, m pagerModel) {
 	)
 }
 
-func pagerSetNoteView(b *strings.Builder, m pagerModel) {
-	fmt.Fprint(b, noteHeading)
-	fmt.Fprint(b, textinput.View(m.textInput))
-}
-
-func pagerHelpView(m pagerModel, width int) (s string) {
-	col1 := [...]string{
+func (m pagerModel) helpView() (s string) {
+	col1 := []string{
 		"g/home  go to top",
 		"G/end   go to bottom",
-		"",
-		"m       set memo",
+		"c       copy contents",
+		"e       edit this document",
+		"r       reload this document",
 		"esc     back to files",
 		"q       quit",
 	}
-	if m.authStatus == authOK && m.currentDocument.markdownType != stashedMarkdown {
-		col1[5] = "s       stash this document"
-	}
 
 	s += "\n"
 	s += "k/↑      up                  " + col1[0] + "\n"
@@ -487,16 +382,20 @@ func pagerHelpView(m pagerModel, width int) (s string) {
 	s += "b/pgup   page up             " + col1[2] + "\n"
 	s += "f/pgdn   page down           " + col1[3] + "\n"
 	s += "u        ½ page up           " + col1[4] + "\n"
-	s += "d        ½ page down         " + col1[5] + "\n"
+	s += "d        ½ page down         "
+
+	if len(col1) > 5 {
+		s += col1[5]
+	}
 
 	s = indent(s, 2)
 
 	// Fill up empty cells with spaces for background coloring
-	if width > 0 {
+	if m.common.width > 0 {
 		lines := strings.Split(s, "\n")
 		for i := 0; i < len(lines); i++ {
 			l := runewidth.StringWidth(lines[i])
-			n := max(width-l, 0)
+			n := max(m.common.width-l, 0)
 			lines[i] += strings.Repeat(" ", n)
 		}
 
@@ -512,9 +411,7 @@ func renderWithGlamour(m pagerModel, md string) tea.Cmd {
 	return func() tea.Msg {
 		s, err := glamourRender(m, md)
 		if err != nil {
-			if debug {
-				log.Println("error rendering with Glamour:", err)
-			}
+			log.Error("error rendering with Glamour", "error", err)
 			return errMsg{err}
 		}
 		return contentRenderedMsg(s)
@@ -523,44 +420,116 @@ func renderWithGlamour(m pagerModel, md string) tea.Cmd {
 
 // This is where the magic happens.
 func glamourRender(m pagerModel, markdown string) (string, error) {
+	trunc := lipgloss.NewStyle().MaxWidth(m.viewport.Width - lineNumberWidth).Render
+
 	if !config.GlamourEnabled {
 		return markdown, nil
 	}
 
-	// initialize glamour
-	var gs glamour.TermRendererOption
-	if m.glamourStyle == "auto" {
-		gs = glamour.WithAutoStyle()
-	} else {
-		gs = glamour.WithStylePath(m.glamourStyle)
+	isCode := !utils.IsMarkdownFile(m.currentDocument.Note)
+	width := max(0, min(int(m.common.cfg.GlamourMaxWidth), m.viewport.Width)) //nolint:gosec
+	if isCode {
+		width = 0
 	}
 
-	width := max(0, min(maxDocumentWidth, m.viewport.Width))
-	r, err := glamour.NewTermRenderer(
-		gs,
+	options := []glamour.TermRendererOption{
+		utils.GlamourStyle(m.common.cfg.GlamourStyle, isCode),
 		glamour.WithWordWrap(width),
-	)
+	}
+
+	if m.common.cfg.PreserveNewLines {
+		options = append(options, glamour.WithPreservedNewLines())
+	}
+	r, err := glamour.NewTermRenderer(options...)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("error creating glamour renderer: %w", err)
+	}
+
+	if isCode {
+		markdown = utils.WrapCodeBlock(markdown, filepath.Ext(m.currentDocument.Note))
 	}
 
 	out, err := r.Render(markdown)
 	if err != nil {
-		return "", err
+		return "", fmt.Errorf("error rendering markdown: %w", err)
+	}
+
+	if isCode {
+		out = strings.TrimSpace(out)
 	}
 
 	// trim lines
 	lines := strings.Split(out, "\n")
 
-	var content string
+	var content strings.Builder
 	for i, s := range lines {
-		content += strings.TrimSpace(s)
+		if isCode || m.common.cfg.ShowLineNumbers {
+			content.WriteString(lineNumberStyle(fmt.Sprintf("%"+fmt.Sprint(lineNumberWidth)+"d", i+1)))
+			content.WriteString(trunc(s))
+		} else {
+			content.WriteString(s)
+		}
 
 		// don't add an artificial newline after the last split
 		if i+1 < len(lines) {
-			content += "\n"
+			content.WriteRune('\n')
 		}
 	}
 
-	return content, nil
+	return content.String(), nil
+}
+
+func (m *pagerModel) initWatcher() {
+	var err error
+	m.watcher, err = fsnotify.NewWatcher()
+	if err != nil {
+		log.Error("error creating fsnotify watcher", "error", err)
+	}
+}
+
+func (m *pagerModel) watchFile() tea.Msg {
+	dir := m.localDir()
+
+	if err := m.watcher.Add(dir); err != nil {
+		log.Error("error adding dir to fsnotify watcher", "error", err)
+		return nil
+	}
+
+	log.Info("fsnotify watching dir", "dir", dir)
+
+	for {
+		select {
+		case event, ok := <-m.watcher.Events:
+			if !ok || event.Name != m.currentDocument.localPath {
+				continue
+			}
+
+			if !event.Has(fsnotify.Write) && !event.Has(fsnotify.Create) {
+				continue
+			}
+
+			log.Debug("fsnotify event", "file", event.Name, "event", event.Op)
+			return reloadMsg{}
+		case err, ok := <-m.watcher.Errors:
+			if !ok {
+				continue
+			}
+			log.Debug("fsnotify error", "dir", dir, "error", err)
+		}
+	}
+}
+
+func (m *pagerModel) unwatchFile() {
+	dir := m.localDir()
+
+	err := m.watcher.Remove(dir)
+	if err == nil {
+		log.Debug("fsnotify dir unwatched", "dir", dir)
+	} else {
+		log.Error("fsnotify fail to unwatch dir", "dir", dir, "error", err)
+	}
+}
+
+func (m *pagerModel) localDir() string {
+	return filepath.Dir(m.currentDocument.localPath)
 }

ui/sort.go

@@ -0,0 +1,12 @@
+package ui
+
+import (
+	"cmp"
+	"slices"
+)
+
+func sortMarkdowns(mds []*markdown) {
+	slices.SortStableFunc(mds, func(a, b *markdown) int {
+		return cmp.Compare(a.Note, b.Note)
+	})
+}

ui/stashhelp.go

@@ -0,0 +1,297 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/muesli/reflow/ansi"
+)
+
+// helpEntry is a entry in a help menu containing values for a keystroke and
+// it's associated action.
+type helpEntry struct{ key, val string }
+
+// helpColumn is a group of helpEntries which will be rendered into a column.
+type helpColumn []helpEntry
+
+// newHelpColumn creates a help column from pairs of string arguments
+// representing keys and values. If the arguments are not even (and therein
+// not every key has a matching value) the function will panic.
+func newHelpColumn(pairs ...string) (h helpColumn) {
+	if len(pairs)%2 != 0 {
+		panic("help text group must have an even number of items")
+	}
+
+	for i := 0; i < len(pairs); i = i + 2 {
+		h = append(h, helpEntry{key: pairs[i], val: pairs[i+1]})
+	}
+
+	return
+}
+
+// render returns styled and formatted rows from keys and values.
+func (h helpColumn) render(height int) (rows []string) {
+	keyWidth, valWidth := h.maxWidths()
+
+	for i := 0; i < height; i++ {
+		var (
+			b    = strings.Builder{}
+			k, v string
+		)
+		if i < len(h) {
+			k = h[i].key
+			v = h[i].val
+
+			switch k {
+			case "s":
+				k = greenFg(k)
+				v = semiDimGreenFg(v)
+			default:
+				k = grayFg(k)
+				v = midGrayFg(v)
+			}
+		}
+		b.WriteString(k)
+		b.WriteString(strings.Repeat(" ", keyWidth-ansi.PrintableRuneWidth(k))) // pad keys
+		b.WriteString("  ")                                                     // gap
+		b.WriteString(v)
+		b.WriteString(strings.Repeat(" ", valWidth-ansi.PrintableRuneWidth(v))) // pad vals
+		rows = append(rows, b.String())
+	}
+
+	return
+}
+
+// maxWidths returns the widest key and values in the column, respectively.
+func (h helpColumn) maxWidths() (maxKey int, maxVal int) {
+	for _, v := range h {
+		kw := ansi.PrintableRuneWidth(v.key)
+		vw := ansi.PrintableRuneWidth(v.val)
+		if kw > maxKey {
+			maxKey = kw
+		}
+		if vw > maxVal {
+			maxVal = vw
+		}
+	}
+
+	return
+}
+
+// helpView returns either the mini or full help view depending on the state of
+// the model, as well as the total height of the help view.
+func (m stashModel) helpView() (string, int) {
+	numDocs := len(m.getVisibleMarkdowns())
+
+	// Help for when we're filtering
+	if m.filterState == filtering {
+		var h []string
+
+		switch numDocs {
+		case 0:
+			h = []string{"enter/esc", "cancel"}
+		case 1:
+			h = []string{"enter", "open", "esc", "cancel"}
+		default:
+			h = []string{"enter", "confirm", "esc", "cancel", "ctrl+j/ctrl+k ↑/↓", "choose"}
+		}
+
+		return m.renderHelp(h)
+	}
+
+	var (
+		navHelp       []string
+		filterHelp    []string
+		selectionHelp []string
+		editHelp      []string
+		sectionHelp   []string
+		appHelp       []string
+	)
+
+	if numDocs > 0 && m.showFullHelp {
+		navHelp = []string{"enter", "open", "j/k ↑/↓", "choose"}
+	}
+
+	if len(m.sections) > 1 {
+		if m.showFullHelp {
+			navHelp = append(navHelp, "tab/shift+tab", "section")
+		} else {
+			navHelp = append(navHelp, "tab", "section")
+		}
+	}
+
+	if m.paginator().TotalPages > 1 {
+		navHelp = append(navHelp, "h/l ←/→", "page")
+	}
+
+	// If we're browsing a filtered set
+	if m.filterApplied() {
+		filterHelp = []string{"/", "edit search", "esc", "clear filter"}
+	} else {
+		filterHelp = []string{"/", "find"}
+	}
+
+	// If there are errors
+	if m.err != nil {
+		appHelp = append(appHelp, "!", "errors")
+	}
+
+	appHelp = append(appHelp, "r", "refresh")
+
+	if numDocs > 0 {
+		appHelp = append(appHelp, "e", "edit")
+	}
+
+	appHelp = append(appHelp, "q", "quit")
+
+	// Detailed help
+	if m.showFullHelp {
+		if m.filterState != filtering {
+			appHelp = append(appHelp, "?", "close help")
+		}
+		return m.renderHelp(navHelp, filterHelp, append(selectionHelp, editHelp...), sectionHelp, appHelp)
+	}
+
+	// Mini help
+	if m.filterState != filtering {
+		appHelp = append(appHelp, "?", "more")
+	}
+	return m.renderHelp(navHelp, filterHelp, selectionHelp, editHelp, sectionHelp, appHelp)
+}
+
+const minHelpViewHeight = 5
+
+// renderHelp returns the rendered help view and associated line height for
+// the given groups of help items.
+func (m stashModel) renderHelp(groups ...[]string) (string, int) {
+	if m.showFullHelp {
+		str := m.fullHelpView(groups...)
+		numLines := strings.Count(str, "\n") + 1
+		return str, max(numLines, minHelpViewHeight)
+	}
+	return m.miniHelpView(concatStringSlices(groups...)...), 1
+}
+
+// Builds the help view from various sections pieces, truncating it if the view
+// would otherwise wrap to two lines. Help view entries should come in as pairs,
+// with the first being the key and the second being the help text.
+func (m stashModel) miniHelpView(entries ...string) string {
+	if len(entries) == 0 {
+		return ""
+	}
+
+	var (
+		truncationChar  = subtleStyle.Render("…")
+		truncationWidth = ansi.PrintableRuneWidth(truncationChar)
+	)
+
+	var (
+		next       string
+		leftGutter = "  "
+		maxWidth   = m.common.width -
+			stashViewHorizontalPadding -
+			truncationWidth -
+			ansi.PrintableRuneWidth(leftGutter)
+		s = leftGutter
+	)
+
+	for i := 0; i < len(entries); i = i + 2 {
+		k := entries[i]
+		v := entries[i+1]
+
+		k = grayFg(k)
+		v = midGrayFg(v)
+
+		next = fmt.Sprintf("%s %s", k, v)
+
+		if i < len(entries)-2 {
+			next += dividerDot.String()
+		}
+
+		// Only this (and the following) help text items if we have the
+		// horizontal space
+		if ansi.PrintableRuneWidth(s)+ansi.PrintableRuneWidth(next) >= maxWidth {
+			s += truncationChar
+			break
+		}
+
+		s += next
+	}
+	return s
+}
+
+func (m stashModel) fullHelpView(groups ...[]string) string {
+	var tallestCol int
+	columns := make([]helpColumn, 0, len(groups))
+	renderedCols := make([][]string, 0, len(groups)) // final rows grouped by column
+
+	// Get key/value pairs
+	for _, g := range groups {
+		if len(g) == 0 {
+			continue // ignore empty columns
+		}
+
+		columns = append(columns, newHelpColumn(g...))
+	}
+
+	// Find the tallest column
+	for _, c := range columns {
+		if len(c) > tallestCol {
+			tallestCol = len(c)
+		}
+	}
+
+	// Build columns
+	for _, c := range columns {
+		renderedCols = append(renderedCols, c.render(tallestCol))
+	}
+
+	// Merge columns
+	return mergeColumns(renderedCols...)
+}
+
+// Merge columns together to build the help view.
+func mergeColumns(cols ...[]string) string {
+	const minimumHeight = 3
+
+	// Find the tallest column
+	var tallestCol int
+	for _, v := range cols {
+		n := len(v)
+		if n > tallestCol {
+			tallestCol = n
+		}
+	}
+
+	// Make sure the tallest column meets the minimum height
+	if tallestCol < minimumHeight {
+		tallestCol = minimumHeight
+	}
+
+	b := strings.Builder{}
+	for i := 0; i < tallestCol; i++ {
+		for j, col := range cols {
+			if i >= len(col) {
+				continue // skip if we're past the length of this column
+			}
+			if j == 0 {
+				b.WriteString("  ") // gutter
+			} else if j > 0 {
+				b.WriteString("    ") // gap
+			}
+			b.WriteString(col[i])
+		}
+		if i < tallestCol-1 {
+			b.WriteRune('\n')
+		}
+	}
+
+	return b.String()
+}
+
+func concatStringSlices(s ...[]string) (agg []string) {
+	for _, v := range s {
+		agg = append(agg, v...)
+	}
+	return
+}

ui/stashitem.go

@@ -4,94 +4,117 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/charmbracelet/bubbles/textinput"
-	"github.com/charmbracelet/charm/ui/common"
-	rw "github.com/mattn/go-runewidth"
-	te "github.com/muesli/termenv"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/charmbracelet/log"
+	"github.com/muesli/reflow/truncate"
+	"github.com/sahilm/fuzzy"
 )
 
 const (
-	newsPrefix           = "News: "
 	verticalLine         = "│"
-	noMemoTitle          = "No Memo"
 	fileListingStashIcon = "• "
 )
 
-var (
-	greenFg        = te.Style{}.Foreground(common.NewColorPair("#04B575", "#04B575").Color()).Styled
-	fuchsiaFg      = te.Style{}.Foreground(common.Fuschia.Color()).Styled
-	dullFuchsiaFg  = te.Style{}.Foreground(common.NewColorPair("#AD58B4", "#F793FF").Color()).Styled
-	yellowFg       = te.Style{}.Foreground(common.YellowGreen.Color()).Styled                        // renders light green on light backgrounds
-	dullYellowFg   = te.Style{}.Foreground(common.NewColorPair("#9BA92F", "#6BCB94").Color()).Styled // renders light green on light backgrounds
-	subtleIndigoFg = te.Style{}.Foreground(common.NewColorPair("#514DC1", "#7D79F6").Color()).Styled
-	redFg          = te.Style{}.Foreground(common.Red.Color()).Styled
-	faintRedFg     = te.Style{}.Foreground(common.FaintRed.Color()).Styled
-	warmGrayFg     = te.Style{}.Foreground(common.NewColorPair("#979797", "#847A85").Color()).Styled
-)
-
 func stashItemView(b *strings.Builder, m stashModel, index int, md *markdown) {
 	var (
-		truncateTo = m.terminalWidth - stashViewHorizontalPadding*2
-		gutter     string
-		title      = md.Note
-		date       = relativeTime(md.CreatedAt)
-		icon       = ""
+		truncateTo  = uint(m.common.width - stashViewHorizontalPadding*2) //nolint:gosec
+		gutter      string
+		title       = truncate.StringWithTail(md.Note, truncateTo, ellipsis)
+		date        = md.relativeTime()
+		editedBy    = ""
+		hasEditedBy = false
+		icon        = ""
+		separator   = ""
 	)
 
-	switch md.markdownType {
-	case newsMarkdown:
-		if title == "" {
-			title = "News"
-		} else {
-			title = newsPrefix + truncate(title, truncateTo-rw.StringWidth(newsPrefix))
-		}
-	case stashedMarkdown, convertedMarkdown:
-		icon = fileListingStashIcon
-		if title == "" {
-			title = noMemoTitle
-		}
-		title = truncate(title, truncateTo-rw.StringWidth(icon))
-	default:
-		title = truncate(title, truncateTo)
-	}
+	isSelected := index == m.cursor()
+	isFiltering := m.filterState == filtering
+	singleFilteredItem := isFiltering && len(m.getVisibleMarkdowns()) == 1
 
-	if index == m.index {
-		switch m.state {
-		case stashStatePromptDelete:
-			// Deleting
-			gutter = faintRedFg(verticalLine)
-			icon = faintRedFg(icon)
-			title = redFg(title)
-			date = faintRedFg(date)
-		case stashStateSettingNote:
-			// Setting note
-			gutter = dullYellowFg(verticalLine)
-			icon = ""
-			title = textinput.View(m.noteInput)
-			date = dullYellowFg(date)
-		default:
-			// Selected
+	// If there are multiple items being filtered don't highlight a selected
+	// item in the results. If we've filtered down to one item, however,
+	// highlight that first item since pressing return will open it.
+	if isSelected && !isFiltering || singleFilteredItem { //nolint:nestif
+		// Selected item
+		if m.statusMessage == stashingStatusMessage {
+			gutter = greenFg(verticalLine)
+			icon = dimGreenFg(icon)
+			title = greenFg(title)
+			date = semiDimGreenFg(date)
+			editedBy = semiDimGreenFg(editedBy)
+			separator = semiDimGreenFg(separator)
+		} else {
 			gutter = dullFuchsiaFg(verticalLine)
-			icon = dullFuchsiaFg(icon)
-			title = fuchsiaFg(title)
-			date = dullFuchsiaFg(date)
+			if m.currentSection().key == filterSection &&
+				m.filterState == filterApplied || singleFilteredItem {
+				s := lipgloss.NewStyle().Foreground(fuchsia)
+				title = styleFilteredText(title, m.filterInput.Value(), s, s.Underline(true))
+			} else {
+				title = fuchsiaFg(title)
+				icon = fuchsiaFg(icon)
+			}
+			date = dimFuchsiaFg(date)
+			editedBy = dimDullFuchsiaFg(editedBy)
+			separator = dullFuchsiaFg(separator)
 		}
 	} else {
-		// Normal
-		if md.markdownType == newsMarkdown {
-			gutter = " "
-			title = te.String(title).Foreground(common.Indigo.Color()).String()
-			date = subtleIndigoFg(date)
+		gutter = " "
+		if m.statusMessage == stashingStatusMessage {
+			icon = dimGreenFg(icon)
+			title = greenFg(title)
+			date = semiDimGreenFg(date)
+			editedBy = semiDimGreenFg(editedBy)
+			separator = semiDimGreenFg(separator)
+		} else if isFiltering && m.filterInput.Value() == "" {
+			icon = dimGreenFg(icon)
+			title = dimNormalFg(title)
+			date = dimBrightGrayFg(date)
+			editedBy = dimBrightGrayFg(editedBy)
+			separator = dimBrightGrayFg(separator)
 		} else {
 			icon = greenFg(icon)
-			if title == noMemoTitle {
-				title = warmGrayFg(title)
-			}
-			gutter = " "
-			date = warmGrayFg(date)
+
+			s := lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#1a1a1a", Dark: "#dddddd"})
+			title = styleFilteredText(title, m.filterInput.Value(), s, s.Underline(true))
+			date = grayFg(date)
+			editedBy = midGrayFg(editedBy)
+			separator = brightGrayFg(separator)
 		}
 	}
 
-	fmt.Fprintf(b, "%s %s%s\n", gutter, icon, title)
+	fmt.Fprintf(b, "%s %s%s%s%s\n", gutter, icon, separator, separator, title)
 	fmt.Fprintf(b, "%s %s", gutter, date)
+	if hasEditedBy {
+		fmt.Fprintf(b, " %s", editedBy)
+	}
+}
+
+func styleFilteredText(haystack, needles string, defaultStyle, matchedStyle lipgloss.Style) string {
+	b := strings.Builder{}
+
+	normalizedHay, err := normalize(haystack)
+	if err != nil {
+		log.Error("error normalizing", "haystack", haystack, "error", err)
+	}
+
+	matches := fuzzy.Find(needles, []string{normalizedHay})
+	if len(matches) == 0 {
+		return defaultStyle.Render(haystack)
+	}
+
+	m := matches[0] // only one match exists
+	for i, rune := range []rune(haystack) {
+		styled := false
+		for _, mi := range m.MatchedIndexes {
+			if i == mi {
+				b.WriteString(matchedStyle.Render(string(rune)))
+				styled = true
+			}
+		}
+		if !styled {
+			b.WriteString(defaultStyle.Render(string(rune)))
+		}
+	}
+
+	return b.String()
 }

ui/styles.go

@@ -0,0 +1,46 @@
+package ui
+
+import "github.com/charmbracelet/lipgloss"
+
+// Colors.
+var (
+	normalDim      = lipgloss.AdaptiveColor{Light: "#A49FA5", Dark: "#777777"}
+	gray           = lipgloss.AdaptiveColor{Light: "#909090", Dark: "#626262"}
+	midGray        = lipgloss.AdaptiveColor{Light: "#B2B2B2", Dark: "#4A4A4A"}
+	darkGray       = lipgloss.AdaptiveColor{Light: "#DDDADA", Dark: "#3C3C3C"}
+	brightGray     = lipgloss.AdaptiveColor{Light: "#847A85", Dark: "#979797"}
+	dimBrightGray  = lipgloss.AdaptiveColor{Light: "#C2B8C2", Dark: "#4D4D4D"}
+	cream          = lipgloss.AdaptiveColor{Light: "#FFFDF5", Dark: "#FFFDF5"}
+	yellowGreen    = lipgloss.AdaptiveColor{Light: "#04B575", Dark: "#ECFD65"}
+	fuchsia        = lipgloss.AdaptiveColor{Light: "#EE6FF8", Dark: "#EE6FF8"}
+	dimFuchsia     = lipgloss.AdaptiveColor{Light: "#F1A8FF", Dark: "#99519E"}
+	dullFuchsia    = lipgloss.AdaptiveColor{Dark: "#AD58B4", Light: "#F793FF"}
+	dimDullFuchsia = lipgloss.AdaptiveColor{Light: "#F6C9FF", Dark: "#7B4380"}
+	green          = lipgloss.Color("#04B575")
+	red            = lipgloss.AdaptiveColor{Light: "#FF4672", Dark: "#ED567A"}
+	semiDimGreen   = lipgloss.AdaptiveColor{Light: "#35D79C", Dark: "#036B46"}
+	dimGreen       = lipgloss.AdaptiveColor{Light: "#72D2B0", Dark: "#0B5137"}
+)
+
+// Ulimately, we'll transition to named styles.
+var (
+	dimNormalFg      = lipgloss.NewStyle().Foreground(normalDim).Render
+	brightGrayFg     = lipgloss.NewStyle().Foreground(brightGray).Render
+	dimBrightGrayFg  = lipgloss.NewStyle().Foreground(dimBrightGray).Render
+	grayFg           = lipgloss.NewStyle().Foreground(gray).Render
+	midGrayFg        = lipgloss.NewStyle().Foreground(midGray).Render
+	darkGrayFg       = lipgloss.NewStyle().Foreground(darkGray)
+	greenFg          = lipgloss.NewStyle().Foreground(green).Render
+	semiDimGreenFg   = lipgloss.NewStyle().Foreground(semiDimGreen).Render
+	dimGreenFg       = lipgloss.NewStyle().Foreground(dimGreen).Render
+	fuchsiaFg        = lipgloss.NewStyle().Foreground(fuchsia).Render
+	dimFuchsiaFg     = lipgloss.NewStyle().Foreground(dimFuchsia).Render
+	dullFuchsiaFg    = lipgloss.NewStyle().Foreground(dullFuchsia).Render
+	dimDullFuchsiaFg = lipgloss.NewStyle().Foreground(dimDullFuchsia).Render
+	redFg            = lipgloss.NewStyle().Foreground(red).Render
+	tabStyle         = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#909090", Dark: "#626262"})
+	selectedTabStyle = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#333333", Dark: "#979797"})
+	errorTitleStyle  = lipgloss.NewStyle().Foreground(cream).Background(red).Padding(0, 1)
+	subtleStyle      = lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "#9B9B9B", Dark: "#5C5C5C"})
+	paginationStyle  = subtleStyle
+)

ui/ui.go

@@ -1,94 +1,72 @@
+// Package ui provides the main UI for the glow application.
 package ui
 
 import (
-	"errors"
 	"fmt"
-	"io/ioutil"
-	"log"
 	"os"
-	"path"
+	"path/filepath"
 	"strings"
 	"time"
 
-	"github.com/charmbracelet/bubbles/spinner"
 	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/charm"
-	"github.com/charmbracelet/charm/keygen"
-	"github.com/charmbracelet/charm/ui/common"
+	"github.com/charmbracelet/glamour/styles"
+	"github.com/charmbracelet/glow/v2/utils"
+	"github.com/charmbracelet/log"
 	"github.com/muesli/gitcha"
 	te "github.com/muesli/termenv"
 )
 
 const (
-	noteCharacterLimit   = 256             // should match server
-	statusMessageTimeout = time.Second * 2 // how long to show status messages like "stashed!"
+	statusMessageTimeout = time.Second * 3 // how long to show status messages like "stashed!"
+	ellipsis             = "…"
 )
 
 var (
-	config            Config
-	glowLogoTextColor = common.Color("#ECFD65")
-	debug             = false // true if we're logging to a file, in which case we'll log more stuff
-	stashedOnly       = false
+	config Config
+
+	markdownExtensions = []string{
+		"*.md", "*.mdown", "*.mkdn", "*.mkd", "*.markdown",
+	}
 )
 
-// Config contains TUI-specific configuration.
-type Config struct {
-	ShowAllFiles bool
-	Gopath       string `env:"GOPATH"`
-	HomeDir      string `env:"HOME"`
-	StashedOnly  bool
-
-	// For debugging the UI
-	Logfile              string `env:"GLOW_LOGFILE"`
-	HighPerformancePager bool   `env:"GLOW_HIGH_PERFORMANCE_PAGER" default:"true"`
-	GlamourEnabled       bool   `env:"GLOW_ENABLE_GLAMOUR" default:"true"`
-}
-
 // NewProgram returns a new Tea program.
-func NewProgram(style string, cfg Config) *tea.Program {
-	if cfg.Logfile != "" {
-		log.Println("-- Starting Glow ----------------")
-		log.Printf("High performance pager: %v", cfg.HighPerformancePager)
-		log.Printf("Glamour rendering: %v", cfg.GlamourEnabled)
-		log.Println("Bubble Tea now initializing...")
-		debug = true
-	}
-	config = cfg
-	return tea.NewProgram(initialize(cfg, style), update, view)
-}
+func NewProgram(cfg Config, content string) *tea.Program {
+	log.Debug(
+		"Starting glow",
+		"high_perf_pager",
+		cfg.HighPerformancePager,
+		"glamour",
+		cfg.GlamourEnabled,
+	)
 
-// MESSAGES
+	config = cfg
+	opts := []tea.ProgramOption{tea.WithAltScreen()}
+	if cfg.EnableMouse {
+		opts = append(opts, tea.WithMouseCellMotion())
+	}
+	m := newModel(cfg, content)
+	return tea.NewProgram(m, opts...)
+}
 
 type errMsg struct{ err error }
-type newCharmClientMsg *charm.Client
-type sshAuthErrMsg struct{}
-type keygenFailedMsg struct{ err error }
-type keygenSuccessMsg struct{}
-type initLocalFileSearchMsg struct {
-	cwd string
-	ch  chan gitcha.SearchResult
-}
-type foundLocalFileMsg gitcha.SearchResult
-type localFileSearchFinished struct{}
-type gotStashMsg []*charm.Markdown
-type stashLoadErrMsg struct{ err error }
-type gotNewsMsg []*charm.Markdown
-type statusMessageTimeoutMsg applicationContext
-type newsLoadErrMsg struct{ err error }
 
-func (e errMsg) Error() string          { return e.err.Error() }
-func (e errMsg) Unwrap() error          { return e.err }
-func (k keygenFailedMsg) Error() string { return k.err.Error() }
-func (k keygenFailedMsg) Unwrap() error { return k.err }
-func (s stashLoadErrMsg) Error() string { return s.err.Error() }
-func (s stashLoadErrMsg) Unwrap() error { return s.err }
-func (s newsLoadErrMsg) Error() string  { return s.err.Error() }
-func (s newsLoadErrMsg) Unwrap() error  { return s.err }
+func (e errMsg) Error() string { return e.err.Error() }
 
-// MODEL
+type (
+	initLocalFileSearchMsg struct {
+		cwd string
+		ch  chan gitcha.SearchResult
+	}
+)
 
-// Which part of the application something appies to. Occasionally used as an
-// argument to commands and messages.
+type (
+	foundLocalFileMsg       gitcha.SearchResult
+	localFileSearchFinished struct{}
+	statusMessageTimeoutMsg applicationContext
+)
+
+// applicationContext indicates the area of the application something applies
+// to. Occasionally used as an argument to commands and messages.
 type applicationContext int
 
 const (
@@ -96,6 +74,7 @@ const (
 	pagerContext
 )
 
+// state is the top-level application state.
 type state int
 
 const (
@@ -104,48 +83,28 @@ const (
 )
 
 func (s state) String() string {
-	return [...]string{
-		"showing stash",
-		"showing document",
+	return map[state]string{
+		stateShowStash:    "showing file listing",
+		stateShowDocument: "showing document",
 	}[s]
 }
 
-type authStatus int
-
-const (
-	authConnecting authStatus = iota
-	authOK
-	authFailed
-)
-
-func (s authStatus) String() string {
-	return map[authStatus]string{
-		authConnecting: "connecting",
-		authOK:         "ok",
-		authFailed:     "failed",
-	}[s]
+// Common stuff we'll need to access in all models.
+type commonModel struct {
+	cfg    Config
+	cwd    string
+	width  int
+	height int
 }
 
-type keygenState int
-
-const (
-	keygenUnstarted keygenState = iota
-	keygenRunning
-	keygenFinished
-)
-
 type model struct {
-	cfg            Config
-	cc             *charm.Client
-	authStatus     authStatus
-	keygenState    keygenState
-	state          state
-	fatalErr       error
-	stash          stashModel
-	pager          pagerModel
-	terminalWidth  int
-	terminalHeight int
-	cwd            string // directory from which we're running Glow
+	common   *commonModel
+	state    state
+	fatalErr error
+
+	// Sub-models
+	stash stashModel
+	pager pagerModel
 
 	// Channel that receives paths to local markdown files
 	// (via the github.com/muesli/gitcha package)
@@ -156,72 +115,94 @@ type model struct {
 // method alters the model we also need to send along any commands returned.
 func (m *model) unloadDocument() []tea.Cmd {
 	m.state = stateShowStash
-	m.stash.state = stashStateReady
+	m.stash.viewState = stashStateReady
 	m.pager.unload()
 	m.pager.showHelp = false
 
 	var batch []tea.Cmd
 	if m.pager.viewport.HighPerformanceRendering {
-		batch = append(batch, tea.ClearScrollArea)
+		batch = append(batch, tea.ClearScrollArea) //nolint:staticcheck
 	}
-	if !m.stash.loaded.done(stashedOnly) || m.stash.loadingFromNetwork {
-		batch = append(batch, spinner.Tick(m.stash.spinner))
+
+	if !m.stash.shouldSpin() {
+		batch = append(batch, m.stash.spinner.Tick)
 	}
 	return batch
 }
 
-func (m *model) setAuthStatus(as authStatus) {
-	m.authStatus = as
-	m.stash.authStatus = as
-	m.pager.authStatus = as
-}
+func newModel(cfg Config, content string) tea.Model {
+	initSections()
 
-// INIT
-
-func initialize(cfg Config, style string) func() (tea.Model, tea.Cmd) {
-	return func() (tea.Model, tea.Cmd) {
-		if style == "auto" {
-			dbg := te.HasDarkBackground()
-			if dbg {
-				style = "dark"
-			} else {
-				style = "light"
-			}
+	if cfg.GlamourStyle == styles.AutoStyle {
+		if te.HasDarkBackground() {
+			cfg.GlamourStyle = styles.DarkStyle
+		} else {
+			cfg.GlamourStyle = styles.LightStyle
 		}
-
-		stashedOnly = cfg.StashedOnly
-
-		m := model{
-			cfg:         cfg,
-			state:       stateShowStash,
-			authStatus:  authConnecting,
-			keygenState: keygenUnstarted,
-		}
-		m.pager = newPagerModel(m.authStatus, style)
-		m.stash = newStashModel(m.authStatus)
-
-		cmds := []tea.Cmd{
-			newCharmClient,
-			spinner.Tick(m.stash.spinner),
-		}
-		if !cfg.StashedOnly {
-			cmds = append(cmds, findLocalFiles(m))
-		}
-
-		return m, tea.Batch(cmds...)
-	}
-}
-
-// UPDATE
-
-func update(msg tea.Msg, mdl tea.Model) (tea.Model, tea.Cmd) {
-	m, ok := mdl.(model)
-	if !ok {
-		return model{
-			fatalErr: errors.New("could not perform assertion on model in update"),
-		}, tea.Quit
 	}
 
+	common := commonModel{
+		cfg: cfg,
+	}
+
+	m := model{
+		common: &common,
+		state:  stateShowStash,
+		pager:  newPagerModel(&common),
+		stash:  newStashModel(&common),
+	}
+
+	path := cfg.Path
+	if path == "" && content != "" {
+		m.state = stateShowDocument
+		m.pager.currentDocument = markdown{Body: content}
+		return m
+	}
+
+	if path == "" {
+		path = "."
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		log.Error("unable to stat file", "file", path, "error", err)
+		m.fatalErr = err
+		return m
+	}
+	if info.IsDir() {
+		m.state = stateShowStash
+	} else {
+		cwd, _ := os.Getwd()
+		m.state = stateShowDocument
+		m.pager.currentDocument = markdown{
+			localPath: path,
+			Note:      stripAbsolutePath(path, cwd),
+			Modtime:   info.ModTime(),
+		}
+	}
+
+	return m
+}
+
+func (m model) Init() tea.Cmd {
+	cmds := []tea.Cmd{m.stash.spinner.Tick}
+
+	switch m.state {
+	case stateShowStash:
+		cmds = append(cmds, findLocalFiles(*m.common))
+	case stateShowDocument:
+		content, err := os.ReadFile(m.common.cfg.Path)
+		if err != nil {
+			log.Error("unable to read file", "file", m.common.cfg.Path, "error", err)
+			return func() tea.Msg { return errMsg{err} }
+		}
+		body := string(utils.RemoveFrontmatter(content))
+		cmds = append(cmds, renderWithGlamour(m.pager, body))
+	}
+
+	return tea.Batch(cmds...)
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	// If there's been an error, any key exits
 	if m.fatalErr != nil {
 		if _, ok := msg.(tea.KeyMsg); ok {
@@ -234,173 +215,108 @@ func update(msg tea.Msg, mdl tea.Model) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case tea.KeyMsg:
 		switch msg.String() {
-		case "q", "esc":
+		case "esc":
+			if m.state == stateShowDocument || m.stash.viewState == stashStateLoadingDocument {
+				batch := m.unloadDocument()
+				return m, tea.Batch(batch...)
+			}
+		case "r":
 			var cmd tea.Cmd
-
-			// Send these keys through to stash
-			switch m.state {
-			case stateShowStash:
-
-				switch m.stash.state {
-				case stashStateSettingNote, stashStatePromptDelete, stashStateShowingError:
-					m.stash, cmd = stashUpdate(msg, m.stash)
+			if m.state == stateShowStash {
+				// pass through all keys if we're editing the filter
+				if m.stash.filterState == filtering {
+					m.stash, cmd = m.stash.update(msg)
 					return m, cmd
 				}
+				m.stash.markdowns = nil
+				return m, m.Init()
+			}
 
-			// Special cases for the pager
-			case stateShowDocument:
-				switch m.pager.state {
-				// If setting a note send all keys straight through
-				case pagerStateSetNote:
-					var batch []tea.Cmd
-					newPagerModel, cmd := pagerUpdate(msg, m.pager)
-					m.pager = newPagerModel
-					batch = append(batch, cmd)
-					return m, tea.Batch(batch...)
+		case "q":
+			var cmd tea.Cmd
 
-				// Otherwise let the user exit the view or application as
-				// normal.
-				default:
-					switch msg.String() {
-					case "q":
-						return m, tea.Quit
-					case "esc":
-						var batch []tea.Cmd
-						batch = m.unloadDocument()
-						return m, tea.Batch(batch...)
-					}
+			switch m.state { //nolint:exhaustive
+			case stateShowStash:
+				// pass through all keys if we're editing the filter
+				if m.stash.filterState == filtering {
+					m.stash, cmd = m.stash.update(msg)
+					return m, cmd
 				}
 			}
 
 			return m, tea.Quit
 
 		case "left", "h", "delete":
-			if m.state == stateShowDocument && m.pager.state != pagerStateSetNote {
+			if m.state == stateShowDocument {
 				cmds = append(cmds, m.unloadDocument()...)
 				return m, tea.Batch(cmds...)
 			}
 
+		case "ctrl+z":
+			return m, tea.Suspend
+
 		// Ctrl+C always quits no matter where in the application you are.
 		case "ctrl+c":
 			return m, tea.Quit
-
-		// Repaint
-		case "ctrl+l":
-			// TODO
-			return m, nil
 		}
 
 	// Window size is received when starting up and on every resize
 	case tea.WindowSizeMsg:
-		m.terminalWidth = msg.Width
-		m.terminalHeight = msg.Height
+		m.common.width = msg.Width
+		m.common.height = msg.Height
 		m.stash.setSize(msg.Width, msg.Height)
 		m.pager.setSize(msg.Width, msg.Height)
 
-		// TODO: load more stash pages if we've resized, are on the last page,
-		// and haven't loaded more pages yet.
-
-	// We've started looking for local files
 	case initLocalFileSearchMsg:
 		m.localFileFinder = msg.ch
-		m.cwd = msg.cwd
+		m.common.cwd = msg.cwd
 		cmds = append(cmds, findNextLocalFile(m))
 
-	// We found a local file
-	case foundLocalFileMsg:
-		newMd := localFileToMarkdown(m.cwd, gitcha.SearchResult(msg))
-		m.stash.addMarkdowns(newMd)
-		cmds = append(cmds, findNextLocalFile(m))
-
-	case sshAuthErrMsg:
-		// If we haven't run the keygen yet, do that
-		if m.keygenState != keygenFinished {
-			m.keygenState = keygenRunning
-			cmds = append(cmds, generateSSHKeys)
-		} else {
-			// The keygen ran but things still didn't work and we can't auth
-			m.setAuthStatus(authFailed)
-			m.stash.err = errors.New("SSH authentication failed; we tried ssh-agent, loading keys from disk, and generating SSH keys")
-			if debug {
-				log.Println("entering offline mode;", m.stash.err)
-			}
-
-			// Even though it failed, news/stash loading is finished
-			m.stash.loaded |= loadedStash | loadedNews
-			m.stash.loadingFromNetwork = false
-		}
-
-	case keygenFailedMsg:
-		// Keygen failed. That sucks.
-		m.setAuthStatus(authFailed)
-		m.stash.err = errors.New("could not authenticate; could not generate SSH keys")
-		if debug {
-			log.Println("entering offline mode;", m.stash.err)
-		}
-
-		m.keygenState = keygenFinished
-
-		// Even though it failed, news/stash loading is finished
-		m.stash.loaded |= loadedStash | loadedNews
-		m.stash.loadingFromNetwork = false
-
-	case keygenSuccessMsg:
-		// The keygen's done, so let's try initializing the charm client again
-		m.keygenState = keygenFinished
-		cmds = append(cmds, newCharmClient)
-
-	case newCharmClientMsg:
-		m.cc = msg
-		m.setAuthStatus(authOK)
-		m.stash.cc = msg
-		m.pager.cc = msg
-		cmds = append(cmds, loadStash(m.stash), loadNews(m.stash))
-
-	case stashLoadErrMsg:
-		m.setAuthStatus(authFailed)
-
 	case fetchedMarkdownMsg:
+		// We've loaded a markdown file's contents for rendering
 		m.pager.currentDocument = *msg
-		cmds = append(cmds, renderWithGlamour(m.pager, msg.Body))
+		body := string(utils.RemoveFrontmatter([]byte(msg.Body)))
+		cmds = append(cmds, renderWithGlamour(m.pager, body))
 
 	case contentRenderedMsg:
 		m.state = stateShowDocument
 
-	case noteSavedMsg:
-		// A note was saved to a document. This will have be done in the
-		// pager, so we'll need to find the corresponding note in the stash.
-		// So, pass the message to the stash for processing.
-		stashModel, cmd := stashUpdate(msg, m.stash)
+	case localFileSearchFinished:
+		// Always pass these messages to the stash so we can keep it updated
+		// about network activity, even if the user isn't currently viewing
+		// the stash.
+		stashModel, cmd := m.stash.update(msg)
 		m.stash = stashModel
 		return m, cmd
 
-	case localFileSearchFinished, gotStashMsg, gotNewsMsg:
-		// Also pass these messages to the stash so we can keep it updated
-		// about network activity.
-		stashModel, cmd := stashUpdate(msg, m.stash)
-		m.stash = stashModel
-		return m, cmd
+	case foundLocalFileMsg:
+		newMd := localFileToMarkdown(m.common.cwd, gitcha.SearchResult(msg))
+		m.stash.addMarkdowns(newMd)
+		if m.stash.filterApplied() {
+			newMd.buildFilterValue()
+		}
+		if m.stash.shouldUpdateFilter() {
+			cmds = append(cmds, filterMarkdowns(m.stash))
+		}
+		cmds = append(cmds, findNextLocalFile(m))
 
-	case stashSuccessMsg:
-		// Something was stashed. Update the stash listing but don't run an
-		// actual update on the stash since we don't want to trigger the status
-		// message and generally don't want any other effects.
+	case filteredMarkdownMsg:
 		if m.state == stateShowDocument {
-			md := markdown(msg)
-			_ = m.stash.removeLocalMarkdown(md.localPath)
-			m.stash.addMarkdowns(&md)
+			newStashModel, cmd := m.stash.update(msg)
+			m.stash = newStashModel
+			cmds = append(cmds, cmd)
 		}
 	}
 
 	// Process children
 	switch m.state {
 	case stateShowStash:
-		newStashModel, cmd := stashUpdate(msg, m.stash)
+		newStashModel, cmd := m.stash.update(msg)
 		m.stash = newStashModel
 		cmds = append(cmds, cmd)
 
 	case stateShowDocument:
-		newPagerModel, cmd := pagerUpdate(msg, m.pager)
+		newPagerModel, cmd := m.pager.update(msg)
 		m.pager = newPagerModel
 		cmds = append(cmds, cmd)
 	}
@@ -408,23 +324,16 @@ func update(msg tea.Msg, mdl tea.Model) (tea.Model, tea.Cmd) {
 	return m, tea.Batch(cmds...)
 }
 
-// VIEW
-
-func view(mdl tea.Model) string {
-	m, ok := mdl.(model)
-	if !ok {
-		return "could not perform assertion on model in view"
-	}
-
+func (m model) View() string {
 	if m.fatalErr != nil {
 		return errorView(m.fatalErr, true)
 	}
 
-	switch m.state {
+	switch m.state { //nolint:exhaustive
 	case stateShowDocument:
-		return pagerView(m.pager)
+		return m.pager.View()
 	default:
-		return stashView(m.stash)
+		return m.stash.view()
 	}
 }
 
@@ -436,38 +345,51 @@ func errorView(err error, fatal bool) string {
 		exitMsg += "return"
 	}
 	s := fmt.Sprintf("%s\n\n%v\n\n%s",
-		te.String(" ERROR ").
-			Foreground(common.Cream.Color()).
-			Background(common.Red.Color()).
-			String(),
+		errorTitleStyle.Render("ERROR"),
 		err,
-		common.Subtle(exitMsg),
+		subtleStyle.Render(exitMsg),
 	)
 	return "\n" + indent(s, 3)
 }
 
 // COMMANDS
 
-func findLocalFiles(m model) tea.Cmd {
+func findLocalFiles(m commonModel) tea.Cmd {
 	return func() tea.Msg {
-		cwd, err := os.Getwd()
-		if err != nil {
-			if debug {
-				log.Println("error finding local files:", err)
+		log.Info("findLocalFiles")
+		var (
+			cwd = m.cfg.Path
+			err error
+		)
+
+		if cwd == "" {
+			cwd, err = os.Getwd()
+		} else {
+			var info os.FileInfo
+			info, err = os.Stat(cwd)
+			if err == nil && info.IsDir() {
+				cwd, err = filepath.Abs(cwd)
 			}
+		}
+
+		// Note that this is one error check for both cases above
+		if err != nil {
+			log.Error("error finding local files", "error", err)
 			return errMsg{err}
 		}
 
-		var ignore []string
-		if !m.cfg.ShowAllFiles {
-			ignore = ignorePatterns(m)
+		log.Debug("local directory is", "cwd", cwd)
+
+		// Switch between FindFiles and FindAllFiles to bypass .gitignore rules
+		var ch chan gitcha.SearchResult
+		if m.cfg.ShowAllFiles {
+			ch, err = gitcha.FindAllFilesExcept(cwd, markdownExtensions, nil)
+		} else {
+			ch, err = gitcha.FindFilesExcept(cwd, markdownExtensions, ignorePatterns(m))
 		}
 
-		ch, err := gitcha.FindFilesExcept(cwd, []string{"*.md"}, ignore)
 		if err != nil {
-			if debug {
-				log.Println("error finding local files:", err)
-			}
+			log.Error("error finding local files", "error", err)
 			return errMsg{err}
 		}
 
@@ -484,166 +406,11 @@ func findNextLocalFile(m model) tea.Cmd {
 			return foundLocalFileMsg(res)
 		}
 		// We're done
-		if debug {
-			log.Println("local file search finished")
-		}
+		log.Debug("local file search finished")
 		return localFileSearchFinished{}
 	}
 }
 
-func newCharmClient() tea.Msg {
-	cfg, err := charm.ConfigFromEnv()
-	if err != nil {
-		return errMsg{err}
-	}
-
-	cc, err := charm.NewClient(cfg)
-	if err == charm.ErrMissingSSHAuth {
-		if debug {
-			log.Println("missing SSH auth:", err)
-		}
-		return sshAuthErrMsg{}
-	} else if err != nil {
-		if debug {
-			log.Println("error creating new charm client:", err)
-		}
-		return errMsg{err}
-	}
-
-	return newCharmClientMsg(cc)
-}
-
-func loadStash(m stashModel) tea.Cmd {
-	return func() tea.Msg {
-		if m.cc == nil {
-			err := errors.New("no charm client")
-			if debug {
-				log.Println("error loading stash:", err)
-			}
-			return stashLoadErrMsg{err}
-		}
-		stash, err := m.cc.GetStash(m.page)
-		if err != nil {
-			if debug {
-				if _, ok := err.(charm.ErrAuthFailed); ok {
-					log.Println("auth failure while loading stash:", err)
-				} else {
-					log.Println("error loading stash:", err)
-				}
-			}
-			return stashLoadErrMsg{err}
-		}
-		return gotStashMsg(stash)
-	}
-}
-
-func loadNews(m stashModel) tea.Cmd {
-	return func() tea.Msg {
-		if m.cc == nil {
-			err := errors.New("no charm client")
-			if debug {
-				log.Println("error loading news:", err)
-			}
-			return newsLoadErrMsg{err}
-		}
-		news, err := m.cc.GetNews(1) // just fetch the first page
-		if err != nil {
-			if debug {
-				log.Println("error loading news:", err)
-			}
-			return newsLoadErrMsg{err}
-		}
-		return gotNewsMsg(news)
-	}
-}
-
-func generateSSHKeys() tea.Msg {
-	if debug {
-		log.Println("running keygen...")
-	}
-	_, err := keygen.NewSSHKeyPair(nil)
-	if err != nil {
-		if debug {
-			log.Println("keygen failed:", err)
-		}
-		return keygenFailedMsg{err}
-	}
-	if debug {
-		log.Println("keys generated succcessfully")
-	}
-	return keygenSuccessMsg{}
-}
-
-func saveDocumentNote(cc *charm.Client, id int, note string) tea.Cmd {
-	if cc == nil {
-		return func() tea.Msg {
-			err := errors.New("can't set note; no charm client")
-			if debug {
-				log.Println("error saving note:", err)
-			}
-			return errMsg{err}
-		}
-	}
-	return func() tea.Msg {
-		if err := cc.SetMarkdownNote(id, note); err != nil {
-			if debug {
-				log.Println("error saving note:", err)
-			}
-			return errMsg{err}
-		}
-		return noteSavedMsg(&charm.Markdown{ID: id, Note: note})
-	}
-}
-
-func stashDocument(cc *charm.Client, md markdown) tea.Cmd {
-	return func() tea.Msg {
-		if cc == nil {
-			return func() tea.Msg {
-				err := errors.New("can't stash; no charm client")
-				if debug {
-					log.Println("error stashing document:", err)
-				}
-				return stashErrMsg{err}
-			}
-		}
-
-		// Is the document missing a body? If so, it likely means it needs to
-		// be loaded. If the document body is really empty then we'll still
-		// stash it.
-		if len(md.Body) == 0 {
-			data, err := ioutil.ReadFile(md.localPath)
-			if err != nil {
-				if debug {
-					log.Println("error loading doucument body for stashing:", err)
-				}
-				return stashErrMsg{err}
-			}
-			md.Body = string(data)
-		}
-
-		// Turn local markdown into a newly stashed (converted) markdown
-		md.markdownType = convertedMarkdown
-		md.CreatedAt = time.Now()
-
-		// Set the note as the filename without the extension
-		p := md.localPath
-		md.Note = strings.Replace(path.Base(p), path.Ext(p), "", 1)
-
-		newMd, err := cc.StashMarkdown(md.Note, md.Body)
-		if err != nil {
-			if debug {
-				log.Println("error stashing document:", err)
-			}
-			return stashErrMsg{err}
-		}
-
-		// We really just need to know the ID so we can operate on this newly
-		// stashed markdown.
-		md.ID = newMd.ID
-		return stashSuccessMsg(md)
-	}
-}
-
 func waitForStatusMessageTimeout(appCtx applicationContext, t *time.Timer) tea.Cmd {
 	return func() tea.Msg {
 		<-t.C
@@ -653,21 +420,21 @@ func waitForStatusMessageTimeout(appCtx applicationContext, t *time.Timer) tea.C
 
 // ETC
 
-// Convert local file path to Markdown. Note that we could be doing things
-// like checking if the file is a directory, but we trust that gitcha has
-// already done that.
+// Convert a Gitcha result to an internal representation of a markdown
+// document. Note that we could be doing things like checking if the file is
+// a directory, but we trust that gitcha has already done that.
 func localFileToMarkdown(cwd string, res gitcha.SearchResult) *markdown {
-	md := &markdown{
-		markdownType: localMarkdown,
-		localPath:    res.Path,
-		displayPath:  strings.Replace(res.Path, cwd+"/", "", -1), // strip absolute path
-		Markdown:     charm.Markdown{},
+	return &markdown{
+		localPath: res.Path,
+		Note:      stripAbsolutePath(res.Path, cwd),
+		Modtime:   res.Info.ModTime(),
 	}
+}
 
-	md.Markdown.Note = md.displayPath
-	md.CreatedAt = res.Info.ModTime() // last modified time
-
-	return md
+func stripAbsolutePath(fullPath, cwd string) string {
+	fp, _ := filepath.EvalSymlinks(fullPath)
+	cp, _ := filepath.EvalSymlinks(cwd)
+	return strings.ReplaceAll(fp, cp+string(os.PathSeparator), "")
 }
 
 // Lightweight version of reflow's indent function.
@@ -683,17 +450,3 @@ func indent(s string, n int) string {
 	}
 	return b.String()
 }
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
-}

url.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"fmt"
+	"net/url"
+	"strings"
+	"sync"
+)
+
+const (
+	protoGithub = "github://"
+	protoGitlab = "gitlab://"
+	protoHTTPS  = "https://"
+)
+
+var (
+	githubURL *url.URL
+	gitlabURL *url.URL
+	urlsOnce  sync.Once
+)
+
+func init() {
+	urlsOnce.Do(func() {
+		githubURL, _ = url.Parse("https://github.com")
+		gitlabURL, _ = url.Parse("https://gitlab.com")
+	})
+}
+
+func readmeURL(path string) (*source, error) {
+	switch {
+	case strings.HasPrefix(path, protoGithub):
+		if u := githubReadmeURL(path); u != nil {
+			return readmeURL(u.String())
+		}
+		return nil, nil
+	case strings.HasPrefix(path, protoGitlab):
+		if u := gitlabReadmeURL(path); u != nil {
+			return readmeURL(u.String())
+		}
+		return nil, nil
+	}
+
+	if !strings.HasPrefix(path, protoHTTPS) {
+		path = protoHTTPS + path
+	}
+	u, err := url.Parse(path)
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse url: %w", err)
+	}
+
+	switch {
+	case u.Hostname() == githubURL.Hostname():
+		return findGitHubREADME(u)
+	case u.Hostname() == gitlabURL.Hostname():
+		return findGitLabREADME(u)
+	}
+
+	return nil, nil
+}
+
+func githubReadmeURL(path string) *url.URL {
+	path = strings.TrimPrefix(path, protoGithub)
+	parts := strings.Split(path, "/")
+	if len(parts) != 2 {
+		// custom hostnames are not supported yet
+		return nil
+	}
+	u, _ := url.Parse(githubURL.String())
+	return u.JoinPath(path)
+}
+
+func gitlabReadmeURL(path string) *url.URL {
+	path = strings.TrimPrefix(path, protoGitlab)
+	parts := strings.Split(path, "/")
+	if len(parts) != 2 {
+		// custom hostnames are not supported yet
+		return nil
+	}
+	u, _ := url.Parse(gitlabURL.String())
+	return u.JoinPath(path)
+}
+
+func isURL(path string) bool {
+	_, err := url.ParseRequestURI(path)
+	return err == nil && strings.Contains(path, "://")
+}

url_test.go

@@ -0,0 +1,30 @@
+package main
+
+import "testing"
+
+func TestURLParser(t *testing.T) {
+	for path, url := range map[string]string{
+		"github.com/charmbracelet/glow":             "https://raw.githubusercontent.com/charmbracelet/glow/master/README.md",
+		"github://charmbracelet/glow":               "https://raw.githubusercontent.com/charmbracelet/glow/master/README.md",
+		"github://caarlos0/dotfiles.fish":           "https://raw.githubusercontent.com/caarlos0/dotfiles.fish/main/README.md",
+		"github://tj/git-extras":                    "https://raw.githubusercontent.com/tj/git-extras/main/Readme.md",
+		"https://github.com/goreleaser/nfpm":        "https://raw.githubusercontent.com/goreleaser/nfpm/main/README.md",
+		"gitlab.com/caarlos0/test":                  "https://gitlab.com/caarlos0/test/-/raw/master/README.md",
+		"gitlab://caarlos0/test":                    "https://gitlab.com/caarlos0/test/-/raw/master/README.md",
+		"https://gitlab.com/terrakok/gitlab-client": "https://gitlab.com/terrakok/gitlab-client/-/raw/develop/Readme.md",
+	} {
+		t.Run(path, func(t *testing.T) {
+			t.Skip("test uses network, sometimes fails for no reason")
+			got, err := readmeURL(path)
+			if err != nil {
+				t.Fatalf("expected no error, got %v", err)
+			}
+			if got == nil {
+				t.Fatalf("should not be nil")
+			}
+			if url != got.URL {
+				t.Errorf("expected url for %s to be %s, was %s", path, url, got.URL)
+			}
+		})
+	}
+}

utils/utils.go

@@ -0,0 +1,113 @@
+// Package utils provides utility functions.
+package utils
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/charmbracelet/glamour"
+	"github.com/charmbracelet/glamour/ansi"
+	"github.com/charmbracelet/glamour/styles"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/mitchellh/go-homedir"
+)
+
+// RemoveFrontmatter removes the front matter header of a markdown file.
+func RemoveFrontmatter(content []byte) []byte {
+	if frontmatterBoundaries := detectFrontmatter(content); frontmatterBoundaries[0] == 0 {
+		return content[frontmatterBoundaries[1]:]
+	}
+	return content
+}
+
+var yamlPattern = regexp.MustCompile(`(?m)^---\r?\n(\s*\r?\n)?`)
+
+func detectFrontmatter(c []byte) []int {
+	if matches := yamlPattern.FindAllIndex(c, 2); len(matches) > 1 {
+		return []int{matches[0][0], matches[1][1]}
+	}
+	return []int{-1, -1}
+}
+
+// ExpandPath expands tilde and all environment variables from the given path.
+func ExpandPath(path string) string {
+	s, err := homedir.Expand(path)
+	if err == nil {
+		return os.ExpandEnv(s)
+	}
+	return os.ExpandEnv(path)
+}
+
+// WrapCodeBlock wraps a string in a code block with the given language.
+func WrapCodeBlock(s, language string) string {
+	return "```" + language + "\n" + s + "```"
+}
+
+var markdownExtensions = []string{
+	".md", ".mdown", ".mkdn", ".mkd", ".markdown",
+}
+
+// IsMarkdownFile returns whether the filename has a markdown extension.
+func IsMarkdownFile(filename string) bool {
+	ext := filepath.Ext(filename)
+
+	if ext == "" {
+		// By default, assume it's a markdown file.
+		return true
+	}
+
+	for _, v := range markdownExtensions {
+		if strings.EqualFold(ext, v) {
+			return true
+		}
+	}
+
+	// Has an extension but not markdown
+	// so assume this is a code file.
+	return false
+}
+
+// GlamourStyle returns a glamour.TermRendererOption based on the given style.
+func GlamourStyle(style string, isCode bool) glamour.TermRendererOption {
+	if !isCode {
+		if style == styles.AutoStyle {
+			return glamour.WithAutoStyle()
+		}
+		return glamour.WithStylePath(style)
+	}
+
+	// If we are rendering a pure code block, we need to modify the style to
+	// remove the indentation.
+
+	var styleConfig ansi.StyleConfig
+
+	switch style {
+	case styles.AutoStyle:
+		if lipgloss.HasDarkBackground() {
+			styleConfig = styles.DarkStyleConfig
+		} else {
+			styleConfig = styles.LightStyleConfig
+		}
+	case styles.DarkStyle:
+		styleConfig = styles.DarkStyleConfig
+	case styles.LightStyle:
+		styleConfig = styles.LightStyleConfig
+	case styles.PinkStyle:
+		styleConfig = styles.PinkStyleConfig
+	case styles.NoTTYStyle:
+		styleConfig = styles.NoTTYStyleConfig
+	case styles.DraculaStyle:
+		styleConfig = styles.DraculaStyleConfig
+	case styles.TokyoNightStyle:
+		styleConfig = styles.DraculaStyleConfig
+	default:
+		return glamour.WithStylesFromJSONFile(style)
+	}
+
+	var margin uint
+	styleConfig.CodeBlock.Margin = &margin
+
+	return glamour.WithStyles(styleConfig)
+}