Editor and language tooling

What this accomplishes

The Miton code editor — syntax highlighting, language servers, symbols, find-and-replace, and file watching.

The Code editor is built on CodeMirror 6 with language-server support, symbol outline, find-and-replace, and automatic reload when files change on disk.

This page is the editor and the language tooling. The file tree, the chat panel, the outline panel, the milestone panel, and the agent dashboard are separate panels in the Code; they are documented on the overview.

Current availability

This page documents behaviour verified in Miton development builds. Miton is still pre-release and is not publicly downloadable; invited beta users will receive a signed desktop build with automatic updates.

Before you start

• A Miton development build and an active project containing source code.
• A connected model. Trust the project before allowing file, terminal or Git actions.

The editor surface

The editor is a CodeMirror 6 instance with the Miton extensions loaded. The editor supports:

• Syntax highlighting for TypeScript, JavaScript, Python, Rust, Go, Markdown, JSON, TOML, YAML, SQL, HTML, CSS, and a dozen other languages.
• Bracket matching for every supported language.
• Auto-indent following the language’s convention (TypeScript and JavaScript: 2 spaces; Python: 4 spaces; Rust: 4 spaces; Go: tabs).
• Code folding for functions, classes, and blocks.
• Multiple cursors (Cmd+D selects the next occurrence of the selection; Cmd+Shift+L selects all occurrences).
• Find and replace in the current file (Cmd+F) and across the project (Cmd+Shift+F).
• Symbol navigation by name (the symbol search panel, opened with Cmd+Shift+O).
• File navigation by name (the file picker, opened with Cmd+P).
• Inline lint annotations for the language-server diagnostics.

The editor settings live in Settings under “Editor”. The user can configure the font, the font size, the line height, the tab size, the auto-indent behaviour, the word wrap, and the lint annotation visibility.

The language-server integration

The editor integrates with language servers via the Language Server Protocol (LSP). The integration is in packages/argus-lsp/; the user-facing surface is the inline diagnostics and completions in the editor.

The editor ships with built-in support for the following languages when the language server is on PATH:

• TypeScript and JavaScript — typescript-language-server.
• Python — pyright.
• Rust — rust-analyzer.
• Go — gopls.
• Markdown — no LSP needed; the editor handles Markdown natively.

The editor also has a fallback symbol extractor (regex-based) for TypeScript, Python, Rust, Go, and Markdown. The fallback is enabled by default and provides symbol outline, go-to-definition, and find- references even when the language server is not available. The fallback’s accuracy is lower than the language server’s; the editor surfaces this in the status bar.

The user can install the language servers via the project’s package manager (npm install, pip install, cargo install) or via the system’s package manager. The editor detects the language servers on PATH and enables the LSP integration automatically.

The LSP integration is configurable per workspace. The user can disable the LSP integration, configure the language-server binary path, configure the LSP arguments, and configure the LSP timeout. The configuration is in Settings under “Editor → Language servers”.

The symbol outline

The symbol outline is a side panel in the editor that shows the symbols in the current file, grouped into Exported and Local sections, with kind icons (functions, classes, methods, variables, types). The outline updates as the user types. The outline is clickable; clicking a symbol jumps the editor to the symbol’s location.

The outline is a CoW panel — the user can close the outline without losing the navigation. The user can reopen the outline with Cmd+3 or from the panel menu.

The outline is powered by the language server when the language server is available, and by the fallback symbol extractor otherwise. The outline’s accuracy depends on the source.

The find and replace

The find and replace in the current file is Cmd+F. The find and replace across the project is Cmd+Shift+F. The find panel is a CoW panel that shows the matches in the current file (or the project, for the cross-file variant) with the file path, the line number, and the matched line. The user can navigate the matches with Enter (next) and Shift+Enter (previous).

The find panel supports:

• Plain text search — the simplest mode.
• Regex search — toggle with the regex button.
• Case-sensitive search — toggle with the case button.
• Whole-word search — toggle with the word button.
• Replace — single replace with the replace button; replace all with the replace-all button.
• File filter — the cross-file variant supports a file glob filter (e.g. *.ts to limit to TypeScript files).

The find panel is in the bottom of the editor; the user can move the panel to the side via the panel settings.

The file watcher

The file watcher is a real-time file-system monitor that updates the editor when files change on disk. The file watcher is implemented in the Tauri backend; the user-facing surface is the automatic refresh of the file tree, the symbol outline, the code search index, and the open editor buffers.

The file watcher is debounced — a burst of file changes within a short window is collapsed into a single update. The debounce window is configurable in Settings under “Editor → File watcher” (default 250ms).

The file watcher respects the user’s .gitignore file by default. The user can configure additional ignore patterns in Settings under “Editor → File watcher → Ignore patterns”.

What the user can configure

Editor settings include:

• Font — the font family, the font size, the line height, the letter spacing.
• Tab — the tab size, the soft-tab / hard-tab toggle, the auto-indent behaviour.
• Word wrap — the wrap mode (off, soft, hard).
• File watcher — debounce window, ignore patterns.
• Language servers — per-language server binary path, arguments, timeout.
• Find and replace — default case sensitivity, default regex.

Each setting is per workspace; the user can configure the setting globally in Settings, or per project in the project’s settings file (.miton/settings.json).

What the editor does not cover

The editor does not cover the IDE-shaped features that require a separate runtime:

• Debug adapter integration — the editor does not have a built-in debug adapter. Use the shell tool for process-level debugging or a dedicated debugger when a graphical debug UI is required.
• Integrated test runner UI — the editor does not have a built-in test runner UI. The user can use the Test Runner sub-agent to run the project’s tests in the background; the user can also use the shell tool to run the test command directly.
• Refactoring tools — the editor does not have built-in refactoring tools (rename symbol, extract function, inline variable). The user can ask the agent to perform the refactoring; the agent applies the refactoring with the appropriate tool calls.

The editor focuses on the IDE-shaped features that the user can implement with the existing primitives (CodeMirror 6 + LSP). The features that require additional runtime are documented above; the user can extend the editor with plugins (the plugin model is in Skills and commands).

What success looks like

The editor is a CodeMirror 6 instance with the Miton extensions. The user gets the standard editor features (syntax highlighting, bracket matching, auto-indent, code folding, multiple cursors, find and replace) plus the language-server integration when the language server is on PATH.

The symbol outline is the most useful IDE-shaped feature. The outline updates as the user types; the user can click a symbol to jump to it. The outline is powered by the language server when available, and by the fallback symbol extractor otherwise.

The file watcher is real-time. The user does not have to refresh the file tree or the symbol outline when a file changes on disk; the file watcher updates the view automatically.

Common failures and recovery

• Confirm the correct project and branch are active.
• Check the model connection and the permission request shown in Chat.
• Keep the exact error before retrying; use Code troubleshooting when the failure persists.

Related next action

Open Code troubleshooting for recovery steps and diagnostic paths.