Lutra/docs/target-app-parity.md
danny 468b9928a7
Some checks are pending
ci / ci (macos-15) (push) Waiting to run
ci / ci (ubuntu-24.04) (push) Waiting to run
ci / ci (windows-2025) (push) Waiting to run
PM: merge M4.4 git gutter markers and status colours
Depth headline inputs updated for H3 (Inspections 5%) and H4 (Settings 8%):
570/101, still ~5.6%.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 17:23:07 +01:00

39 KiB
Raw Blame History

Target-app parity

Status: M1 done (text buffer, VFS, engine workspace, project tree, tabs and a plain-text editor, recovery, palette, settings and themes in the app); M2 started: PHP syntax highlighting, find in files with its tool window, the symbol index and the go-to popup, the Structure tool window; M3 started: the integrated terminal, go to definition, find references and rename through Phpactor; M4 started: Git backend (M4.1), Changes tool window (M4.2) · Last updated: 2026-10-25 · Target: PhpStorm 2026.x

How this is measured

Each feature area gets a weight (how much a typical PHP developer uses it) and a score (how much of the documented behaviour Lutra has, judged by behaviour, not by menu items). The headline depth is the weighted sum. Every score is marked measured or estimated and must point to evidence (tests, commands, screenshots of Lutra). Behaviour references come from public PhpStorm documentation only, noted with URLs in plan/phpstorm/.

Hours are the estimated agent wall-clock hours for one agent to reach behaviour parity in the area, from zero. They are first estimates made at the end of M0 and are recalibrated after each milestone from merged-commit timestamps.

Breadth inventory (2026-10-18). Breadth is counted against the public PhpStorm help table of contents (https://www.jetbrains.com/help/phpstorm/HelpTOC.json): 155 level-1 feature units across 20 sections, without getting-started, reference, tutorial, troubleshooting and FAQ pages. A unit counts when Lutra has at least partial behaviour for it. Now 32/155 (~21%, estimated): the 23 units of 2026-10-18 plus 9 from C4 (completion, diagnostics, rename, hover and signature help, PHP interpreter, terminal, CLI, MCP server, main menu). Sections with no support yet: version control, debugging, run configurations, testing and profiling, code quality tools, frameworks (Laravel, Symfony, WordPress, others), deployment, database tools, HTTP client, SSH/Docker/WSL, remote development, Dev Containers, AI. Only titles and URLs are used; behaviour is read from each public page when the feature is planned.

Feature areas

Area Weight Score Missing Hours (one agent) Evidence
Editor core 12 11% (est.) semantic highlighting and a colour scheme editor, code folding, soft wrap and other editor settings, preview tab, pinned/split/reordered tabs, close others/all, reopen closed tab, tab limit, conflict UI for files changed on disk, save before run/commit (no such features yet; they will call flushDirty), local history, encodings other than UTF-8, large-file mode, column selection and multi-caret checked against the docs; recovery journal not yet checked in the running app (gaming mode) ~100 (est.) M3.10: autosave (ui/src/stores/autosave.ts): changed files are saved on window blur / hidden page, on a tab switch and after editor.autosave.idleSeconds (default 15) without an edit; three settings in Settings › Editor, all on by default. flushDirty() is the one "save all dirty and wait" entry point (waits for pending buffer sync, then file.saveAll {skipConflicts: true}), for deployment, run configurations and terminal commands later. Files changed or deleted on disk while dirty are skipped, our own save reported late is not a conflict (hash of the last read/written content); one toast per failed file, not repeated by autosave. Tests: engine (crates/engine/tests/workspace.rs: skip conflict, removed file not recreated, typing right after a save; settings validation), Vitest with fake timers (ui/tests/editor/autosave.test.ts, 11 tests: idle, idle setting/0, blur, hidden page, tab switch, settings off, pending-sync wait, skipped conflicts, toasts, command failure, serialised flushes). Checked in the app on Windows 11 (bundled UI, --control 7940, edits via buffer.edit, measured): not saved 10 s after an edit, saved at 15.0 s; edit then switching tabs a→b and b→a saved in ≤ 0.1 s; edit, then another app took focus: saved in 0.75 s; no buffer dirty afterwards. Graded against plan/phpstorm/15-autosave.md. M2.2: syntax highlighting by file extension (ui/src/components/editor/language.ts): PHP with embedded HTML/CSS/JS through @codemirror/lang-php (Lezer), plus HTML, CSS, JS/TS, JSON, YAML, Markdown; spans carry lt-syntax-* classes coloured only by the eleven --lt-syntax-* tokens of both themes (Lutra's own palette, ≥ 4.5:1 on the editor background and active line, contrast test). editor.reveal {path, line, column} opens, activates, places the cursor (UTF-16 column, CRLF-safe) and centres it; agents reach it as a UI command. Checked in the app on Windows 11 (bundled UI, control channel): PHP with embedded HTML in dark and light, editor.reveal into a closed CRLF file (last line, then line 302 centred). Vitest: language per extension, classes on spans for PHP/HTML and the other languages, reveal on open and closed files, CRLF mapping, clamping, bad params. keystroke to highlight on a 1 MB PHP file 3.0–11.4 ms median (jsdom, JavaScript work only, measured, not yet in the WebView). M2.1: crates/syntax parses PHP with tree-sitter (incremental reparse from lutra_text edits) and computes folding ranges (brace blocks, arrays, comments, heredocs, use runs); library only, nothing visible in the editor yet, so the score is unchanged. Tests: outline/folding snapshots for five PHP 8.3 fixtures, proptests (random bytes and token soups never panic, reparse equals a fresh parse, undo round trip). 1 MB parse 364–553 ms, reparse after one keystroke 7–11 ms (release, measured, machine busy). M1.13: opening a file that is already open switches to its tab (bufferFocused; engine test, Vitest, control-channel test; live check pending (gaming mode)); files in folders the tree never expanded still reload or report changes on disk, because the parent directory of every open buffer stays watched (engine tests). M1.7: crash-recovery journal (crates/engine/src/journal.rs, cmd/recovery.rs): dirty buffers are written atomically to <data_dir>/recovery/<project-id>/ about 1 s after the last edit (at least every 2 s while typing), never per keystroke; removed on save, close and discard; recoveryAvailable after project.open, recovery.list/restore/discard; restored buffers are dirty and keep line ending and BOM; corrupt entries are moved aside with a warning. Restore dialog (ui/src/components/recovery/: Restore all / selected / Discard, time, changed-on-disk hint). Tests: engine dropped mid-edit and a new engine restores the exact CRLF + BOM text, corrupt entries, removal paths, a property test of random edit sequences → crash → restore equals the buffer (crates/engine/tests/recovery.rs, 10 tests), the same flow headless over the control channel (crates/control/tests/recovery.rs), 10 Vitest tests for the dialog. 1 MiB entry write: 8.5 ms median (release, measured). Graded against plan/phpstorm/04-recovery.md. M1.6: tabs and a CodeMirror 6 editor in the app (ui/src/components/editor/, ui/src/stores/editor.ts): open from the project tree or engine events, activate, close by button, middle click or Mod+W, dirty dot, Save / Don't Save / Cancel on closing a dirty tab, Mod+S / Mod+Alt+S from engine command specs, non-blocking notice for a dirty file changed or deleted on disk; local edits go to buffer.edit with version-based resync, CRLF files keep \r\n; undo/redo, multiple selections, search and bracket matching from CodeMirror's basic setup. Vitest: a burst of 400 keystrokes with stale versions and remote edits loses none, a CRLF burst with deletions converges, store and component tests against a fake engine (ui/tests/editor/, 22 tests). Checked in the app on Windows 11 with --control and ui.screenshot: typing via the UI and via buffer.edit, save to disk, close question, middle click, disk-change notice. 1 MB file (16,385 lines): engine file.open 80 ms over the control channel (debug build, measured), editor state 1–6 ms and first rendered view 4–11 ms in Chromium (measured), ≈ 90 ms in total (estimated, budget 150 ms). Graded against plan/phpstorm/03-editor-tabs.md. crates/text: rope buffer, positions, edits (M1.1, unit tests + proptests). M1.3: engine buffers with versions and dirty state, file.open, buffer.get, buffer.edit (UTF-16 change sets, stale_version), file.save, file.saveAll, buffer.close with unsaved-changes guard, line ending and BOM kept on save, clean buffers reload on external change; 14 integration tests on temp dirs (crates/engine/tests/workspace.rs)
Project view, VFS 6 8% (est.) views list (project / scopes), toolbar (Select Opened File, Expand/Collapse All), sort and display options, show/hide excluded, distinct icons for library and excluded folders, file colours, speed search, preview, file operations ~37 (est.) lutra-vfs (M1.2): lazy sorted listing, ignore rules (.gitignore, .ignore, info/exclude, global excludes, Lutra defaults), native file watching via notify with a polling fallback, capped UTF-8 reads, atomic writes; 34 tests on temp dirs, watcher tests run on both backends (crates/vfs/tests). M1.5: project tree UI (lazy listing, keyboard navigation, dimmed ignored entries, event refresh) in ui/src/components/project/, Vitest against a mocked engine. M1.3: project.open, project.close, project.children (watches listed directories, capped at 256 native / 32 polling, least recently listed dropped), treeChanged events from disk, events.subscribe on the control channel with a TCP test (crates/control/tests/events.rs). M1.4: the tree runs against the engine in the app: folder picker (project.openDialog) and lutra-desktop --control PORT PATH open a project, the tree lists it lazily with ignored (var/ from .gitignore) and excluded (node_modules) entries dimmed, a file created on disk appears in an expanded folder within ~100 ms; verified with ui.screenshot on Windows 11 and Vitest (ui/tests/project/, ui/tests/ipcEvents.test.ts). M1.13: a directory listed only partly (more than 100,000 entries) ends with a "Listing truncated" note row (Vitest). M1.12: a folder that cannot be opened from the picker or the command line (including unsaved_changes when switching projects) and stopped file watching show as toasts instead of stderr (apps/lutra-desktop/src/host.rs, ui/src/stores/notifications.ts, ui/tests/notifications/, 19 Vitest tests; live check pending, gaming mode); score unchanged. Graded against plan/phpstorm/02-project-view.md: tool window, folder-first tree, dimmed ignored/excluded, keyboard navigation and live refresh exist; most toolbar, view and display options do not
Navigation 10 13% (est.) go to declaration: type declaration, implementations, the hover link underline; find usages: popup variant, usages highlighted in the file, scopes, grouping options, read/write access; go-to: recent files on an empty query, a non-project toggle (library items always show), file-type filter, :line suffixes, actions and text tabs, sending the list to Find; recent files and locations, navigation history, File Structure popup, Structure speed search, sorting and filters (visibility, inherited members), autoscroll from the caret, navigation bar, bookmarks (M1.8: a command palette over commands only) ~96 (est.) M3.5: Go to Definition (lsp.definition, F12 or Mod+click with a pointer cursor while Mod is held) through Phpactor: one location revealed, several in a picker (one modal at a time), none as a toast; Find References (lsp.references, Shift+F12) in a References tab of the bottom panel, grouped by file with the line preview and the name marked, click or Enter reveals. Requests wait off the engine lock (pending outcomes) and see every edit sent before them. Live against Phpactor 2026.06.25.0 on Windows (port 7935, three-file temp project, debug build, tick on): class definition across files 93 ms cold, 7–18 ms warm; references (4 uses in 3 files, incl. a CRLF file) ~140 ms (measured). Tests: crates/engine/tests/lsp_nav.rs (fake server with scripted answers; an ignored real-Phpactor test), Vitest ui/tests/nav/. The F12 and F2 keys were not pressed in the live app (no key input without stealing the owner's focus); the key and click paths are covered by Vitest. M2.6: go-to popup ui/src/components/goto/ with Files / Classes / Symbols tabs (Tab and Shift+Tab or a click switch, the text stays), UI commands goto.fileOpen Mod+P, goto.classOpen Mod+Alt+C, goto.symbolOpen Mod+T (optional {query} for agents), live query against goto.* (60 ms debounce, stale answers dropped), matched characters marked, directory / namespace / container column, library rows dimmed and labelled (goto.file items now carry library), an indexing hint with progress and a re-query on indexReady, Enter or a click opens through editor.reveal, Escape closes, one modal at a time; Vitest ui/tests/goto/, live-checked in the app (port 7826). M2.7: Structure tool window (ui/src/components/structure/) in a new left stripe with Project
Search and replace 6 8% (est.) find in the current file, replace in files and in a file, scopes (module, directory, open files, custom), comment/string filters, search history, a tab per search, grouping options, merging matches on one line, find in path from the tree, structural search ~70 (est.) M2.4 Find tool window in a new resizable, collapsible bottom panel: query with case / whole word / regex toggles, include and exclude globs, streamed results grouped by file (sorted) with the match highlighted in the line preview, counts and elapsed time, cancel, a truncated hint, a refused regex or glob shown in place; Enter or click opens the match through editor.reveal, arrow keys / Page / Home / End walk the results; find.open (Mod+Alt+F, Lutra's own) prefills the selection or the word at the cursor, find.open {query} from an agent searches at once; a new search cancels the running one. Tests: 26 Vitest store and component tests (ui/tests/find/FindToolWindow.test.ts). Live check (bundled-ui debug build, control port 7824, 3-file temp project): find.open {query} over uiCommand showed 14 matches in 3 files (vendor included) grouped and highlighted in 17 ms; with *.php include 2 matches; revealing a result's position opened the file at the match; find.open without params prefilled the word at the cursor; a bad regex showed the engine's message in place (screenshots read, measured). Opening a result by mouse or Enter is covered by Vitest only (the control channel cannot click). M2.3 backend: crates/search (parallel ignore walk + grep-searcher: literal/regex, case, whole word, include/exclude globs, project ignore rules with vendor/ searched and node_modules skipped, binary and > 8 MiB files skipped, match cap, cancel) and engine search.find / search.cancel with searchResults / searchDone events through the pump; dirty buffers are searched in their buffer text. Tests: 9 library tests incl. a property test of random queries and file bytes (crates/search/tests/search.rs), 3 preview/column unit tests, 4 engine tests (crates/engine/tests/search.rs), a TCP control-channel test (find → results → done, invalid regex, cancel; crates/control/tests/search.rs). 20k-file generated tree, release: first result 10–43 ms, full walk 0.66–1.43 s (measured); live over the control channel against the running app: first result 55 ms, done 386 ms on a 5,900-file project (debug build, measured)
Code completion 10 5% (est.) type-matching and second-invocation completion, postfix completion, live templates, path completion, ranking options and the replace-on-accept variant, accept characters, auto-insert of a single suggestion, auto-import checked against the real Phpactor (applied when the server sends it; tested with the fake server only), completion settings beyond H4's auto popup and delays (case sensitivity, sorting), parameter info settings, a documentation tool window, type info ~238 (est.) H3: Phpactor indexes ~3× faster on Windows (a 1 ms tick while it reports progress and in a session's first 120 s): the first useful completion on a 2,000-class project after 20.7–26.9 s instead of 71.6 s (measured, debug build); its indexing progress shows in the status bar; editor.completion.delayMs stays 0 (Phpactor CPU per request and a request-count model measured; 100 ms only delays the list). M3.4: completion, hover and signature help from Phpactor. Engine lsp.completion {id, position, triggerCharacter?} (items with label, kind, detail, Markdown documentation, insertText, textEdit, additionalTextEdits, sortText; at most 500, sorted by sortText, incomplete when cut or when the server says so; snippets turned into plain text), lsp.hover (Markdown, range) and lsp.signatureHelp (UTF-16 parameter spans), sent off the engine lock through M3.5's pending outcomes (crates/engine/src/cmd/lsp_assist.rs). Editor (ui/src/components/editor/assist/): a CodeMirror completion source with Lutra's own triggers (identifiers, $, ->, ?->, ::, namespace \; not in strings or comments unless asked), the server's ranking as boost, local filtering for complete lists, text edits and imports applied in UTF-16 (CRLF files too), Lucide kind icons; hover documentation after 350 ms and on demand (editor.quickDocumentation Mod+I); signature help on ( and , that follows the cursor (editor.parameterInfo); editor.complete; Markdown rendered by Lutra's own renderer without any HTML (XSS-tested). Tests: 6 engine tests against the fake server, 9 unit tests, 29 Vitest tests, an ignored test against the real PHAR. Measured with the real Phpactor on Windows 11 (debug build, 25 ms tick): completion while typing 61–109 ms (median 76 ms; ~107 ms through the control channel in the app), hover 4–91 ms (median 15–16 ms), signature help 4–28 ms (median 16 ms); a useful list 2.3 s after opening a file of a 20-class project and 65 s for 2,000 classes (Phpactor indexes first and answers with an empty incomplete list until then). Checked in the app (port 7934): completion after ->, quick documentation of a class, parameter info with the active parameter, screenshots read. Graded against plan/phpstorm/12-completion.md: the depth comes from Phpactor (members, classes, variables, keywords; detail and documentation often missing), Lutra has no type inference of its own
Inspections and quick-fixes 8 5% (est.) Lutra's own inspections and their settings, severities per inspection, quick-fixes (LSP code actions), suppression, inspection profiles, running inspections on a scope, the editor's problem counter and scrollbar marks, next/previous problem, a current-file Problems view and severity filters, external tools (PHPStan, Psalm, PHP_CodeSniffer) ~287 (est.) H3: PHP syntax errors on Windows from Lutra's own php -l (on open and save, off the engine lock, killed with Lutra), merged into the editor underlines and the Problems tab with source php -l; the language server's messages as notifications and its log as lsp.log. Tests: crates/engine/tests/lsp_ux.rs, unit tests incl. a parser proptest. M3.3: diagnostics from Phpactor (worse reflection: missing members, unknown classes, …) as wavy underlines, gutter markers and hover messages in the editor (ui/src/components/editor/lint.ts, tokens only), and a Problems tab in the bottom panel grouped by file with click to reveal (ui/src/components/problems/, problems.open Mod+Alt+P); engine diagnosticsChanged, diagnostics.list, lspStatus (crates/engine/src/lsp/). Tests: 10 engine tests against a fake server incl. a sync proptest, a TCP test, 16 Vitest tests, an ignored test against the real PHAR. Checked in the app on Windows 11 with the real Phpactor (port 7933): five errors underlined and listed; first diagnostics 2.7 s after file.open, 2.7–2.9 s after an edit (debug build, measured, incl. Phpactor's 1 s debounce). Graded against plan/phpstorm/11-problems.md: the depth comes from Phpactor, Lutra has no inspections of its own
Refactoring 7 3% (est.) rename: preview of all changes, comments/strings and text occurrences, scope, renaming files with classes, one undo across files (closed files written on disk are not undone by the editor); extract variable/method/constant, inline, move, change signature, safe delete, pull up/push down, introduce parameter ~244 (est.) M3.5: Rename (lsp.prepareRename then lsp.rename, F2) through Phpactor with an inline field over the symbol that shows how many uses in how many files change. The workspace edit is checked completely first (inside the project, ranges fit, open buffers unchanged since the request, no file operations); then closed files are written atomically through the VFS (written ones restored if a later write fails), open buffers change through buffer.edit (dirty, one undo step each in the editor), Phpactor reindexes the written files (sent as didOpen/didSave/didClose; its index followed in 140 ms, measured) and a summary notification follows. Live: renaming a method used in 3 files took 28 ms (open buffer + 2 closed files, CRLF kept). Tests: crates/engine/tests/lsp_nav.rs (multi-file rename incl. a closed CRLF file, an edit outside the project refused, a bad range refused, a buffer edited meanwhile refused; ignored real-Phpactor rename and rename back), Vitest ui/tests/nav/.
Code style and formatting 4 0% everything ~120 (est.) —
Git 8 6% (est.) Changes window: chunk and line staging, changelists, recent messages and a message template, pre-commit checks, skipping hooks, commit-and-push, a tree view and grouping, a context menu (rollback, delete, ignore); gutter markers: actions (show the old text, revert or stage a chunk, next/previous change), markers against HEAD; directory status colours; diff viewer, branch widget (C5 wave 3); log, blame, conflicts, stash, remotes (C6); ignored files in the status ~136 (est.) M4.2: Changes tab in the bottom panel (ui/src/components/vcs/changes/): Staged / Changes / Untracked groups from git.status (re-read on gitChanged), stage and unstage per file and per group with checkboxes (a staged rename passes both paths), keyboard navigation with Space to stage, double-click or Enter opens through vcs.showDiff when the diff viewer provides it, else the file; a commit message box with Amend and Commit (also Mod+Enter), which runs flushDirty() first, cancels when a save fails and toasts the short hash; hints for a missing git and a folder without a repository; vcs.openChanges Mod+Alt+Shift+G, vcs.commit Mod+Alt+Shift+M, vcs.refresh. Tests: 19 Vitest tests (ui/tests/vcs/ChangesToolWindow.test.ts). M4.4: change markers in the editor gutter (added, modified, deleted against the index, 150 ms after typing and on every gitChanged, CRLF-safe) through git.lineChanges (line diff in Rust off the lock, index text cached and dropped on gitChanged); file names in the project tree and the editor tabs coloured by Git status (--lt-vcs-*), ignored entries in the ignored colour inside a repository. Tests: crates/engine/tests/git_lines.rs (real temp repositories), unit and property tests, Vitest (ui/tests/editor/gitGutter.test.ts, ui/tests/vcs/vcsStatus.test.ts). M4.1 (backend, reachable through the palette, control channel and MCP): git.status, git.stage, git.unstage (also before the first commit), git.commit {message, amend} with hooks, git.show at HEAD or the index, git.branches, git.checkout (remote → tracking branch), git.createBranch; gitChanged after changes and from a .git poll plus the project watcher. Runs the installed git ≥ 2.30 (git.executable), porcelain v2 / -z only, no prompts, timeouts and caps, off the engine lock. Tests against real temp repositories (crates/vcs/tests/repo.rs, crates/engine/tests/git.rs). Graded against plan/phpstorm/16-vcs-basics.md: committing and staging work from the UI, and changed lines and files are marked (read-only markers, no chunk actions); diff, branches, log, blame and remotes do not yet.
Terminal 3 15% (est.) renaming and splitting tabs, sessions kept across restarts, search in the output, clickable paths and links, drag and drop, command completion, terminal settings (shell path, start directory, environment, font, cursor shape, bell, copy on selection, middle-click paste), a key back to the editor, the PHP interpreter in PATH, a terminal in a file's directory, confirmation before killing a running process, moving a terminal into the editor ~26 (est.) M3.6: crates/terminal runs the shell in a pseudo terminal (portable-pty: ConPTY on Windows, Unix pty elsewhere) on its own reader, writer and waiter threads: UTF-8 split across reads joined, invalid bytes U+FFFD, a 1 MiB output buffer per session with backpressure (the shell waits, nothing is dropped while it runs), a non-blocking input queue, resize, kill, exit codes. Engine terminal.create {cwd?, shell?, cols, rows} / terminal.input / terminal.resize / terminal.close, events terminalOutput (≤ 64 KiB per terminal and 256 KiB per pump, round-robin) and terminalExited {code}; terminals close with the project and on app.quit. UI: a Terminal tab in the bottom panel (tabs next to Find), xterm.js with the fit addon, several terminals as sub-tabs (Local, Local (2)…) with close and new buttons, output replayed after collapsing the panel, copy (Mod+Shift+C, Ctrl+C with a selection) and paste (Mod+Shift+V, Ctrl+V), a focus rule that leaves plain Ctrl keys to the shell, Lutra's own ANSI colours (--lt-terminal-*, all text colours ≥ 4.5:1), terminal.open Mod+Shift+T. Tests: 8 session tests with real cmd.exe (echo, exit code, input, 6,000 multibyte characters without U+FFFD, 30,000 lines through a full buffer without losing a line, resize, kill, spawn errors) and UTF-8 proptests (crates/terminal), 3 engine tests (crates/engine/tests/terminal.rs), a TCP control test create → output → input → exit (crates/control/tests/terminal.rs), 20 Vitest tests with a mocked xterm (ui/tests/terminal/). Live check (Windows 11, debug build with bundled UI, control port 7936, temp project): terminal.open showed a pwsh prompt in the project root, first terminalOutput 0.2–0.5 s after the command; php -v printed PHP 8.4.24 within 0.5–1.5 s; dir listed the project; resizing the window changed the shell's width 144 → 190 → 105 → 142 columns (pwsh WindowSize); a second terminal as sub-tab "Local (2)"; Find and Terminal as bottom tabs; dark and light screenshots read; exit 3 gave terminalExited {code: 3}; app.quit ended the app and its shells (measured). The live check found two bugs, fixed before the commit: xterm's own black viewport background showed as a bar under the last row, and programs printing ANSI white (PSReadLine) were unreadable on the light theme, so xterm now enforces a 4.5:1 minimum contrast. Typing, clicking and copy/paste were not driven in the app (the control channel has no input method); Vitest covers them. Graded against plan/phpstorm/10-terminal.md
Run configurations 2 0% everything ~50 (est.) —
Debugger 5 0% everything ~120 (est.) —
Testing 4 0% everything ~80 (est.) —
Composer and interpreters 2 0% everything ~50 (est.) —
Frameworks 5 0% everything ~300 (est.) —
Database tools 3 0% everything ~250 (est.) —
HTTP client 1 0% everything ~60 (est.) —
Web languages 2 0% everything ~200 (est.) —
Docker and remote 1 0% everything ~120 (est.) —
Settings, keymaps, themes 1 8% (est.) nested settings tree, project-level settings, export/import, keymaps (M1.8: one global keymap from the commands' default shortcuts, not editable), colour scheme editor, custom and imported themes, per-language colours (M1.9a: settings backend with 3 keys, persistence, settings.* commands, no UI yet; M1.10: light and dark themes with live switching and a system mode; M1.9b: settings dialog with search, controls by type, reset, live updates, theme picker, editor font size) ~58 (est.) H5: both themes aligned to the README banner and approved by the owner from before/after screenshots (raspberry accent, cream-tinted light and faintly plum-tinted dark surfaces, retuned syntax colours); severity tokens --lt-diag-* for underlines, gutter, tooltips and Problems icons, --lt-vcs-* status tokens, completion icons coloured by kind; WCAG AA checked by ui/tests/theme/contrast.test.ts (score unchanged: no new setting or theme feature). H4: every setting the engine has is editable in the dialog: string settings get a text field with in-place hints (quotes or spaces around a path, control characters, length), path settings (php.executable, phpactor.path, any key ending in path/executable, so M4.1's git.executable too) a "Browse…" button through the dialog plugin's native picker (desktop IPC pick_file); three new settings editor.completion.autoPopup, editor.completion.delayMs (0–2000), editor.hover.delayMs (100–3000) applied live to open editors through CodeMirror compartments; settings.open {section?, query?}. Tests: engine settings::tests::assist_defaults_and_validation, control events.rs defaults, Vitest ui/tests/settings/StringSettings.test.ts (12) and ui/tests/editor/assist/settings.test.ts (6, fake timers). Checked in the app on Windows 11 (bundled UI, control port 7954, screenshots read); "Browse…" not clicked live (no synthetic input), covered by Vitest
Plug-ins 0.5 0% everything ~120 (est.) —
AI features 0.5 0% everything ~60 (est.) —

Sum: about 2,920 h. Adding UI fidelity (~150 h), localization (~40 h), performance (~100 h) and stability hardening (~100 h) gives the ROADMAP's ~3,300 h to full parity. These are the raw first estimates. Cycle C1 (M1.1–M1.6) took 2.5 h of agent time for 37 h estimated (factor 0.07), so the calibrated full-parity figure is ~330 h if that speed holds for deeper areas; the ROADMAP shows the range 300–3,300 h until M2/M3 give data for language work. The range is wide (2,000–5,000 h): completion, inspections, refactoring and frameworks depend on an own type-inference engine whose size is hard to judge before M6.

Weights were reviewed at the end of M0 and kept: nothing built so far gives a reason to change them.

What ships (M0, 2026-10-14)

No PHP feature. The foundation, verified on Windows 11:

  • cargo xtask ci passes all 13 steps (fmt, clippy with no-panic lints, tests, lints self-test, layers, assets, clean-room, cargo-deny licences, pnpm install, ESLint, vue-tsc, Vitest, frontend licences).
  • Commands app.about and app.quit with unit tests; a panicking command is caught by the guard (crates/engine/src/engine.rs tests).
  • Control channel: app.ping, engine.execute, engine.listCommands, ui.screenshot, with proptests and a TCP integration test (crates/control), and checked against the running app.
  • The desktop window opens themed from Rust tokens and shows the product name and version that the frontend gets from app.about over IPC.

What ships (M1, done 2026-10-16)

The project tree is the first user-visible feature (Project view 8%, estimated); every other score stays 0%.

  • M1.1 text buffer (crates/text): Buffer on a ropey rope with byte, char, UTF-16 and line counts; byte offset to line and column in UTF-16 code units or chars and back, all fallible (out of range, inside a character, inside a CRLF, inside a surrogate pair); atomic Edit batches in LSP TextEdit[] semantics that reject reversed, out-of-range and overlapping ranges; / / detection with a keep-the-file's-ending save policy. 23 unit tests and 6 proptests (round-trips on emoji, ZWJ sequences, CJK and combining marks; random edit batches checked against a String model, never panicking).
  • M1.10 themes (2026-10-16): Lutra Dark and Lutra Light with the same tokens, including real editor, tab and notice tokens; appearance.theme switches live without a reload, system follows the OS preference, and the window starts in the stored theme. Both themes pass a WCAG AA contrast test for every text/background pair in use. Checked by engine, control-channel and Vitest DOM tests; not yet looked at in the running app (gaming mode). No theme picker yet (settings dialog, M1.9b).
  • M1.9b settings dialog (2026-10-16): settings.open (Mod+,) opens a dialog built from settings.list with sections, a select/number/switch per type, catalog labels and descriptions, search over label, description, key and section, Reset to default, changes applied at once with inline errors and live updates on settingsChanged; the theme picker switches at once and editor.fontSize sizes the editor. Vitest: ui/tests/settings/SettingsDialog.test.ts (14). Live check pending (gaming mode).

Revision history

Date Change Summary
2026-10-25 minor M4.4: Git 4% → 6% (est.), gutter change markers and status colours; hours 138 → 136
2026-10-25 minor H3: Inspections and quick-fixes 4% → 5% (est.), php -l on Windows; Code completion evidence (indexing ~3× faster), score unchanged; hours 290 → 287 and 240 → 238
2026-10-25 minor M4.2: Git 1% → 4% (est.), Changes tool window; hours 148 → 138
2026-10-25 minor M4.1: Git 0% → 1% (est.), Git backend without UI; hours 150 → 148
2026-10-25 minor H5: Settings row evidence (banner-aligned themes, diagnostic and VCS tokens); score unchanged
2026-10-24 minor H4: Settings 7% → 8% (est.), string and path controls, completion and tooltip settings; hours 60 → 58
2026-10-22 minor C4 review: breadth recounted against the feature map, 32/155
2026-10-22 minor M3.5: Navigation 10% → 13% (est.), go to definition and find references; Refactoring 0% → 3% (est.), rename; hours 102 → 96 and 250 → 244
2026-10-22 minor M3.4: Code completion 0% → 5% (est.), completion, hover and signature help from Phpactor; hours 250 → 240; breadth 26/155
2026-10-21 minor M3.3: Inspections and quick-fixes 0% → 4% (est.), diagnostics from Phpactor and the Problems tab; hours 300 → 290
2026-10-20 minor M3.10: Editor core 10% → 11% (est.), autosave and flushDirty; hours 104 → 100
2026-10-18 minor M3.6: Terminal 0% → 15% (est.), integrated terminal with xterm.js sub-tabs
2026-10-18 minor Breadth inventory: 155 units from the public help, 23 partially supported
2026-10-17 minor M2.6: Navigation 4% → 10% (est.), go-to popup; hours 108 → 102
2026-10-17 minor M2.7: Navigation 0% → 4% (est.), Structure tool window; hours 112 → 108
2026-10-17 minor M2.5: Navigation evidence (symbol index and go-to commands, no UI), score unchanged at 0%, hours 120 → 112
2026-10-17 minor M2.4: Search and replace 0% → 8% (est.), Find tool window; hours 76 → 70
2026-10-16 minor M2.2: Editor core 9% → 10% (est.), syntax highlighting and editor.reveal
2026-10-16 minor M2.3: Search and replace evidence (find-in-files backend, no UI), score unchanged at 0%, hours 80 → 76
2026-10-16 minor M2.1: Editor core and Navigation evidence (tree-sitter parse, outline, folding library), scores unchanged
2026-10-16 minor M1.9b: Settings row 4% → 7% (est.), settings dialog; M1 done
2026-10-16 minor M1.8: Navigation and Settings/keymaps evidence (palette, global keymap), scores unchanged
2026-10-16 minor M1.12: Project view evidence (picker errors as toasts), scores unchanged
2026-10-16 minor M1.13: Editor core and Project view evidence (focus on re-open, watched buffer folders, truncated note), scores unchanged
2026-10-16 minor M1.7: Editor core 8% → 9% (est.), crash-recovery journal and restore dialog
2026-10-16 minor M1.10: Settings row 2% → 4% (est.), light/dark themes with live switching
2026-10-16 minor M1.9a: Settings row 0% → 2% (est.), settings backend without UI
2026-10-15 minor Calibration note after cycle C1 (factor 0.07)
2026-10-15 minor Editor core 0% → 8% (estimated): tabs and editor in the app (M1.6)
2026-10-15 minor Project view 0% → 8% (estimated): tree runs against the engine in the app (M1.4)
2026-10-14 minor Project view evidence: project tree UI (M1.5), score unchanged
2026-10-14 minor M1.3 engine workspace evidence (Editor core, Project view; scores unchanged)
2026-10-14 minor M1.1 text buffer evidence (Editor core, score unchanged)
2026-10-14 minor Project view evidence: native file watching (M1.2b), score unchanged
2026-10-14 minor Project view evidence: lutra-vfs (M1.2), score unchanged
2026-10-14 minor Hours per area, weights reviewed, M0 evidence
2026-10-13 major Baseline