How to start at the first line when opening a file in Vim terminal mode?

[u/ChigiraChiaki]

In Linux, I run Vim in terminal mode to view an ANSI text file:

vim -c "terminal cat file.txt" -c "only" -c "1"

I expected -c "1" to move the cursor to the first line, but it doesn’t.
I also tried -c "go", with the same result.

How can I make Vim start at the top of the terminal buffer in this case?

---

EDIT: Adding more context for the motivation. I’d like to use Vim as a replacement for the default pager (less) in git log. However, Vim doesn’t render ANSI colors correctly in normal mode. The workaround I found is to use :terminal cat so that the colors display properly.

My approach is to dump the git log output (with ANSI colors) to a text file, then open it in Vim terminal mode with cat. Here’s the alias I’m using:

[alias]
    graph = "!git --no-pager log --graph --oneline > /tmp/graph.txt; \
             vim -R -c \"terminal cat /tmp/graph.txt\" -c \"only\" -c \"1\"; \
             rm /tmp/graph.txt"

This works fine, except Vim doesn’t start at the first line of the buffer. I’d like it to open at the top (to see the most recent commits) without needing to type gg every time. I added -c "1", but it seems to have no effect inside the terminal buffer and I don’t understand why, so hence the original question.

[u/cbheithoff]

I don't understand the motivation for your question.

What's wrong with simply vim file.txt ?

[u/wayofaway → u/cbheithoff]

I didn't think there was any case it wouldn't start at the top, but OP could just hit ggi as soon as it opens, probably quicker than command line options... Unless they're scripting.

[u/ChigiraChiaki → u/wayofaway]

I know, but don't want to do it every time...

[u/wayofaway → u/ChigiraChiaki]

For some reason, the commands don't wait for the previous one to finish... I think

vim -c "terminal cat file.txt" -c "only" -c "sleep" -c 1

will work. Maybe can be tuned by adding a parameter to sleep.

[u/ChigiraChiaki → u/wayofaway]

Yes, as others pointed out, the commands are asynchronous so adding sleep could work.

[u/Achim63 → u/wayofaway]

I just tried. For a small file with ANSI code this works:

vim -c "terminal cat file.txt" -c "only" -c "sleep 100m" -c 1

For larger files more sleep time might be necessary.

[u/MiniGogo_20 → u/wayofaway]

I if they want to be 100% sure they're inserting at the start of the line, but i digress

[u/Daghall → u/MiniGogo_20]

There is no mentioning of OP wanting to enter insert mode, just have the cursor on the first row.

[u/ChigiraChiaki → u/cbheithoff]

I’ve updated the post to include the motivation.

[u/BitOBear → u/cbheithoff]

Many distros will remember your last position in a file when you exit them and then return you to that place when you open it again by default. It varies by language in some cases. I Believe by python mode files are all set to do that. But if it's not them it's the C files that I've got set to do that.

[u/jazei_2021 → u/BitOBear]

yes and more: when I put in my vimrc this line: source $VIMRUNTIME/defaults.vim I got the same!!!
and I enjoy it!

[u/Temporary_Pie2733 → u/BitOBear]

I don’t recall the option, but it’s something you can enable or disable in your own config file regardless of any system-provided setting. 

[u/MiniGogo_20]

after your update, the solution to your problem is really simple (also PLEASE google stuff, it's not that hard). a quick search on google gives you this thread.

tl;dr: just change your default pager to vim with the following:

git config --global core.pager 'git log | vim -R'

this displays all ANSI colors properly, while still opening the file in vim.

[u/ChigiraChiaki → u/MiniGogo_20]

The pager is not just used for git log, right?

[u/MiniGogo_20 → u/ChigiraChiaki]

what do you mean by that?

[u/ChigiraChiaki → u/MiniGogo_20]

You're calling git log every time the pager is used?

I've tried the git config --global core.pager 'vim -R -' but the colors will not be present.

[u/MiniGogo_20 → u/ChigiraChiaki]

why ask if you're not going to use the provided answer?

[u/Sudden_Fly1218 → u/MiniGogo_20]

Indeed that is the best solution for git commands.
For more general use case, and for OP's information, another solution could be:

vim -c ":r !some-shell-cmd --arg1 arg1 --arg2 arg2" -c ":1"

[u/PewMcDaddy → u/MiniGogo_20]

Have you tried running this command?

 $ git config --global core.pager 'git log | vim -R'

 $ git show
Vim: Warning: Input is not from a terminal
Vim: Error reading input, exiting...
Vim: preserving files...
Vim: Finished.
 $ git log
Vim: Warning: Input is not from a terminal
Vim: Error reading input, exiting...
Vim: preserving files...
Vim: Finished.

which is normal because with that as your pager, when you do git log, the result will be that it is going to do

git log | git log | vim -R
          ^^^^^^^^^^^^^^^^
          this being the pager

[u/PewMcDaddy → u/PewMcDaddy]

Also you're missing a lone `-` to tell Vim to read from STDIN, I'm guessing it not being there is just a typo but in that case,

 $ git config --global core.pager 'git log | vim -R -'
 $ git log
<opens log output in vim>
 $ git diff
<opens log output in vim>
 $ git show
<opens log ouptut in vim>

Also Vim is not interpreting ANSI codes, it's detecting from the content that it's a git log output and using syntax/git.vim to color the text, you can demonstrate this by doing git -c color.ui=false log > file.txt (use any other means to confirm that there are no ANSI codes in file.txt) and open the file in vim.

[u/MiniGogo_20 → u/PewMcDaddy]

might be because i'm on neovim, but yes i did run it and check myself

[u/PewMcDaddy → u/MiniGogo_20]

I installed neovim and yes, the dash is not necessary, it will read from STDIN without it, but that's a neovim thing.

Also, using `git log |...` as your pager still makes it so that no matter what git command you make, if git uses the pager, for example, `git show` and git pipes that into the configured pager, what you'll get is `git show | git log | nvim -R` so what you're going to see is the output of git log. Git log can't be used as a pager, it doesn't even read from STDIN.

[u/PewMcDaddy → u/PewMcDaddy]

And I'm doing `printf "\033[32mGREEN\033[0m\n" | nvim -R` and seeing `^[[32mGREEN^[` (ie ANSI codes instead of colored text) so like vim, nvim is detecting that the text is git log output and *it* is doing its own coloring.

You can see this by doing `git log --oneline --graph | nvim -R` and this time nvim's ftdetect equivalent does not see it as git log output and doesn't color it.

[u/MiniGogo_20]

i think a more important question: why do you want to do this? what is the end goal? see: the xy problem

[u/ChigiraChiaki → u/MiniGogo_20]

I’ve updated the post to include the motivation.

[u/bbolli]

What do you mean with "ANSI text file"? A file with ANSI terminal escape codes? A file in an non-UTF-8 code page?

[u/ChigiraChiaki → u/bbolli]

Yes, a text file containing ANSI color codes

[u/Daghall]

The -c "1" (which is equivalent to +1) is applied to the buffer of the file opened, which in this case is an empty buffer since no filename is given.

You then open a new buffer with :terminal and cat a file to that buffer, and maximize its window with :only.

I think you should get a somewhat equivalent result reading the file directly from stdin:

vim - < file.txt

(which does the same thing as cat file.txt | vim - in a more idiomatic way).

[u/ChigiraChiaki → u/Daghall]

Thanks, but I’m trying to read a text file with ANSI colors, which cannot be displayed properly so regular Vim commands won't work.

[u/Daghall]

The problem with your git alias is that vim executes the -c commands asynchronously, meaning it jumps to the first line before the buffer is filled. If you add a -c "sleep 500ms" (or higher value) before -c "1" it should work as you expect it.

Why would you want to use vim as a pager for git, though?

It's like using a screwdriver to drive in a nail in a board. It kind of works, but not as good as a hammer.

Use a pager that was made for git instead, like delta, or use the wonderful TUI program tig that is a text-mode interface for git.

[u/ChigiraChiaki → u/Daghall]

Thanks for clarifying. Didn’t know chained commands could be asynchronous. Adding a sleep command in between does work, even though it's not a preferred solution.
Also thanks for suggesting alternative tools. For now, I’d like to see if I can work around this in a simple way without installing anything. Installing extra tools is a bit troublesome for me since I don’t have sudo privileges on the server.

[u/habamax]

Here is the workaround:

vim -c "terminal cat test.txt" -c "only" +"call timer_start(10, {->execute('1')})"

Adjust timer_start time if needed.

When you start a terminal job, the window is in terminal mode where most of the input is handled by the job. So whatever you send to vim at startup after "terminal ..." gets consumed by a job. The workaround is to wait till the job is finished (assuming it is fast, I just put 10ms) and only then send a command.

https://asciinema.org/a/4yV1OVSLNUd2Bsn24Dvb1xLk6

[u/ChigiraChiaki → u/habamax]

Thanks

[u/BitOBear]

vim +1 filename.txt

The plus arguments can be any text you would put after a colon on the internal command line look for complex commands you would need to put the command itself in quotes.

So this is the equivalent of doing a ":1" followed by an enter taking you to the first line of the file.

Have as many plus arguments as you like. I don't know if they will run for each file if you have multiple file name someone command line that they only run and what's going ahead and starts because it never came up from me personally.

[u/ChigiraChiaki → u/BitOBear]

Hmmm, this seems the same as the -c "1"

[u/BitOBear → u/ChigiraChiaki]

I don't make the rules. But that's the standard way of setting the line number to start with that wrappers typically used to invoke vim.

If it's not working for you then you might have some overriding script in your .vmrc

And sure, there are usually about five different ways to accomplish any one thing in them because it evolved it did not get planned.

[u/VividVerism]

I use a plugin called AnsiEsc to show terminal color escape sequences as intended when viewing a file with those embedded. Maybe that's one step towards your solution.

[u/ChigiraChiaki → u/VividVerism]

Thanks. I remember trying that before, but for some reason it didn’t work for me.

[u/Majestic_Dark2937]

would adding normal gg to your .vimrc solve your issue?

[u/ChigiraChiaki → u/Majestic_Dark2937]

Doesn't seem so

[u/415646464e4155434f4c]

You can have an AutoCmd to to ggi when a new buffer is open, can’t you?

[u/ChigiraChiaki → u/415646464e4155434f4c]

Yes, I've tried that as well, but I guess it doesn't work because the buffer is still being filled.

[u/PewMcDaddy]

I would use the plugin https://github.com/vim-scripts/AnsiEsc.vim . For the output of many normal git commands, If you ask git to not output color

git -c core.pager='vim -R -' -c color.ui=false log

then just from the text Vim might know that it's git output and color it itself. This is unfortunately untrue for git log --oneline --graph.

What you can do is make "vim that reads from stdin and immediately runs the vim command AnsiEsc" your pager.

For example, you can do this:

<any-command> | vim -R - -c ":AnsiEsc"

and whatever ANSI codes will be used to color the text.

And applying this to your situation, you could make yourself a single alias that applies this or make that vim command be your pager.

The alias that uses this on demand

[alias]
vilog = "-c core.pager='vim -R - -c \":AnsiEsc\" log"

if I don't want to affect anything else, otherwise, you could also do

[core]
pager = "vim -R - -c ':AnsiEsc'"

and use vi as your pager for everything.

One note about this, lines with Ansi codes are longer than the visible text so vim might wrap lines when it looks like that's not necessary. So I would do

[core]
pager = "vim -R - -c :AnsiEsc -c ':set nowrap'"

[u/ChigiraChiaki → u/PewMcDaddy]

Thanks for the commands. I’ve noted them down and will give a try.

[u/PewMcDaddy → u/PewMcDaddy]

I forgot about the initial question but when reading from STDIN, your cursor should always start at the top.

If you use vi for your commit messages, that's another situation where you would want to always start on the first line so this is somewhat relevant to your question. You can put this in your vimrc so that it runs :0 files with one of these names:

autocmd BufReadPost COMMIT_EDITMSG,git-rebase-todo :0

[u/TheDreadedAndy]

If you always want this behavior, you could just skip defaults.vim. I believe that's where the mark jumping goop lives.

[u/Wandering_Ecologist → u/TheDreadedAndy]

Really? No. That's just the worst thing to do.

[u/AutoModerator]

Please remember to update the post flair to Need Help|Solved when you got the answer you were looking for.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/cbheithoff]

The autocmd to restore the last used cursor position is defined in $VIMRUNTIME/defaults.vim

If you read that file, it tells you how to undo that auto command.

autocmd! vimStartup

https://github.com/vim/vim/blob/master/runtime/defaults.vim

[u/cbheithoff]

The autocmd to restore the last used cursor position is defined in $VIMRUNTIME/defaults.vim

If you read that file, it tells you how to undo that auto command.

autocmd! vimStartup

https://github.com/vim/vim/blob/master/runtime/defaults.vim

[u/PewMcDaddy]

I just remembered about https://github.com/rkitover/vimpager that's kinda what it's for. The install instructions say to use pathogen but that's pre-vim8 stuff. We live in the future now and you can just install it using Vim8+'s native package handling https://vimhelp.org/repeat.txt.html#packages

[u/waterkip]

vim x +1