AI assistant¶

An in-editor assistant that drives the AI command-line agent you already have installed — explain, refactor, fix, write tests, summarize, translate, and chat, with every proposed edit shown as a reviewable diff you apply on purpose.

Bring your own agent¶

The assistant does not ask you for an API key and does not sign you into anything. Instead it runs a locally installed AI CLI agent as a helper and streams its output into the editor. Authentication, your subscription, and model choice all belong to that tool.

Today: Claude Code (claude). Install it and log in once (so claude works from a terminal); the editor picks it up automatically. Codex and Gemini appear in the engine list but their command-line integration is not yet verified.
Detection is automatic and non-blocking. The editor probes for the agent in the background right after startup — the window never waits for it. While the probe runs, View → AI Chat is briefly disabled with a Detecting AI engine… tooltip; a few seconds later it either enables (agent found) or stays greyed out with a hint telling you what to install.

The agent is a separate program you install

The editor does not bundle or download any AI agent, and it does not send your text anywhere itself — the CLI agent you installed makes the request using its own account and network connection. If the agent isn't installed or logged in, the AI features simply stay disabled and nothing else in the editor is affected.

Requirements¶

The assistant has one hard requirement: a supported AI CLI agent installed and logged in on your system PATH.

Install a supported agent. Today that is Claude Code (claude).
Log in once. Run the agent from a terminal and complete its own sign-in, so it works headlessly afterwards. The editor never asks for or stores an API key — your subscription and login live entirely in that tool.
Make sure it's on your PATH. If the editor can't run it, View → AI Chat is greyed out with an explanatory tooltip.

The AI Chat panel¶

There is no top-level AI menu — everything lives in one bottom panel, toggled from View → AI Chat. If the panel was open when you last closed the editor, it reopens on the next start (once the engine is detected).

From top to bottom the panel shows:

an Engine dropdown (your choice is remembered between sessions) and the Allow file edits checkbox (see below);
a status line — the detected engine and version, a probe/progress note, or the "install and log in" hint;
a thin busy bar with a Stop button while the agent is working;
the console — the whole conversation in one view;
a hint line listing the available commands as clickable links.

The console¶

The conversation works like a terminal: history above, and you type at the end, after the › prompt.

Enter sends; Shift+Enter inserts a line break, so multi-line prompts work.
Clicking or typing anywhere in the history moves the caret back to the prompt — history is selectable and copyable but never editable.
Esc cancels the running request; when nothing is running it clears whatever you typed after ›. Esc works with focus anywhere in the panel.
The view auto-scrolls only while you are at the bottom; scroll up to read and it stays put.

Commands¶

Type a command at the prompt, or click it in the hint line (commands that take an argument get a trailing space and wait for you to finish the line):

Command	What it does	Result
`.explain`	Explain the selected code	answer in the chat
`.summarize`	Summarize the selected text	answer in the chat
`.refactor <how>`	Refactor as instructed (e.g. `.refactor extract a helper`)	reviewable edit
`.fix`	Fix the selected code	reviewable edit
`.tests`	Write unit tests for the selection	reviewable edit
`.translate <language>`	Translate the selection (e.g. `.translate German`)	reviewable edit

Anything else you type is handled naturally:

Plain text is a free-form question to the agent (the current selection is attached as optional context).
A line starting with / is forwarded to the agent verbatim — its own commands (like Claude's /help) keep working.
An unrecognised .word is not an error; it's sent through as a prompt.

Matching is case-insensitive, and the hint line narrows as you type (.r → .refactor …).

Selection or whole document¶

Commands work on the current selection. With no selection, they operate on the whole document — and because that sends the entire file to the agent, the editor asks first: Send whole document '…' to Claude? You are asked once per document per editor session; declining aborts the send and keeps what you typed. Free-form questions never pull in the whole file — a selection is only optional context there.

Reviewing and applying edits¶

Edit commands never rewrite your text silently. When the agent finishes, a review dialog opens with one checkable, colourised change group per modification — removed lines in red, added lines in green:

untick the changes you don't want;
Apply replaces the selection (or the whole document, for the no-selection case) with just the accepted changes;
Discard leaves the buffer exactly as it was.

Applied changes are ordinary edits, so Ctrl+Z undoes them like anything else. Your file's line-ending style (CRLF/LF) is preserved. If you kept editing while the agent was working and the text under the original selection changed, the editor refuses to apply and tells you to run the command again — it never splices a stale edit over your newer text. If the agent declines to make an edit, its explanation appears as a normal chat answer instead of a bogus diff.

The diff colours follow your colour theme: themes may define dedicated Diff added text / Diff removed text colours (editable in Preferences → Syntax Colouring → Themes), and without them the editor picks readable defaults for light and dark interfaces.

Conversations¶

Free-form questions form a continuing conversation: the agent remembers your previous questions and answers. There is one conversation per opened folder (or per file, when no folder is open), so unrelated projects don't share context. Edit commands (.refactor, .fix, …) intentionally run one-shot and don't pollute the chat context. Conversations are not persisted — restarting the editor starts fresh ones.

Stopping a run¶

While the agent works, a busy bar appears with a Stop button — click it (or press Esc anywhere in the panel) to cancel. The stream halts, the run is marked [Cancelled], and no edit is applied. Pressing Enter mid-run doesn't queue anything; the status line reminds you the agent is still working.

Letting the agent edit files¶

By default the assistant is read-only: every run launches the agent with its file-editing tools, shell access, and sub-agents disabled, so changes reach you only as reviewable proposals. For engines with verified permission flags (Claude) this is a hard block enforced by the agent itself, no matter how your CLI is configured.

Read-only is not guaranteed for every engine

The hard block relies on the engine's own permission flags. Engines without verified flags (Codex, Gemini) have no such switch, so the editor can only ask them — as a best-effort instruction — to stay read-only; it cannot force them. Treat read-only as not guaranteed for those engines: they may still write to disk, and their behaviour is ultimately governed by your CLI's own configuration. Keep such work in a version-controlled folder if that matters to you.

The Allow file edits checkbox (next to the engine dropdown, off by default, remembered between sessions) opts into agent-side editing:

the agent's file edits are auto-accepted and it may modify files in the opened folder during a run;
every write is reported in the conversation as [the agent modified a file: …], and open documents pick the changes up through the editor's normal file watching;
when the run ends, a single summary line lists the full set of touched files with a count, e.g. [modified files (3): …];
shell access and sub-agents stay blocked even with the option on.

Allow file edits can overwrite or delete your work

With the option enabled the agent writes to disk directly and those writes are auto-accepted — there is no per-change review dialog. The agent can overwrite, delete, or corrupt files in the opened folder, and edits to files you don't have open aren't shown to you as diffs. Only enable this for a folder under version control (Git, SVN, …): commit or stash your work first, then use the VCS diff to inspect every change and revert anything unwanted — treat version control as your undo for agent edits. Engines without verified permission flags (Codex, Gemini) ignore this option entirely, so their edits are governed solely by your CLI's own configuration.

Switching engines¶

Pick a different agent from the Engine dropdown at any time (it's disabled while a run is active). Switching cancels detection of the previous engine, probes the new one in the background, and starts fresh conversations — a chat begun with one engine can't be continued by another.

Privacy and cost¶

Requests are sent by the CLI agent you chose, using its own account and network connection — the editor adds no separate telemetry or endpoints. What is sent (your selection or document and your instruction) and what it costs are governed by that agent's subscription or plan.

What ships today

Commands work on the current selection (or whole document, with consent) and, when accepted, replace it. There are two authority levels: the read-only propose-only flow above, or the explicit Allow file edits opt-in. There is no separate in-editor review of the agent's own on-disk edits — with Allow file edits on, rely on your version control instead.