From 68599fa2ac1b14c713d4b5cc470c7139606cd1c6 Mon Sep 17 00:00:00 2001 From: danny Date: Sat, 31 Oct 2026 14:33:42 +0100 Subject: [PATCH] A3: add untracked files to .gitignore from the Changes context menu git.ignore appends one anchored, escaped literal pattern per path to the work tree root's .gitignore, skipping patterns already there. The Changes window gets a row context menu (right click, Shift+F10, context-menu key) with Open and Add to .gitignore. Co-Authored-By: Claude Opus 5.5 --- crates/engine/src/cmd/git_ignore.rs | 80 +++++++ crates/engine/src/cmd/mod.rs | 3 + crates/engine/tests/git_merge.rs | 33 ++- crates/vcs/src/ignore.rs | 115 ++++++++++ crates/vcs/src/lib.rs | 4 + crates/vcs/tests/ignore.rs | 86 ++++++++ docs/architecture.md | 2 + docs/target-app-parity.md | 3 +- docs/ui-parity.md | 3 +- .../vcs/changes/ChangesContextMenu.vue | 200 ++++++++++++++++++ .../vcs/changes/ChangesToolWindow.vue | 38 ++++ ui/src/components/vcs/changes/changes.ts | 38 +++- ui/src/i18n/en.json | 4 + ui/tests/vcs/ChangesToolWindow.test.ts | 29 +++ 14 files changed, 633 insertions(+), 5 deletions(-) create mode 100644 crates/engine/src/cmd/git_ignore.rs create mode 100644 crates/vcs/src/ignore.rs create mode 100644 crates/vcs/tests/ignore.rs create mode 100644 ui/src/components/vcs/changes/ChangesContextMenu.vue diff --git a/crates/engine/src/cmd/git_ignore.rs b/crates/engine/src/cmd/git_ignore.rs new file mode 100644 index 0000000..c52a21c --- /dev/null +++ b/crates/engine/src/cmd/git_ignore.rs @@ -0,0 +1,80 @@ +//! `git.ignore` (C7 A3): adds literal patterns for chosen files to the +//! work tree's `.gitignore`, on top of `lutra_vcs::Repo::ignore`. +//! +//! It runs through [`super::git::start_with`] like the other `git.*` +//! commands and sends `gitChanged` afterwards, since the status changes. + +use serde::Deserialize; +use serde_json::{Value, json}; + +use super::git::{rel_path, start_with}; +use super::params::parse; +use crate::{Command, CommandSpec, EngineError, Outcome, Registry, State}; + +/// Most paths one call takes. +const MAX_PATHS: usize = 10_000; + +/// Registers `git.ignore`. +/// +/// # Errors +/// [`EngineError::Internal`] if the id is taken. +pub fn register(registry: &mut Registry) -> Result<(), EngineError> { + registry.register(Box::new(Ignore)) +} + +/// Params of `git.ignore`. +#[derive(Debug, Deserialize)] +#[serde(deny_unknown_fields)] +struct IgnoreParams { + /// Project-relative or absolute paths inside the project. + paths: Vec, +} + +/// `git.ignore`. +struct Ignore; + +impl Command for Ignore { + fn spec(&self) -> &CommandSpec { + &CommandSpec { + id: "git.ignore", + label: "Git: Add to .gitignore", + menu_path: None, + default_shortcut: None, + params: "{ paths: [path inside the project] } (1 to 10000); appends one literal pattern per path to the .gitignore at the work tree's root (created when missing): anchored with /, with \\ * ? [ and trailing spaces escaped, so it matches exactly that file or folder; returns { patterns: [added pattern] }, leaving out patterns already in the file", + } + } + + fn enabled(&self, state: &State) -> bool { + state.has_project() + } + + fn run(&self, state: &mut State, params: Value) -> Result { + let command = self.spec().id; + let p: IgnoreParams = parse(command, params)?; + if p.paths.is_empty() || p.paths.len() > MAX_PATHS { + return Err(EngineError::invalid_params( + command, + format!("paths takes 1 to {MAX_PATHS} entries"), + )); + } + let paths = p + .paths + .iter() + .map(|path| rel_path(state, command, path)) + .collect::, _>>()?; + start_with( + state, + command, + true, + Box::new(move |repo| { + let patterns = repo.ignore(&paths)?; + Ok(json!({ "patterns": patterns })) + }), + ) + } +} + +/// The ids of the commands this module registers, checked against the +/// registry by the engine's listing test. Add a new command's id here. +#[cfg(test)] +pub(crate) const COMMAND_IDS: &[&str] = &["git.ignore"]; diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs index 8fc5c18..812b351 100644 --- a/crates/engine/src/cmd/mod.rs +++ b/crates/engine/src/cmd/mod.rs @@ -5,6 +5,7 @@ mod buffer; mod file; pub mod git; pub mod git_blame; +pub mod git_ignore; pub mod git_lines; pub mod git_log; pub mod git_merge; @@ -78,6 +79,7 @@ pub fn register_builtins(registry: &mut Registry) -> Result<(), EngineError> { git_remote::register(registry)?; git_merge::register(registry)?; git_stash::register(registry)?; + git_ignore::register(registry)?; Ok(()) } @@ -91,6 +93,7 @@ pub(crate) const BUILTIN_COMMAND_IDS: &[&[&str]] = &[ file::COMMAND_IDS, git::COMMAND_IDS, git_blame::COMMAND_IDS, + git_ignore::COMMAND_IDS, git_lines::COMMAND_IDS, git_log::COMMAND_IDS, git_merge::COMMAND_IDS, diff --git a/crates/engine/tests/git_merge.rs b/crates/engine/tests/git_merge.rs index b8e66c9..7f658c9 100644 --- a/crates/engine/tests/git_merge.rs +++ b/crates/engine/tests/git_merge.rs @@ -1,7 +1,7 @@ //! The merge commands through the engine with pending outcomes: //! `git.merge` up to date, with conflicts and refused; `git.conflictVersions`; //! `git.markResolved` and `git.mergeAbort`, each followed by `gitChanged`; -//! bad params. Skips with a message when git is not installed. +//! `git.mergeMessage`; `git.ignore` (C7 A3); bad params. Skips with a message when git is not installed. #![allow( clippy::unwrap_used, @@ -198,6 +198,8 @@ fn bad_params_and_no_project() { ("git.merge", json!({"branch": "-x"})), ("git.markResolved", json!({"paths": []})), ("git.conflictVersions", json!({"path": 3})), + ("git.ignore", json!({"paths": []})), + ("git.ignore", json!({"paths": ["../x"]})), ] { assert!( matches!( @@ -216,3 +218,32 @@ fn bad_params_and_no_project() { Err(EngineError::Disabled(_)) )); } + +#[test] +fn ignore_appends_a_literal_pattern_and_refreshes() { + if !have_git() { + return; + } + let dir = tempfile::tempdir().unwrap(); + let root = dir.path(); + conflicting(root); + std::fs::write(root.join("debug[1].log"), "x").unwrap(); + std::fs::write(root.join("debug1.log"), "x").unwrap(); + let host = Host::open(root); + host.git_changes(); + let out = host + .run("git.ignore", json!({"paths": ["debug[1].log"]})) + .unwrap(); + assert_eq!(out["patterns"].as_array().unwrap().len(), 1); + assert_eq!(host.git_changes(), 1); + let status = host.run("git.status", Value::Null).unwrap(); + let paths: Vec<&str> = status["files"] + .as_array() + .unwrap() + .iter() + .map(|f| f["path"].as_str().unwrap()) + .collect(); + assert!(paths.contains(&"debug1.log"), "{paths:?}"); + assert!(paths.contains(&".gitignore"), "{paths:?}"); + assert!(!paths.contains(&"debug[1].log"), "{paths:?}"); +} diff --git a/crates/vcs/src/ignore.rs b/crates/vcs/src/ignore.rs new file mode 100644 index 0000000..8a540c8 --- /dev/null +++ b/crates/vcs/src/ignore.rs @@ -0,0 +1,115 @@ +//! Ignoring files (C7 A3): appending literal patterns for chosen paths to +//! the `.gitignore` at the work tree's root. +//! +//! Each path becomes one pattern that matches exactly that path: anchored +//! with a leading `/`, and with the characters gitignore treats specially +//! (`\`, `*`, `?`, `[`, and trailing spaces) escaped with a backslash, so a +//! file named `a*.php` ignores only itself. Patterns already in the file +//! are not added again. + +use std::fs::OpenOptions; +use std::io::{ErrorKind, Write}; + +use crate::Repo; +use crate::VcsError; +use crate::repo::SMALL_CAP; + +/// The literal, root-anchored gitignore pattern of a root-relative path. +/// +/// # Parameters +/// - `path`: a root-relative path with `/` separators, as +/// [`Repo::to_repo_path`] returns it. +pub fn ignore_pattern(path: &str) -> String { + let kept = path.trim_end_matches(' '); + let trailing = path.len() - kept.len(); + let mut out = String::with_capacity(path.len() + 8); + out.push('/'); + for c in kept.chars() { + if matches!(c, '\\' | '*' | '?' | '[') { + out.push('\\'); + } + out.push(c); + } + for _ in 0..trailing { + out.push_str("\\ "); + } + out +} + +impl Repo { + /// Appends a literal pattern for each path to the root's `.gitignore` + /// (created when missing), on a line of its own. + /// + /// # Parameters + /// - `paths`: project-relative paths of files or folders. + /// + /// # Returns + /// The patterns added, in the order given; patterns already in the + /// file are left out. + /// + /// # Errors + /// [`VcsError::InvalidPath`] for a bad path (nothing is written); + /// [`VcsError::Git`] when `.gitignore` cannot be read or written, or is + /// larger than 16 MiB. + pub fn ignore(&self, paths: &[String]) -> Result, VcsError> { + let mut patterns = Vec::with_capacity(paths.len()); + for path in paths { + let pattern = ignore_pattern(&self.to_repo_path(path)?); + if pattern != "/" && !patterns.contains(&pattern) { + patterns.push(pattern); + } + } + if patterns.is_empty() { + return Ok(patterns); + } + let _guard = self.lock(); + let file = self.root().join(".gitignore"); + let failed = |e: std::io::Error| VcsError::Git(format!("cannot update .gitignore: {e}")); + let existing = match std::fs::read(&file) { + Ok(bytes) => bytes, + Err(e) if e.kind() == ErrorKind::NotFound => Vec::new(), + Err(e) => return Err(failed(e)), + }; + if existing.len() > SMALL_CAP { + return Err(VcsError::Git( + "cannot update .gitignore: the file is too large".into(), + )); + } + let text = String::from_utf8_lossy(&existing); + let present: Vec<&str> = text.lines().collect(); + patterns.retain(|p| !present.contains(&p.as_str())); + if patterns.is_empty() { + return Ok(patterns); + } + let mut out = String::new(); + if !existing.is_empty() && !existing.ends_with(b"\n") { + out.push('\n'); + } + for pattern in &patterns { + out.push_str(pattern); + out.push('\n'); + } + OpenOptions::new() + .create(true) + .append(true) + .open(&file) + .and_then(|mut f| f.write_all(out.as_bytes())) + .map_err(failed)?; + Ok(patterns) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn patterns_are_anchored_and_literal() { + assert_eq!(ignore_pattern("tmp.txt"), "/tmp.txt"); + assert_eq!(ignore_pattern("a/b c.php"), "/a/b c.php"); + assert_eq!(ignore_pattern("x*?[y].php"), "/x\\*\\?\\[y].php"); + assert_eq!(ignore_pattern("#note!"), "/#note!"); + assert_eq!(ignore_pattern("back\\slash"), "/back\\\\slash"); + assert_eq!(ignore_pattern("end "), "/end\\ \\ "); + } +} diff --git a/crates/vcs/src/lib.rs b/crates/vcs/src/lib.rs index d6fbe4a..7d5c18f 100644 --- a/crates/vcs/src/lib.rs +++ b/crates/vcs/src/lib.rs @@ -12,6 +12,8 @@ //! git's credential helper and the ssh agent (see `remote.rs`). //! - Blame (M4.7): who last changed each line, of the working copy or an //! editor buffer (`blame.rs`). +//! - Ignoring files (C7 A3): literal patterns appended to `.gitignore` +//! (`ignore.rs`). //! - [`RepoWatch`] notices changes inside `.git` (HEAD, index, refs). //! //! Every call goes through [`runner::run`]: arguments as an array, never a @@ -25,6 +27,7 @@ pub mod blame; mod error; +mod ignore; pub mod log; pub mod porcelain; mod remote; @@ -35,6 +38,7 @@ mod watch; pub use blame::{BlameLine, UNCOMMITTED_AUTHOR, is_uncommitted}; pub use error::VcsError; +pub use ignore::ignore_pattern; pub use log::{CommitDetails, CommitFile, LOG_LIMIT, LogCommit, LogQuery}; pub use porcelain::{FileState, FileStatus, Head, Status, Version}; pub use remote::{ diff --git a/crates/vcs/tests/ignore.rs b/crates/vcs/tests/ignore.rs new file mode 100644 index 0000000..04959cd --- /dev/null +++ b/crates/vcs/tests/ignore.rs @@ -0,0 +1,86 @@ +//! Ignoring files against a real temp repository: literal patterns for +//! odd names, a project in a subfolder, no duplicates, a missing final line +//! break, and refused paths. Skips with a message when git is not +//! installed. + +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use std::path::Path; +use std::process::Command; + +use lutra_vcs::{Git, VcsError}; + +/// The installed git, or `None` (with a message) when there is none. +fn installed() -> Option { + match Git::detect("") { + Ok(git) => Some(git), + Err(e) => { + eprintln!("skipped: no usable git installed ({e})"); + None + } + } +} + +/// Runs git in `dir` and returns its stdout and whether it succeeded. +fn git(dir: &Path, args: &[&str]) -> (String, bool) { + let out = Command::new("git") + .args(args) + .current_dir(dir) + .env_remove("GIT_DIR") + .env_remove("GIT_WORK_TREE") + .env_remove("GIT_INDEX_FILE") + .output() + .unwrap(); + ( + String::from_utf8_lossy(&out.stdout).trim().to_string(), + out.status.success(), + ) +} + +/// Whether git ignores `path` (root-relative). +fn ignored(dir: &Path, path: &str) -> bool { + git(dir, &["check-ignore", "-q", "--no-index", "--", path]).1 +} + +#[test] +fn ignores_exactly_the_given_paths() { + let Some(cli) = installed() else { return }; + let dir = tempfile::tempdir().unwrap(); + let root = dir.path(); + assert!(git(root, &["init", "-q", "-b", "main"]).1); + std::fs::create_dir_all(root.join("app/var")).unwrap(); + std::fs::write(root.join(".gitignore"), "vendor/").unwrap(); + for name in [ + "app/a[1].php", + "app/a1.php", + "app/var/cache.log", + "app/b.php", + ] { + std::fs::write(root.join(name), "x").unwrap(); + } + let repo = cli.open(&root.join("app")).unwrap().expect("a repository"); + + let added = repo + .ignore(&[ + "a[1].php".to_string(), + "var".to_string(), + "var/".to_string(), + ]) + .unwrap(); + assert_eq!(added, vec![r"/app/a\[1].php", "/app/var"]); + assert_eq!( + std::fs::read_to_string(root.join(".gitignore")).unwrap(), + "vendor/\n/app/a\\[1].php\n/app/var\n" + ); + assert!(ignored(root, "app/a[1].php")); + assert!(!ignored(root, "app/a1.php")); + assert!(ignored(root, "app/var/cache.log")); + assert!(!ignored(root, "app/b.php")); + + assert!(repo.ignore(&["a[1].php".to_string()]).unwrap().is_empty()); + assert!(matches!( + repo.ignore(&["../outside".to_string(), "b.php".to_string()]), + Err(VcsError::InvalidPath(_)) + )); + assert!(!ignored(root, "app/b.php")); +} diff --git a/docs/architecture.md b/docs/architecture.md index 44243d0..3701e03 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -594,6 +594,7 @@ Watched directories: the VFS watcher is non-recursive, so `project.children` wat - **Commands** (UI commands, menu group Git): `vcs.openChanges` `Mod+Alt+Shift+G` shows the tab; `vcs.commit` `Mod+Alt+Shift+M` shows it and focuses the message box; `vcs.refresh` re-reads the status (enabled while `git.status` is). The shortcuts are Lutra's own: checked against the public default keymaps (Windows and macOS) so they copy no default there, and against Lutra's registered shortcuts and CodeMirror's `basicSetup` keys (`Mod+Alt+G` is its go to line, which the global listener would swallow). - **Status:** read from the shared status store (`ui/src/stores/vcsStatus.ts`, since C6 F1), which runs `git.status` on start, on `projectOpened`, on `gitChanged` and on `vcs.refresh`; `projectClosed` clears it and with it the rows and the selection. The result is untrusted: unknown states and malformed entries are dropped, at most 50,000 files. - **Amend prefill (C6 F1):** checking Amend with an empty message box fills it from `git.lastMessage`; clearing Amend empties a box that still holds exactly that text. A message already typed is never replaced. The event type `gitChanged` is now part of `EngineEventPayload` in `ui/src/ipc.ts`. +- **Context menu and ignoring (C7 A3):** a right click on a row (or Shift+F10 / the context-menu key) opens `ChangesContextMenu.vue`: Open, and Add to .gitignore for untracked rows. That runs `git.ignore {paths}` (`cmd/git_ignore.rs`, `crates/vcs/src/ignore.rs`) → `{patterns}`: one pattern per path appended to the work tree root's `.gitignore`, anchored with `/` and with `\ * ? [` and trailing spaces escaped, so it matches only that path; patterns already present are skipped; `gitChanged` follows. - **Groups:** Staged (the index side changed), Changes (the work tree side changed, or conflicted), Untracked. A partly staged file is in Staged and Changes. Names are coloured with `--lt-vcs-*` (renamed and modified use `modified`, copied uses `added`); a deleted file is struck through. A staged rename shows "from ". - **Staging:** a checkbox per file and per group header: checked in Staged (clearing it unstages), clear elsewhere (checking it stages). `git.stage {paths}` / `git.unstage {paths}`, both through `runWaiting`; unstaging a staged rename passes both paths, as M4.1 requires. Keyboard: Up/Down, Page Up/Down, Home, End move; Space stages or unstages; Enter opens. Failures toast git's message (`notification.command.failed`). - **Opening:** Enter or a double-click runs the UI command `vcs.showDiff {path, staged}` when something provides it (the diff viewer, M4.3, registers and provides it); until then the file opens with `file.open`, and a deleted file does nothing. @@ -756,6 +757,7 @@ Watched directories: the VFS watcher is non-recursive, so `project.children` wat | Date | Change | Summary | |---|---|---| +| 2026-10-31 | minor | C7 A3: `git.mergeMessage` and the merge message prefill, `git.ignore` and the Changes context menu, gutter markers kept on their line, per-module `COMMAND_IDS` for the command listing test | | 2026-10-30 | minor | M4.7: blame (`git.blame` with `--contents` from the buffer, the annotation gutter by age, hover with the commit message, `vcs.toggleBlame`, `vcs.showCommit`) | | 2026-10-28 | minor | M4.6: history backend (`git.log`, `git.showCommit`, `git.showAt`), the shared hook for new git commands, the Log tab, diffs at a commit | | 2026-10-28 | minor | M4.10: remotes (`Call::network` with progress and cancel, URL redaction, `git.fetch/pull/push/clone/cancel/remotes/remoteAdd/remoteSetUrl/remoteRemove`, `gitProgress`, `git.pull.mode`, the clone and remotes dialogs) | diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index 465cf95..cda67b7 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -22,7 +22,7 @@ Hours are the estimated agent wall-clock hours for one agent to reach behaviour | 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 | 16% (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: a unified view, three-way merge, revert or stage a chunk from the diff, comparing with any revision or branch, ignore-whitespace options, folders; branches: merge, rebase, rename, delete, compare, favourites, incoming/outgoing markers, a branch from another start point; log: date and branch filters, several selected commits, cherry-pick, revert, reset, checkout or new branch from a commit, compare two commits, history of a selection; blame (C6); stash: stashing selected files, a stash's diff, unstash as a branch, restoring the index; remotes: force push, tags, a push dialog with the outgoing commits and a target branch, hosting features (pull requests, issues), a check against a real hosted server; ignored files in the status | ~122 (est.) | C6 M4.9: stash from the Git menu or the Changes window (`vcs.stash`, `vcs.showStashes`): a message and "Include untracked files", open files saved first; a list of entries (message or WIP text, branch, date) with apply, pop and drop after a question; refusals say what to do (nothing to stash, no commit yet, unresolved conflicts, conflicts after applying with the entry kept, files that would be overwritten, a stash changed meanwhile). Backend `git.stash`, `git.stashList`, `git.stashApply {index, pop, hash?}`, `git.stashDrop`. Tests: `crates/vcs/tests/stash.rs`, `crates/engine/tests/git_stash.rs`, `ui/tests/vcs/Stash.test.ts`. M4.8: `vcs.merge` (Git › Merge…) merges a branch after saving and toasts merged, up to date or git's refusal; on conflicts the merge dialog lists the conflicted files (also from Changes and Git › Resolve Conflicts…); each opens a three-pane resolve view (current branch, the editable result starting from the base with non-conflicting changes applied, merged branch) with » / « per chunk, accept left/right, accept all and previous/next conflict; Apply writes the result through the file's buffer and runs `git.markResolved`; modify/delete keeps one side; Abort Merge after a confirmation. Backend `git.merge`, `git.mergeAbort`, `git.conflictVersions`, `git.markResolved`. Tests: `crates/vcs/tests/merge.rs`, `crates/engine/tests/git_merge.rs`, 22 Vitest tests (`ui/tests/vcs/Merge.test.ts`). M4.10: fetch, pull (merge or rebase per `git.pull.mode`, open files saved first) and push (upstream set on the first push) as `git.fetch/pull/push` and Git › Fetch / Pull / Push, with `gitProgress` in the status bar, Cancel (`git.cancel`, git and its children killed) and explained refusals (rejected push, sign-in, unknown host key, not found, unreachable, no upstream, conflicts); Git › Clone Repository… (`git.clone`, then `project.open`) and Git › Manage Remotes… (`git.remotes/remoteAdd/remoteSetUrl/remoteRemove`). Any HTTPS or SSH server through git's credential helper (its window allowed) and the ssh agent; no terminal prompts, `ext::` refused, URL userinfo redacted everywhere (D23). Tests against local bare repositories only (`crates/vcs/tests/remote.rs` 8, `crates/engine/tests/git_remote.rs` 3, Vitest `ui/tests/vcs/Remote.test.ts` 11); not checked against a hosted server. C6 M4.6: a Log tab in the bottom panel (`vcs.showLog`, menu Git › Log) lists all branches' commits in topological order with graph lanes, ref badges, author and date, 100 per page loaded as the list scrolls; message and author filters; the selected commit's message and changed files, each opening a read-only "Diff: ()" at that commit against its parent (renames followed); history of a file or folder (`vcs.showHistory`: menu, the tree's context menu, or the active editor tab) follows renames. Backend `git.log`, `git.showCommit`, `git.showAt`. Tests: `crates/vcs/tests/log.rs`, `crates/engine/tests/git_log.rs`, Vitest `ui/tests/vcs/Log.test.ts` (21). C6 F1: Amend fills an empty message box with the last commit message (`git.lastMessage`); checking out a remote branch whose remote is not configured gives an untracked local branch and a clean tree instead of a half-done checkout; one shared status store, so a `gitChanged` costs one `git.status` for the Changes window, the colours and the branch item. M4.5: a status-bar item shows the current branch, or the short hash when detached (`ui/src/components/vcs/branches/`); clicking it or `vcs.branches` (menu Git › Branches…) opens a popup with a filter field, "New branch…", the local branches (current marked, upstream shown) and the remote branches, keyboard-driven; choosing one runs `vcs.checkout {branch}`, which saves dirty buffers through `flushDirty()` first, cancels when a save fails and toasts git's refusal with the branch name; a remote branch checks out its tracking branch. "New branch…" / `vcs.newBranch {name?, checkout?}` creates one from HEAD (checked out by default) and keeps git's refusal next to the name. Tests: 16 Vitest tests (`ui/tests/vcs/Branches.test.ts`). M4.3: `vcs.showDiff {path, staged?}` (`Mod+Alt+Shift+D`, menu Git › Show Diff, double-click in Changes, the project tree's context menu, the palette) opens a "Diff: " tab in the editor area: `@codemirror/merge` side by side, the staged version (or the last commit for a staged row) read-only on the left, the working copy editable on the right through its normal engine buffer (saves, autosave, the journal), changed lines and words tinted with `--lt-vcs-*`, unchanged stretches collapsed, the left side re-read on `gitChanged`; next/previous change (`Alt+Shift+]` / `Alt+Shift+[`); notices for binary, too large, failed and deleted files (`ui/src/components/vcs/diff/`, 21 Vitest tests). 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, staging and switching or creating branches work from the UI, and changed lines and files are marked (read-only markers, no chunk actions); diff, log, blame and remotes do not yet. | +| Git | 8 | 16% (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, context menu actions beyond Open and Add to .gitignore (rollback, delete); gutter markers: actions (show the old text, revert or stage a chunk, next/previous change), markers against HEAD; directory status colours; diff viewer: a unified view, three-way merge, revert or stage a chunk from the diff, comparing with any revision or branch, ignore-whitespace options, folders; branches: merge, rebase, rename, delete, compare, favourites, incoming/outgoing markers, a branch from another start point; log: date and branch filters, several selected commits, cherry-pick, revert, reset, checkout or new branch from a commit, compare two commits, history of a selection; blame (C6); stash: stashing selected files, a stash's diff, unstash as a branch, restoring the index; remotes: force push, tags, a push dialog with the outgoing commits and a target branch, hosting features (pull requests, issues), a check against a real hosted server; ignored files in the status | ~122 (est.) | C7 A3: a context menu on Changes rows (right click, Shift+F10 or the context-menu key) with Open and Add to .gitignore for untracked files (`git.ignore`: one anchored, escaped literal pattern per file in the root `.gitignore`); while a merge waits on conflicts, an empty commit box offers git's prepared merge message (`git.mergeMessage`); gutter markers stay on their line when text is inserted at its start. Tests: `crates/vcs/tests/ignore.rs`, `crates/vcs/tests/merge.rs`, `crates/engine/tests/git_merge.rs`, Vitest (`ui/tests/vcs/ChangesToolWindow.test.ts`, `ui/tests/editor/gitGutter.test.ts`). C6 M4.9: stash from the Git menu or the Changes window (`vcs.stash`, `vcs.showStashes`): a message and "Include untracked files", open files saved first; a list of entries (message or WIP text, branch, date) with apply, pop and drop after a question; refusals say what to do (nothing to stash, no commit yet, unresolved conflicts, conflicts after applying with the entry kept, files that would be overwritten, a stash changed meanwhile). Backend `git.stash`, `git.stashList`, `git.stashApply {index, pop, hash?}`, `git.stashDrop`. Tests: `crates/vcs/tests/stash.rs`, `crates/engine/tests/git_stash.rs`, `ui/tests/vcs/Stash.test.ts`. M4.8: `vcs.merge` (Git › Merge…) merges a branch after saving and toasts merged, up to date or git's refusal; on conflicts the merge dialog lists the conflicted files (also from Changes and Git › Resolve Conflicts…); each opens a three-pane resolve view (current branch, the editable result starting from the base with non-conflicting changes applied, merged branch) with » / « per chunk, accept left/right, accept all and previous/next conflict; Apply writes the result through the file's buffer and runs `git.markResolved`; modify/delete keeps one side; Abort Merge after a confirmation. Backend `git.merge`, `git.mergeAbort`, `git.conflictVersions`, `git.markResolved`. Tests: `crates/vcs/tests/merge.rs`, `crates/engine/tests/git_merge.rs`, 22 Vitest tests (`ui/tests/vcs/Merge.test.ts`). M4.10: fetch, pull (merge or rebase per `git.pull.mode`, open files saved first) and push (upstream set on the first push) as `git.fetch/pull/push` and Git › Fetch / Pull / Push, with `gitProgress` in the status bar, Cancel (`git.cancel`, git and its children killed) and explained refusals (rejected push, sign-in, unknown host key, not found, unreachable, no upstream, conflicts); Git › Clone Repository… (`git.clone`, then `project.open`) and Git › Manage Remotes… (`git.remotes/remoteAdd/remoteSetUrl/remoteRemove`). Any HTTPS or SSH server through git's credential helper (its window allowed) and the ssh agent; no terminal prompts, `ext::` refused, URL userinfo redacted everywhere (D23). Tests against local bare repositories only (`crates/vcs/tests/remote.rs` 8, `crates/engine/tests/git_remote.rs` 3, Vitest `ui/tests/vcs/Remote.test.ts` 11); not checked against a hosted server. C6 M4.6: a Log tab in the bottom panel (`vcs.showLog`, menu Git › Log) lists all branches' commits in topological order with graph lanes, ref badges, author and date, 100 per page loaded as the list scrolls; message and author filters; the selected commit's message and changed files, each opening a read-only "Diff: ()" at that commit against its parent (renames followed); history of a file or folder (`vcs.showHistory`: menu, the tree's context menu, or the active editor tab) follows renames. Backend `git.log`, `git.showCommit`, `git.showAt`. Tests: `crates/vcs/tests/log.rs`, `crates/engine/tests/git_log.rs`, Vitest `ui/tests/vcs/Log.test.ts` (21). C6 F1: Amend fills an empty message box with the last commit message (`git.lastMessage`); checking out a remote branch whose remote is not configured gives an untracked local branch and a clean tree instead of a half-done checkout; one shared status store, so a `gitChanged` costs one `git.status` for the Changes window, the colours and the branch item. M4.5: a status-bar item shows the current branch, or the short hash when detached (`ui/src/components/vcs/branches/`); clicking it or `vcs.branches` (menu Git › Branches…) opens a popup with a filter field, "New branch…", the local branches (current marked, upstream shown) and the remote branches, keyboard-driven; choosing one runs `vcs.checkout {branch}`, which saves dirty buffers through `flushDirty()` first, cancels when a save fails and toasts git's refusal with the branch name; a remote branch checks out its tracking branch. "New branch…" / `vcs.newBranch {name?, checkout?}` creates one from HEAD (checked out by default) and keeps git's refusal next to the name. Tests: 16 Vitest tests (`ui/tests/vcs/Branches.test.ts`). M4.3: `vcs.showDiff {path, staged?}` (`Mod+Alt+Shift+D`, menu Git › Show Diff, double-click in Changes, the project tree's context menu, the palette) opens a "Diff: " tab in the editor area: `@codemirror/merge` side by side, the staged version (or the last commit for a staged row) read-only on the left, the working copy editable on the right through its normal engine buffer (saves, autosave, the journal), changed lines and words tinted with `--lt-vcs-*`, unchanged stretches collapsed, the left side re-read on `gitChanged`; next/previous change (`Alt+Shift+]` / `Alt+Shift+[`); notices for binary, too large, failed and deleted files (`ui/src/components/vcs/diff/`, 21 Vitest tests). 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, staging and switching or creating branches work from the UI, and changed lines and files are marked (read-only markers, no chunk actions); diff, 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.) | — | @@ -65,6 +65,7 @@ The project tree is the first user-visible feature (Project view 8%, estimated); | Date | Change | Summary | |---|---|---| +| 2026-10-31 | patch | C7 A3 evidence in the Git row (Changes context menu with Add to .gitignore, merge message prefill, gutter markers on inserts); score left to the PM | | 2026-10-30 | minor | C6 review: Git 11% → 16% (est.): log, blame, merge conflicts, stash and remotes on top of the C5 core | | 2026-10-30 | patch | M4.9 evidence in the Git row (stash dialog, apply/pop/drop, refusals); score left to the PM | | 2026-10-28 | patch | M4.6 evidence in the Git row (Log tab, commit details, diff at a commit, file history); score left to the PM | diff --git a/docs/ui-parity.md b/docs/ui-parity.md index bf0a646..4a4a2da 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -41,7 +41,7 @@ - [ ] Terminal tool window - M3.6 (2026-10-18): a Terminal tab in the bottom panel (the panel shows Find and Terminal as tabs while both are open; Left/Right switch); xterm.js with the fit addon follows the panel size; several terminals as sub-tabs (Local, Local (2)…) with a close button each and a new-terminal button, Left/Right/Home/End/Delete on a sub-tab, an ended shell dims its tab and prints its exit code; output survives collapsing the panel; copy with `Mod+Shift+C` or `Ctrl+C` on a selection, paste with `Mod+Shift+V` or `Ctrl+V`; while a terminal has the focus plain Ctrl keys go to the shell and only Mod+Shift / Mod+Alt shortcuts reach Lutra; Lutra's own ANSI palette in both themes (text colours ≥ 4.5:1). `terminal.open` `Mod+Shift+T`. Missing: renaming and splitting tabs, a context menu, search, clickable links and paths, drag and drop, a key back to the editor, a confirmation before killing a running process, terminal settings. - [ ] Git tool window - - M4.2 (2026-10-25): a Changes tab in the bottom panel (`vcs.openChanges` `Mod+Alt+Shift+G`, menu Git › Changes): Staged, Changes and Untracked groups with counts, file names coloured by status (`--lt-vcs-*`, deleted struck through, a staged rename shows its old path), a checkbox per file and per group to stage or unstage, Up/Down/Page/Home/End and Space in the list, double-click or Enter opens the diff (M4.3) or the file; a commit message box with Amend and Commit (`Mod+Enter`; `vcs.commit` `Mod+Alt+Shift+M` focuses it), saving open files first; a refresh button (`vcs.refresh`); hints when git is missing or the folder is not a repository. Vitest (19 tests). Missing: a tree view and grouping by directory or module, changelists, chunk staging, a context menu (rollback, delete, add to .gitignore), recent commit messages, commit options (sign-off, author, skip hooks), commit and push, a commit preview of the diff. Behaviour notes: `plan/phpstorm/16-vcs-basics.md`. + - M4.2 (2026-10-25): a Changes tab in the bottom panel (`vcs.openChanges` `Mod+Alt+Shift+G`, menu Git › Changes): Staged, Changes and Untracked groups with counts, file names coloured by status (`--lt-vcs-*`, deleted struck through, a staged rename shows its old path), a checkbox per file and per group to stage or unstage, Up/Down/Page/Home/End and Space in the list, double-click or Enter opens the diff (M4.3) or the file; a commit message box with Amend and Commit (`Mod+Enter`; `vcs.commit` `Mod+Alt+Shift+M` focuses it), saving open files first; a refresh button (`vcs.refresh`); hints when git is missing or the folder is not a repository. Vitest (19 tests). C7 A3: a row context menu (right click, Shift+F10, the context-menu key) with Open and Add to .gitignore for untracked files, and git's prepared merge message offered in an empty box during a merge. Missing: a tree view and grouping by directory or module, changelists, chunk staging, context menu actions to roll back or delete, recent commit messages, commit options (sign-off, author, skip hooks), commit and push, a commit preview of the diff. Behaviour notes: `plan/phpstorm/16-vcs-basics.md`. - M4.4 (2026-10-25): the editor gutter shows a bar beside lines added or changed since the staged version and a notch where lines were deleted (tooltips from the catalog), updated 150 ms after typing and whenever Git changes; file names in the project tree and the tabs take the Git status colour (added, modified, deleted, untracked, conflicted; ignored entries inside a repository). Vitest. Missing: clicking a marker to see the old text, revert or stage the chunk, next/previous change, markers against HEAD, coloured directories. - M4.3 (2026-10-26): "Diff: " tabs in the editor area after the file tabs (`vcs.showDiff` `Mod+Alt+Shift+D`, menu Git › Show Diff; double-click or Enter in Changes; right click or Shift+F10 on a file in the project tree → Show Diff): the staged version or the last commit on the left, read-only, and the working copy on the right, editable like its own tab; a caption says what is compared; changed lines and words tinted with the VCS tokens, a change bar in each gutter, unchanged stretches collapsed to a clickable row; next/previous change `Alt+Shift+]` / `Alt+Shift+[` (wrapping); notices for binary, too large and deleted files and for git's errors. The project tree got its first context menu (Open, Show Diff; WAI-ARIA menu, keyboard). Vitest. Missing: unified view, revert/stage arrows between the sides, synchronised horizontal scrolling, whitespace and highlighting options, comparing with any revision, a diff window of its own, more tree context menu items. - M4.5 (2026-10-26): the status bar shows the current branch (Lucide `git-branch`), or the short hash when detached, hidden outside a repository. A click or `vcs.branches` (menu Git › Branches…) opens a popup above it: a filter field, "New branch…", Local (current one checked, upstream beside it) and Remote headings; Up/Down/Page keys, Enter or a click checks out, Escape or a click outside closes and returns the focus. "New branch…" switches to a name field with a "Check out" checkbox; git's refusal shows under the field. An exclusive modal. Vitest (16 tests). Missing: merge, rebase, rename, delete, compare with current, favourites, recent branches first, incoming/outgoing markers, a submenu per branch. @@ -51,6 +51,7 @@ | Date | Change | Summary | |---|---|---| +| 2026-10-31 | patch | Changes context menu with Add to .gitignore and the merge message prefill (C7 A3) | | 2026-10-28 | minor | Fetch/pull/push with progress, clone and remotes dialogs (M4.10) | | 2026-10-26 | minor | Branch widget and popup (M4.5) | | 2026-10-26 | minor | Diff viewer and the project tree's context menu (M4.3) | diff --git a/ui/src/components/vcs/changes/ChangesContextMenu.vue b/ui/src/components/vcs/changes/ChangesContextMenu.vue new file mode 100644 index 0000000..5f8cb89 --- /dev/null +++ b/ui/src/components/vcs/changes/ChangesContextMenu.vue @@ -0,0 +1,200 @@ + + + + + diff --git a/ui/src/components/vcs/changes/ChangesToolWindow.vue b/ui/src/components/vcs/changes/ChangesToolWindow.vue index 8bc49ba..b8da5a6 100644 --- a/ui/src/components/vcs/changes/ChangesToolWindow.vue +++ b/ui/src/components/vcs/changes/ChangesToolWindow.vue @@ -20,6 +20,9 @@ * `vcs.showDiff {path, staged}` when something provides it (the diff * viewer, M4.3); until then the file opens in the editor (`file.open`), * unless it was deleted. + * - **Context menu (C7 A3):** a right click on a row, or Shift+F10 / the + * context-menu key on the selected one, opens `ChangesContextMenu.vue`: + * Open, and Add to .gitignore for untracked files. * - **Commit box:** the message, an Amend checkbox and Commit. Commit * saves dirty buffers first (`flushDirty`); `Mod+Enter` in the box * commits too. @@ -35,6 +38,7 @@ import { t } from "../../../i18n"; import { run } from "../../../ipc"; import { baseName } from "../../../stores/editor"; import { useNotificationsStore } from "../../../stores/notifications"; +import ChangesContextMenu from "./ChangesContextMenu.vue"; import { SHORT_HASH, useChangesStore, type ChangeRow, type FileState, type GroupId } from "./changes"; const changes = useChangesStore(); @@ -46,6 +50,27 @@ const list = ref(null); /** The commit message box. */ const messageBox = ref(null); +/** The open context menu: its row and where it shows; null when closed. */ +const menu = ref<{ row: ChangeRow; x: number; y: number } | null>(null); + +/** + * Opens the context menu of a row. + * + * @param row - the row; it becomes the selection. + * @param x - window x of the menu. + * @param y - window y of the menu. + */ +function openMenu(row: ChangeRow, x: number, y: number): void { + changes.select(row.key); + menu.value = { row, x, y }; +} + +/** Closes the context menu and gives the focus back to the list. */ +function closeMenu(): void { + menu.value = null; + list.value?.focus(); +} + /** Rows moved by Page Up and Page Down. */ const PAGE = 10; @@ -259,6 +284,10 @@ function onListKey(event: KeyboardEvent): void { } else if (event.key === " " && row) { event.preventDefault(); void changes.toggle(row); + } else if ((event.key === "ContextMenu" || (event.key === "F10" && event.shiftKey)) && row) { + event.preventDefault(); + const rect = document.getElementById(optionId(changes.selectedIndex))?.getBoundingClientRect(); + openMenu(row, rect ? rect.left + 24 : 0, rect ? rect.bottom : 0); } } @@ -399,6 +428,7 @@ watch( data-test="changes-row" @click="changes.select(row.key)" @dblclick="openRow(row)" + @contextmenu.prevent="openMenu(row, $event.clientX, $event.clientY)" > +
{ void onAmend(on); }); + /** Whether the box is empty and Amend is off, so a prepared message may fill it. */ + function boxFree(): boolean { + return !amend.value && message.value.trim() === ""; + } + /** Whether the prepared merge message was offered for the merge in progress. */ let mergeOffered = false; @@ -249,7 +256,7 @@ export const useChangesStore = defineStore("changes", () => { * is; no merge also ends the current offer. */ async function offerMergeMessage(): Promise { - if (amend.value || message.value.trim() !== "") { + if (!boxFree()) { return; } const result = await runWaiting("git.mergeMessage"); @@ -266,7 +273,7 @@ export const useChangesStore = defineStore("changes", () => { return; } mergeOffered = true; - if (!amend.value && message.value.trim() === "") { + if (boxFree()) { message.value = text; } } @@ -343,6 +350,32 @@ export const useChangesStore = defineStore("changes", () => { return row.group === "staged" ? unstage([row]) : stage([row]); } + /** + * Adds untracked files to the root `.gitignore`, one literal pattern + * each, and toasts the result. + * + * @param list - rows; those not in Untracked are ignored. + */ + async function ignore(list: ChangeRow[]): Promise { + const paths = [...new Set(list.filter((row) => row.group === "untracked").map((row) => row.file.path))]; + if (paths.length === 0 || busy.value) { + return; + } + busy.value = true; + try { + if ((await mutate("git.ignore", { paths })) !== null) { + notifications.notify({ + level: "info", + messageKey: "notification.vcs.ignored", + params: { path: paths.join(", ") }, + }); + await refresh(); + } + } finally { + busy.value = false; + } + } + /** * Stages or unstages a whole group. * @@ -482,6 +515,7 @@ export const useChangesStore = defineStore("changes", () => { unstage, toggle, toggleGroup, + ignore, commit, start, stop, diff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.json index 09a6b9b..3b71016 100644 --- a/ui/src/i18n/en.json +++ b/ui/src/i18n/en.json @@ -183,6 +183,7 @@ "notification.vcs.fetchFailed": "Fetch failed: {reason}", "notification.vcs.fetched": "Fetched from every remote", "notification.vcs.historyNoFile": "Open a file or pass a path to show its history", + "notification.vcs.ignored": "Added to .gitignore: {path}", "notification.vcs.mergeAborted": "Merge aborted", "notification.vcs.mergeConflicts": "Merging {branch} stopped on conflicts (conflicted files: {count}). Resolve them, then commit.", "notification.vcs.mergeFailed": "Git did not merge {branch}: {reason}", @@ -347,6 +348,9 @@ "vcs.changes.group.untracked": "Untracked", "vcs.changes.list.label": "Changed files", "vcs.changes.loading": "Reading the Git status…", + "vcs.changes.menu.ignore": "Add to .gitignore", + "vcs.changes.menu.label": "Actions for {path}", + "vcs.changes.menu.open": "Open", "vcs.changes.noCommits": "no commits yet", "vcs.changes.noProject": "Open a project to see its changes", "vcs.changes.noRepo": "This project is not in a Git repository", diff --git a/ui/tests/vcs/ChangesToolWindow.test.ts b/ui/tests/vcs/ChangesToolWindow.test.ts index b8cbc10..f7ef920 100644 --- a/ui/tests/vcs/ChangesToolWindow.test.ts +++ b/ui/tests/vcs/ChangesToolWindow.test.ts @@ -430,6 +430,35 @@ describe("the Changes window", () => { expect(callsOf("file.open").map((c) => c.params)).toEqual([{ path: "src/a.php" }]); }); + it("adds an untracked file to .gitignore from its context menu", async () => { + const wrapper = await mountChanges(); + const rows = wrapper.findAll("[data-test=changes-row]"); + await rows[0]?.trigger("contextmenu", { clientX: 10, clientY: 10 }); + const items = (): HTMLElement[] => [...document.querySelectorAll("[data-test=changes-menu-item]")]; + expect(items().map((item) => item.dataset.item)).toEqual(["open", "ignore"]); + expect(items()[1]?.getAttribute("aria-disabled")).toBe("true"); + items()[1]?.click(); + await flushPromises(); + expect(callsOf("git.ignore")).toHaveLength(0); + document.querySelector("[data-test=changes-menu]")?.dispatchEvent( + new KeyboardEvent("keydown", { key: "Escape", bubbles: true }), + ); + await flushPromises(); + expect(document.querySelector("[data-test=changes-menu]")).toBeNull(); + + const list = wrapper.get("[data-test=changes-list]"); + await list.trigger("keydown", { key: "End" }); + await list.trigger("keydown", { key: "F10", shiftKey: true }); + expect(items()[1]?.getAttribute("aria-disabled")).toBe("false"); + const refreshes = callsOf("git.status").length; + items()[1]?.click(); + await flushPromises(); + expect(callsOf("git.ignore").map((c) => c.params)).toEqual([{ paths: ["tmp.txt"] }]); + expect(callsOf("git.status").length).toBe(refreshes + 1); + expect(useNotificationsStore(pinia).toasts.map((toast) => toast.text)).toContain("Added to .gitignore: tmp.txt"); + expect(document.querySelector("[data-test=changes-menu]")).toBeNull(); + }); + it("opens through vcs.showDiff when it is provided, and never opens a deleted file", async () => { const wrapper = await mountChanges(); const rows = wrapper.findAll("[data-test=changes-row]");