DEV Community: Eric Wong

Giving Your Neovim AI Assistant a Sense of Time: Scheduled Tasks in chat.nvim

Eric Wong — Wed, 08 Jul 2026 13:27:59 +0000

AI Is Passive

You tell AI "fix this code," it responds instantly. You say "remind me about the meeting in an hour," it says "sure" — and then nothing happens.

This isn't a bug in one product. It's a common limitation across most mainstream AI assistants: they are passive. They answer when you ask. They stay silent when you don't. They have no concept of "time," no concept of "the future," and no ability to initiate anything on their own. While some open-source or closed-source Agent frameworks already support scheduled tasks, mainstream assistants like Doubao and DeepSeek still lack this capability.

chat.nvim now includes a scheduled task feature, designed to give AI a sense of time — letting it proactively reach out to you at a future moment.

The Core Idea

To break AI's passivity, the key question is: how do we make AI start working at a future moment, as if it just received a user message?

The solution is straightforward, three steps:

Remember a task (when, what)
Trigger at the right time
Inject the message into the session — AI processes it like any user message

Simple in concept, but the devil is in the details. Let's walk through the design decisions for each part.

Time Model: Unified as Absolute Timestamps

Users can describe time in three ways:

"In 1 hour" — relative delay
"Tomorrow at 9 AM" — absolute point in time
"Every day at 10 PM" — recurring cycle

Pick one, they're mutually exclusive.

Regardless of how the user describes it, internally everything converts to a Unix timestamp. "In 1 hour" becomes current_time + 3600. "Every day" becomes every 86400 seconds starting from creation time.

Why? Because the scheduling engine only needs to handle one time model. No need to distinguish between "delay" and "schedule," no need for different logic branches. Unified abstraction eliminates branching.

Trigger Mechanism: No Polling, Use Timers

The most intuitive approach is polling: scan the task list every few seconds to check if anything is due.

That's wasteful. 99 out of 100 tasks are still waiting, yet you scan them every second.

A better approach: one independent timer per task. It wakes up only when due, with zero CPU overhead while waiting. This is event-driven, not poll-driven.

Neovim has libuv built in. uv.new_timer() does exactly this — millisecond precision, non-blocking on the main thread.

Anti-Drift for Recurring Tasks

Recurring tasks have a pitfall: if Neovim restarts midway, how do you calculate the next trigger time after recovery?

The instinctive approach is current_time + interval. But this causes rhythm drift — you set "every day at 10 AM," after a restart it becomes 10:03, after another restart 10:07...

The correct approach: calculate the next trigger based on creation time and execution count.

next_trigger = creation_time + (executed_count + 1) × interval

This way, no matter how many restarts happen, the 7th execution always lands at creation_time + 7 × interval. The rhythm is locked to the moment of creation.

The 24.8-Day Limit

libuv timers have a hard limit: maximum timeout of 2³¹-1 milliseconds, approximately 24.8 days.

What if a user sets a task 30 days out?

The solution is sharding. First set a 24.8-day timer. When it fires, check — the real trigger time hasn't arrived yet, so recalculate the remaining delay and set a new timer. Two relays cover any duration.

The 30-day cap covers reasonable use cases while preventing a buggy task from hanging around forever.

Decoupling Scheduling from Execution

This is the most critical decision in the entire design.

The scheduling engine does exactly one thing: when the time comes, push a message into the queue. It doesn't call the LLM API, doesn't care if AI is online, doesn't care about network status.

Why not just call the API directly when the timer fires? Because once responsibilities are mixed, complexity explodes:

What if AI is already processing another request?
What if the network is down?
What if the session was deleted?
What if the user is mid-keystroke?

After decoupling, the scheduling engine's logic is dead simple: fire → push → done. Everything else is handled by the message queue.

Message Queue: Waiting for a Window

After a task fires, the message enters a queue. The queue is responsible for delivering the message to AI at "the right moment."

What's the right moment? When the session is idle.

If AI isn't busy, send immediately
If AI is processing another request, queue up and check every few seconds — inject once it's free

It's like a colleague messaging you while you're in a meeting — the message doesn't disappear, you just read it after the meeting.

Only after 3 consecutive send failures does the message get discarded, preventing transient glitches from swallowing messages.

Persistence and Recovery

Neovim isn't a persistent process — users can close it at any time. Scheduled tasks must survive restarts.

The approach is straightforward: every time a task is created, cancelled, or fired, write all tasks to a JSON file on disk. On next launch, load it back.

One detail: libuv timers are in-memory objects that can't be serialized. When persisting, the timer handle must be excluded and recreated on recovery.

Recovery has two different strategies:

Expired one-time tasks: skip them. The trigger time has passed, they're meaningless now
Expired recurring tasks: must be restored. Recurring tasks need to continue executing — they shouldn't break just because of a restart

The Complete Flow

You say: "Remind me about the meeting in 1 hour"
    │
    ▼
AI calls the tool, calculates trigger_at = current_time + 3600
    │
    ▼
Scheduling engine creates the task, writes to disk, arms a 3600s timer
    │
    ··· (1 hour later) ···
    │
    ▼
Timer fires → pushes "Remind me about the meeting" into the session's message queue
    │
    ▼
Queue detects session is idle → sends to AI
    │
    ▼
AI receives the message, responds with a reminder — just as if you said it yourself

How to Use It

Just tell AI in natural language:

Remind me to follow up on the Subei People's Hospital project in 1 hour

AI will automatically calculate the time and create a scheduled task.

Three modes:

One-time: delay_seconds=3600 or trigger_at=1717200000
Recurring: interval=86400 (daily), optionally repeat_count=7 to limit repeats
Management: action="list" to view, action="cancel" to cancel

Feature	Details
Persistence	Survives Neovim restarts
Max delay	30 days
Min interval	10 seconds
Precision	Second-level (Unix timestamp based)
Dependencies	Zero external deps — pure Neovim + libuv

Summary

The scheduled task system in chat.nvim proves that giving AI a sense of time doesn't require a complex architecture. The key design principles:

Unify the time model — one abstraction, no branching
Event-driven, not poll-driven — zero overhead when idle
Lock the rhythm — anti-drift for recurring tasks
Decouple scheduling from execution — keep the engine simple
Persist everything — survive restarts gracefully

The result: AI that can proactively reach out when you need it, not just respond when you ask.

Multiple cursor support in SpaceVim

Eric Wong — Fri, 08 Apr 2022 14:42:26 +0000

SpaceVim is a preconfigured configuration for Vim and Neovim. It provides multiple cursor supportting via iedit plugin which just same as iedit-mode of emacs.

The default key binding of iedit is SPC s e, SPC is <Space>. There are two mode of iedit, iedit-normal mode and iedit-insert mode. Here are the key bindings of these two modes.

iedit states key bindings

State transitions:

Key Bindings	From	to
`SPC s e`	normal or visual	iedit-Normal

In iedit-Normal mode:

iedit-Normal mode inherits from Normal mode, the following key bindings are specific to iedit-Normal mode.

Key Binding	Descriptions
`<Esc>`	go back to `Normal` mode
`i`	switch to `iedit-Insert` mode, same as `i` in `Normal` model
`a`	switch to `iedit-Insert` mode, same as `a` in `Normal` model
`I`	go to the beginning of the current occurrence and switch to `iedit-Insert` mode, same as `I` in `Normal` model
`A`	go to the end of the current occurrence and switch to `iedit-Insert` mode, same as `A` in `Normal` model
`<Left>`/`h`	Move cursor to left, same as `h` in `Normal` model
`<Right>`/`l`	Move cursor to right, same as `l` in `Normal` model
`0`/`<Home>`	go to the beginning of the current occurrence, same as `0` in `Normal` model
`$`/`<End>`	go to the end of the current occurrence, same as `$` in `Normal` model
`C`	delete the characters from the cursor to the end in all occurrences and switch to iedit-Insert mode, same as `C` in `Normal` model
`D`	delete the occurrences, same as `D` in `Normal` model
`s`	delete the character under cursor and switch to iedit-Insert mode, same as `s` in `Normal` model
`S`	delete the occurrences and switch to iedit-Insert mode, same as `S` in `Normal` model
`x`	delete the character under cursor in all the occurrences, same as `x` in `Normal` model
`X`	delete the character before cursor in all the occurrences, same as `X` in `Normal` model
`gg`	go to first occurrence, same as `gg` in `Normal` model
`G`	go to last occurrence, same as `G` in `Normal` model
`f{char}`	Move the cursor to the right where the `{char}` first appears in all the occurrences
`n`	go to next occurrence
`N`	go to previous occurrence
`p`	replace occurrences with last yanked (copied) text
`<Tab>`	toggle current occurrence

In iedit-Insert mode:

Key Bindings	Descriptions
`Ctrl-g` / `<Esc>`	go back to `iedit-Normal` mode
`Ctrl-b` / `<Left>`	move cursor to left
`Ctrl-f` / `<Right>`	move cursor to right
`Ctrl-a` / `<Home>`	moves the cursor to the beginning of the current occurrence
`Ctrl-e` / `<End>`	moves the cursor to the end of the current occurrence
`Ctrl-w`	delete word before cursor
`Ctrl-k`	delete all words after cursor
`Ctrl-u`	delete all characters before cursor
`Ctrl-h` / `<Backspace>`	delete character before cursor
`<Delete>`	delete character after cursor

The SPC s e will select all matchs by default, if you want to select the matchs one by one, you can use SPC s E key binding and Ctrl-n to select next one.

Tasks manager within SpaceVim

Eric Wong — Sat, 22 Feb 2020 08:38:12 +0000

Tasks

To integrate with external tools, SpaceVim introduce a task manager system,
which is similar to vscode tasks-manager. There are two kinds of task configuration
file: global tasks configuration(~/.SpaceVim.d/tasks.toml) and local configuration(.SpaceVim.d/tasks.toml).

Key Bindings	Descriptions
`SPC p t e`	edit tasks configuration file
`SPC p t r`	select task to run

Task auto-detection

SpaceVim currently auto-detects tasks for npm.
the tasks manager will paser the package.json file for npm systems.
If you have cloned the eslint-starter example,
then pressing SPC p t r shows the following list:

Custom tasks

this is basic task configuration for running echo hello world, and print results to runner windows.

[my-task]
    command = 'echo'
    args = ['hello world']

To run task in the background, you need to set isBackground to true:

[my-task]
    command = 'echo'
    args = ['hello world']
    isBackground = true

The task's properties have the following semantic:

command: the actual command to execute.
args: the arguments passed to the command. can be omitted.
options: override the defaults for cwd,env or shell.

SpaceVim supports variable substitution in task, The following predefined variables are supported:

${workspaceFolder}: - the project root directory
${workspaceFolderBasename}: - the parent directory name of current project root
${file}: - the path of current file
${relativeFile}: - the current file relative to project root
${relativeFileDirname}: - the current file's dirname relative to workspaceFolder
${fileBasename}: - the current file's basename
${fileBasenameNoExtension}: - the current file's basename without file extension
${fileDirname}: - the current file's dirname
${fileExtname}: - the current file's extension
${cwd}: - the task runner's current working directory on startup
${lineNumber}: - the current selected line number in the active file

for example: Supposing that you have the following requirements:

A file located at /home/your-username/your-project/folder/file.ext opened in your editor;
The directory /home/your-username/your-project opened as your root workspace.
So you will have the following values for each variable:

${workspaceFolder}: - /home/your-username/your-project/
${workspaceFolderBasename}: - your-project
${file}: - /home/your-username/your-project/folder/file.ext
${relativeFile}: - folder/file.ext
${relativeFileDirname}: - folder/
${fileBasename}: - file.ext
${fileBasenameNoExtension}: - file
${fileDirname}: - /home/your-username/your-project/folder/
${fileExtname}: - .ext
${lineNumber}: - line number of the cursor

Use Vim as a Java IDE

Eric Wong — Mon, 24 Jun 2019 12:30:04 +0000

Use Vim as a Java IDE

why canonical_url do not word?!
the origin URL is https://spacevim.org/use-vim-as-a-java-ide/

This is a general guide for using SpaceVim as a Java IDE, including layer configuration and usage.
Each of the following sections will be covered:

Installation
Language server
Code completion
Code outline
Rename symbol
Javadoc hovers
Syntax lint
Import packages
Jump to test file
running code
Code formatting
REPL

Installation

SpaceVim is a Vim and neovim configuration, so you need to install vim or neovim,
here are two guides for installing neovim and vim8 with +python3 feature.
following the quick start guide to install SpaceVim.

SpaceVim do not enable language layer by default, so you need to enable lang#java layer.
Press SPC f v d to open SpaceVim configuration file, and add following section:

[[layers]]
  name = "lang#java"

Language server

To enable language server protocol support, you may need to enable lsp layer.

[[layers]]
  name = "lsp"
  filetypes = [
    "java"
  ]
  [layers.override_cmd]
    java = [
    "java",
    "-Declipse.application=org.eclipse.jdt.ls.core.id1",
    "-Dosgi.bundles.defaultStartLevel=4",
    "-Declipse.product=org.eclipse.jdt.ls.core.product",
    "-Dlog.protocol=true",
    "-Dlog.level=NONE",
    "-noverify",
    "-Xmx1G",
    "-jar",
    "D:\\dev\\jdt-language-server-latest\\plugins\\org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar",
    "-configuration",
    "D:\\dev\\jdt-language-server-latest\\config_win",
    "-data",
    "C:\\Users\\Administrator\\.cache\\javalsp"
    ]

You need to replace D:\dev\jdt-language-server-latest\plugins\org.eclipse.equinox.launcher_1.5.200.v20180922-1751.jar with the actual name of the org.eclipse.equinox.launcher jar

The configuration flag can point to either:

config_win, for Windows
config_mac, for MacOS
config_linux, for Linux

The data flag value should be the absolute path to the working directory of the server.
This should be different from the path of the user's project files (which is sent during the initialize handshake).

Code completion

javacomplete2 which has been included in lang#java layer provides omnifunc for java file and deoplete source.
with this plugin and autocomplete layer, the completion popup menu will be opened automatically。

Code outline

The default outline plugin is tagbar, and the key binding is F2. This key binding will open an outline sidebar on the left.

To fuzzy find outline in current buffer, you need to enable a fuzzy find layer, for example denite layer,
then press Leader f o:

Rename symbol

After enable lsp layer for java, you can use SPC l e to rename symbol under the cursor:

Javadoc hovers

The default key binding to get doc of cursor symbol is SPC l d or K:

Syntax lint

checkers layer provides asynchronous linting feature, this layer use neomake by default.
neomake support maven, gradle and eclipse project. it will generate classpath automatically for these project.

within above picture, we can see the checkers layer provides following feature:

list errors and warnings in quickfix windows
sign error and warning position on the left side
show numbers of errors and warnings on statusline
show cursor error and warning information below current line

Import packages

There are two kind features for importing packages, import packages automatically and manually. SpaceVim will import the packages after selecting the class name on popmenu.
Also, you can use key binding <F4> to import the class at the cursor point. If there are more than one class, a menu will be shown below current windows.

Jump to test file

SpaceVim use vim-project to manager the files in a project, you can add a .projections.json to the root of your project with following content:

{
  "src/main/java/*.java": {"alternate": "src/test/java/{dirname}/Test{basename}.java"},
  "src/test/java/**/Test*.java": {"alternate": "src/main/java/{}.java"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

Base on JavaUnite, you can use SPC l r c to run current function or use SPC l r m to run the main function of current Class.

Code formatting

For formatting java code, you also nEed have uncrustify or astyle in your PATH.
BTW, the google's java formatter also works well with neoformat.

REPL

you need to install jdk9 which provide a build-in tools jshell, and SpaceVim use the jshell as default inferior REPL process:

Use Vim as a C/C++ IDE

Eric Wong — Fri, 10 May 2019 00:00:00 +0000

Use Vim as a C/C++ IDE

This is a general guide for using SpaceVim as a C/C++ IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
code completion
alternate file jumping
code running
code format
REPL support  ### Enable language layer

To add C/C++ language support in SpaceVim, you need to enable the lang#c layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#c"

for more info, you can read the lang#c layer documentation.

code completion

By default the autocomplete layer has been enabled, so after loading lang#c layer, the code completionfor C/C++ language should works well.

alternate file jumping

To manage the alternate file for a project, you may need to create a .project_alt.json file in the root of yourproject.

for exmaple, add following content into the .project_alt.json file:

{
  "*.c": {"alternate": "{}.h"},
  "*.h": {"alternate": "{}.c"}
}

with this configuration, you can jump between the alternate file via command :A

code running

The default code running key binding is SPC l r. It will compile and run current file asynchronously.And the stdout will be shown on a runner buffer.

code format

The format layer use neoformat as default tool to format code, it will format current file.And the default key binding is SPC b f.

[[layers]]
  name = "format"

REPL support

Start a igcc inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process, all key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a PHP IDE

Eric Wong — Wed, 08 May 2019 00:00:00 +0000

Use Vim as a PHP IDE

This is a general guide for using SpaceVim as a PHP IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add PHP language support in SpaceVim, you need to enable the lang#php layer. Press SPC f v d to openSpaceVim configuration file, and add the following snippet:

[[layers]]
  name = "lang#php"

For more info, you can read the lang#php layer documentation.

Code completion

lang#php layer will load the PHP plugin automatically, unless it’s overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run psalm asynchronously.

To install psalm, you may need to run:

composer require --dev vimeo/psalm

Jump to test file

To manage the alternate file for a project, you may need to create a .project_alt.json file in the root of yourproject.

for exmaple, add following content into the .project_alt.json file:

{
  "src/*.php": {"alternate": "test/{}.php"},
  "test/*.php": {"alternate": "src/{}.php"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowwill be openen, the output of the script will be shown in this window.It is running asynchronously, and will not block your Vim.

Code formatting

The format layer is also enabled by default. With this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install php_beautifier:

pear install PHP_Beautifier

REPL support

Start a php -a inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process. All key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a Ruby IDE

Eric Wong — Mon, 18 Feb 2019 00:00:00 +0000

Use Vim as a Ruby IDE

This is a general guide for using SpaceVim as a Ruby IDE, including layer configuration and usage.Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add Ruby language support in SpaceVim, you need to enable the lang#ruby layer. Press SPC f v d to openSpaceVim configuration file, and add the following snippet:

[[layers]]
  name = "lang#ruby"

For more info, you can read the lang#ruby layer documentation.

Code completion

lang#ruby layer will load the Ruby plugin automatically, unless it’s overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run rubocop asynchronously.

Install rubocop via gem:

gem install rubocop

Jump to test file

SpaceVim use built-in plugin to manager the files in a project, you can add a .project_alt.json to the root of your project with the following content:

{
  "src/*.rb": {"alternate": "test/{}.rb"},
  "test/*.rb": {"alternate": "src/{}.rb"}
}

With this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowwill be openen, the output of the script will be shown in this window.It is running asynchronously, and will not block your Vim.

Code formatting

The format layer is also enabled by default. With this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install rufo:

gem install rufo

REPL support

Start a irb inferior REPL process with SPC l s i. After the REPL process being started, you cansend code to inferior process. All key bindings prefix with SPC l s, including sending line, sending selection or evensend whole buffer.

Use Vim as a Perl IDE

Eric Wong — Tue, 12 Feb 2019 00:00:00 +0000

Use Vim as a Perl IDE

This is a general guide for using SpaceVim as a perl IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting
REPL support  ### Enable language layer

To add perl language support in SpaceVim, you need to enable the lang#perl layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#perl"

for more info, you can read the lang#perl layer documentation.

Code completion

lang#perl layer will load the perl plugin automatically, unless overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run perl and perlcritic asynchronously.

Install perlcritic via cpan:

cpanm Perl::Critic

Jump to test file

SpaceVim use built-in plugin to manager the files in a project, you can add a .project_alt.json to the root of your project with following content:

{
  "src/*.pl": {"alternate": "test/{}.pl"},
  "test/*.pl": {"alternate": "src/{}.pl"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

The format layer is also enabled by default, with this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install perltidy:

cpanm Perl::Tidy

REPL support

Start a perli or perl -del inferior REPL process with SPC l s i. After the REPL process has been started. you can send code to inferior process, all key bindings are begin with SPC l s prefix, including sending line, sending selection or evensend whole buffer.

Use Vim as a CoffeeScript IDE

Eric Wong — Mon, 28 Jan 2019 00:00:00 +0000

Blogs » Use Vim as a CoffeeScript IDE

This is a general guide for using SpaceVim as a CoffeeScript IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax linting
Jump to test file
running code
Code formatting  ### Enable language layer

By default lang#coffeescript layer is not loaded. To add CoffeeScript language support in SpaceVim,you need to enable the lang#coffeescript layer. Press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#coffeescript"

for more info, you can read the lang#coffeescript layer documentation.

Code completion

lang#coffeescript layer will load the vim-coffeescript plugin automatically, unless overriden in your init.toml.The completion menu will be opened as you type.

Syntax linting

The checkers layer is enabled by default. This layer provides asynchronous syntax linting via neomake.It will run coffeelint asynchronously.

The coffeelint is command line lint for coffeescript, currently is maintained by Shuan Wang.To install coffeelint, just run following command in terminal.

npm install -g coffeelint

Note: if no coffeelint is installed, neomake will ues default command coffee.

Jump to test file

SpaceVim use built-in plugin to manager the files in a project,you can add a .project_alt.json to the root of your project with following content:

{
  "src/*.coffee": {"alternate": "test/{}.coffee"},
  "test/*.coffee": {"alternate": "src/{}.coffee"}
}

with this configuration, you can jump between the source code and test file via command :A.

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

The format layer is also enabled by default, with this layer you can use key binding SPC b f to format current buffer.Before using this feature, please install coffee-fmt.

npm install -g coffee-fmt

Use Vim as a Python IDE

Eric Wong — Thu, 27 Sep 2018 00:00:00 +0000

Use Vim as a Python IDE

This is a general guide for using SpaceVim as a python IDE, including layer configuration and usage. Each of the following sections will be covered:

Enable language layer
Code completion
Syntax lint
Import packages
Jump to test file
running code
Code formatting
REPL
Debug  ### Enable language layer

To add python language support in SpaceVim, you need to enable lang#python layer. Just press SPC f v d to openSpaceVim configuration file, and add following configuration:

[[layers]]
  name = "lang#python"

for more info, you can read the lang#python layer documentation.

Code completion

Base on which completion engine is used, lang#python layer load the jedi plugin automatically.The completion menu will be opened as you type.

Syntax lint

neomake - Asynchronous linting and make framework for Neovim/Vim

I am maintainer of javac maker in neomake, the javac maker support maven project, gradle project or eclipse project.also you can set the classpath.

Import packages

When edit python file, you can import the package automatically, remove unused package and format package list.

pip install --user isort

Jump to test file

SpaceVim use vim-project to manager the files in a project, you can add a .projections.json to the root of your project with following content:

{
  "src/*.py": {"alternate": "test/{dirname}/{basename}Test.py"},
  "test/**/Test*.py": {"alternate": "src/{}.py"}
}

with this configuration, you can jump between the source code and test file via command :A

running code

To run current script, you can press SPC l r, and a split windowswill be openen, the output of the script will be shown in this windows.It is running asynchronously, and will not block your vim.

Code formatting

neoformat - A (Neo)vim plugin for formatting code.

For formatting java code, you also nEed have uncrustify or astyle in your PATH.BTW, the google’s java formatter also works well with neoformat.

REPL

you need to install jdk9 which provide a build-in tools jshell, and SpaceVim use the jshell as default inferior REPL process:

Debug

Grep on the fly in SpaceVim

Eric Wong — Tue, 23 Jan 2018 00:00:00 +0000

Asynchronous grep on the fly

FlyGrep means grep on the fly , it will update the result as you type. Of course, it is runningasynchronously. Before using this feature, you need to install a searching tool. FlyGrep worksthrough search tools: ag, rg, ack, pt and grep, Choose one you like.

This ia a built-in plugin in SpaceVim, and we also separated a plugin : FlyGrep.vim

Features

Search in a project

In SpaceVim, you can use SPC s p or SPC s / to search in the current project.

Search in current file

You can use SPC s s to search in the current file. To search word under the cursor, you can press SPC s S.

Search in all loaded buffers

To searching in all loaded buffers, you need to press SPC s b, and you can also use SPC s B to search word under the point.

Search in an arbitrary directory

If you want to searching in a different directory instead of current directory, you canuse SPC s f. Then insert the path of the arbitrary directory.

Search in a project in the background

If you need background searching, you can press SPC s j, after searching is done, the index will be displayed on statusline. you can use SPC s l to list all the search results.

Key bindings

The search commands in SpaceVim are organized under the SPC s prefix with the next key is the tool to use and the last key is the scope. For instance SPC s a b will search in all opened buffers using ag.

If the last key (determining the scope) is uppercase then the current word under the cursor is used as default input for the search. For instance SPC s a B will search with word under cursor.

If the tool key is omitted then a default tool will be automatically selected for the search. This tool corresponds to the first tool found on the system of the list g:spacevim_search_tools, the default calling sequence is rg, ag, pt, ack then grep. For instance SPC s b will search in the opened buffers using pt if rg and ag have not been found on the system.

The tool keys are:

Tool	Key
ag	a
grep	g
ack	k
rg	r
pt	t

The available scopes and corresponding keys are:

Scope	Key
opened buffers	b
files in a given directory	f
current project	p

Within FlyGrep buffer:

Key Binding	Description
`<Esc>`	close FlyGrep buffer
`<Enter>`	open file at the cursor line
`<Tab>`	move cursor line down
`<C-j>`	move cursor line down
`<S-Tab>`	move cursor line up
`<C-k>`	move cursor line up
`<Bs>`	remove last character
`<C-w>`	remove the word before the cursor
`<C-u>`	remove the line before the cursor
`<C-k>`	remove the line after the cursor
`<C-a>`/`<Home>`	Go to the beginning of the line
`<C-e>`/`<End>`	Go to the end of the line