coc-git 2.7.10 → 2.7.11

package/AGENTS.md

@@ -0,0 +1,61 @@
+# AGENTS.md
+
+## Repository purpose
+
+`coc-git` is the Git integration extension for `coc.nvim`. Its runtime entry point is `src/index.ts`; the published entry point is the bundled `lib/index.js`. The extension owns Git-backed buffer state, gutters and blame text, conflict actions, Coc lists, GitHub/GitLab issue completion, and the commands/keymaps declared in `package.json`.
+
+## Code map
+
+
+- `src/index.ts` is the activation and registration layer. Register new Coc commands, `<Plug>` keymaps, lists, completion providers, and disposables here.
+- `src/manager.ts` coordinates editor events, live `GitBuffer` instances, configuration, and user-facing operations.
+- `src/model/git.ts` is the low-level child-process wrapper around the configured Git executable.
+- `src/model/repo.ts` implements repository-scoped Git operations; put Git command construction and output parsing there rather than in the activation layer.
+- `src/model/resolver.ts` resolves documents and working directories to repositories and relative paths.
+- `src/model/buffer.ts` owns per-buffer diffs, signs, blame, folds, and conflict state.
+- `src/model/service.ts` owns resolver/repository lifetimes and constructs `GitBuffer` instances.
+- `src/lists/` contains Coc list implementations (`gstatus`, `gfiles`, `gchanges`, `gchunks`, `branches`, `commits`, and `bcommits`). List-specific actions and rendering belong in the corresponding list class.
+- `src/source.ts` implements GitHub/GitLab issue loading plus the `issues` list/completion source.
+- `src/types.ts` is the shared contract for diffs, conflicts, and the configuration object passed into buffer/model code.
+- `package.json` is also the Coc extension manifest: command names, activation, and all user-visible configuration schemas live there.
+- `Readme.md` documents the public commands, keymaps, lists, environment variables, and settings.
+
+## Public-contract synchronization
+
+When changing a user-facing feature, update every surface that represents the same contract:
+
+- A new `git.*` command needs a `commands.registerCommand` registration in `src/index.ts` and an entry under `contributes.commands` in `package.json`. Add it to `Readme.md` when it is intended for direct use.
+- A new `<Plug>(coc-git-...)` mapping needs a `workspace.registerKeymap` registration in `src/index.ts` and matching usage documentation in `Readme.md`.
+- A new `git.*` setting needs a schema entry under `contributes.configuration.properties` in `package.json`, a typed field in `src/types.ts` when consumed beyond the registration layer, and loading/default logic in `DocumentManager.loadConfiguration()` in `src/manager.ts`. Keep defaults identical across those locations and `Readme.md`.
+- A new list must be implemented under `src/lists/`, registered through `listManager` in `src/index.ts`, and added to the documented list names.
+- Preserve the exported `ExtensionApi` shape in `src/index.ts` unless the API change is intentional; other Coc extensions can consume `git`, `resolver`, and `manager` from activation.
+
+## Git and editor behavior
+
+- Use the configured executable discovered from `git.command`; do not hard-code an executable path. Model-layer Git execution should flow through `Git`, `GitRepo`, or the existing command helpers.
+- Keep Git work asynchronous. Do not introduce synchronous child-process calls into buffer refresh, cursor movement, completion, or list loading paths.
+- Pass arguments as arrays to `Git.exec`, `Git.stream`, or `spawnCommand` when filenames or revisions are involved. The repository already supports paths containing spaces; avoid building an unescaped shell string unless the operation specifically requires an interactive terminal command.
+- Preserve cancellation and disposal behavior around spawned processes and Coc event listeners. Anything registered during activation or manager construction must be owned by the existing `subscriptions`/`disposables` lifecycle.
+- Buffer refreshes are event-driven (`TextChange`, writes when realtime gutters are disabled, `FocusGained`, and `BufEnter`). Changes to diff or blame behavior must account for stale async results and for buffers disposed while repository resolution is still running.
+- Keep Vim and Neovim compatibility. Virtual text, floating windows, namespaces, terminal operations, and popup behavior must retain the existing capability checks or Coc abstractions; do not use a Neovim-only API on an unconditional path.
+- Git output is normalized under `LC_ALL`/`LANG=en_US.UTF-8` and decoded through `iconv-lite`. Parsing code must not depend on the user's localized Git messages.
+- GitHub issue access uses `GITHUB_API_TOKEN`; GitLab access uses `GITLAB_PRIVATE_TOKEN` and `git.gitlab.hosts`. Do not log tokens or put them into rendered list/completion items.
+
+## Generated output and dependencies
+
+- Do not edit or commit `lib/index.js`; `lib/` is generated and ignored. Change TypeScript under `src/` and rebuild it with `npm run build`.
+- `esbuild.js` must continue to bundle `src/index.ts` for Node while leaving `coc.nvim` external. The bundle target is `node10.12`; avoid emitting runtime syntax or APIs that violate that target unless the target is deliberately raised.
+- Use npm for dependency and lockfile changes. CI installs with `npm ci`, so `package.json` and `package-lock.json` must stay synchronized.
+- `npm run lint` is TypeScript checking (`tsc -p tsconfig.json`), not an ESLint formatting pass. The project enables `noUnusedLocals` and emits nothing during this check.
+
+## Verification
+
+Run checks according to the affected subsystem:
+
+- Type/config/registration changes: `npm run lint` and `npm run build`.
+- Git parsing, repository, buffer, manager, list, source, command, or keymap behavior: `npm test`.
+- Vim-specific behavior: `npm run test:integration:vim`.
+- Neovim-specific behavior: `npm run test:integration:nvim`.
+- Changes intended to pass CI must succeed in both editor variants. The GitHub Actions matrix uses Node 22 and runs typechecking plus the Vim and Neovim integration suites.
+
+For manual editor verification, load the rebuilt extension through Coc and exercise the exact public surface changed: the relevant `:CocCommand git.*`, `<Plug>(coc-git-*)` mapping, `:CocList` list, gutter/blame update, conflict action, or issue completion flow. Use a temporary Git repository containing the required staged, unstaged, untracked, renamed, conflicted, or non-UTF-8-path state rather than testing against this checkout's working tree.

package/Readme.md

@@ -152,6 +152,8 @@ In your vim/neovim, run command:
 
 - `git.commitFiles.splitCommand`: Command used to open the changed-files TreeView for a commit, default: `"belowright 40vs"`
 
+- `git.statusTree.splitCommand`: Command used to open the Git status TreeView, default: `"belowright 40vs"`
+
 - `git.floatConfig`: Configure style of float window/popup, extends from floatFactory.floatConfig, default: `{}`.
 
 - `git.gitlab.hosts`: Custom GitLab hosts, default: `["gitlab.com"]`
@@ -279,6 +281,7 @@ related commands.
 - `:CocCommand git.copyUrl` Copy url of current line to clipboard.
 - `:CocCommand git.copyPermalink` Copy a permalink for the current line to clipboard.
 - `:CocCommand git.refresh` Refresh Git information for all buffers.
+- `:CocCommand git.statusTree` Open files reported by Git status in a TreeView. File nodes show staged and unstaged status; opening a file jumps to its first changed line when Git can determine one.
 - `:CocCommand git.nextChunk` Navigate to the next chunk.
 - `:CocCommand git.prevChunk` Navigate to the previous chunk.
 - `:CocCommand git.chunkInfo` Show chunk info under cursor.
@@ -351,6 +354,21 @@ line with a commit.
 
 Use `git.commitFiles.splitCommand` to configure how the TreeView split opens.
 
+#### Git Status TreeView
+
+Use `:CocCommand git.statusTree` to display staged, unstaged, conflicted, and
+untracked files grouped by directory. Each file shows Git's two-column status
+and a readable staged/unstaged description. Press `<CR>` on a file to open its
+working-tree version in the previous editor window. For tracked files, the
+cursor moves to the first changed line when Git provides a diff location;
+otherwise it opens at line 1. Files deleted from the working tree open the
+read-only `HEAD` version through the `coc-git:` scheme. The root node refreshes
+the status snapshot. File actions follow each file's status: `Add` stages
+unstaged or untracked files, `Restore staged changes` unstages a file, and
+`Restore working tree changes` discards its tracked working-tree changes.
+
+Use `git.statusTree.splitCommand` to configure how the TreeView split opens.
+
 For more advance usage, checkout `:h coc-list`.
 
 ### Issue autocomplete from multiple GitHub repositories

package/history.md

@@ -1,3 +1,8 @@
+## 2.7.11
+
+- add AGENTS.md (34ea156)
+- feat: add git status tree view (4bc3f6e)
+
 ## 2.7.10
 
 - docs: add MIT license (172bdca)
@@ -5,7 +10,6 @@
 
 ## 2.7.9
 
-- add a read-only TreeView for files changed by a commit
 - show complete commit files as decorated coc-git virtual documents with chunk navigation
 - docs: add coc-git logo (992064f)
 - feat: show staged git gutters and navigate chunks (9410092)

package/lib/index.js

@@ -695,8 +695,8 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
-    function checkPathExt(path9, options) {
+    var fs6 = require("fs");
+    function checkPathExt(path10, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
         return true;
@@ -707,25 +707,25 @@ var require_windows = __commonJS({
       }
       for (var i = 0; i < pathext.length; i++) {
         var p = pathext[i].toLowerCase();
-        if (p && path9.substr(-p.length).toLowerCase() === p) {
+        if (p && path10.substr(-p.length).toLowerCase() === p) {
           return true;
         }
       }
       return false;
     }
-    function checkStat(stat, path9, options) {
+    function checkStat(stat, path10, options) {
       if (!stat.isSymbolicLink() && !stat.isFile()) {
         return false;
       }
-      return checkPathExt(path9, options);
+      return checkPathExt(path10, options);
     }
-    function isexe(path9, options, cb) {
-      fs5.stat(path9, function(er, stat) {
-        cb(er, er ? false : checkStat(stat, path9, options));
+    function isexe(path10, options, cb) {
+      fs6.stat(path10, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path10, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs5.statSync(path9), path9, options);
+    function sync(path10, options) {
+      return checkStat(fs6.statSync(path10), path10, options);
     }
   }
 });
@@ -735,14 +735,14 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports2, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs5 = require("fs");
-    function isexe(path9, options, cb) {
-      fs5.stat(path9, function(er, stat) {
+    var fs6 = require("fs");
+    function isexe(path10, options, cb) {
+      fs6.stat(path10, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
-    function sync(path9, options) {
-      return checkStat(fs5.statSync(path9), options);
+    function sync(path10, options) {
+      return checkStat(fs6.statSync(path10), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -766,7 +766,7 @@ var require_mode = __commonJS({
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports2, module2) {
-    var fs5 = require("fs");
+    var fs6 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -775,7 +775,7 @@ var require_isexe = __commonJS({
     }
     module2.exports = isexe;
     isexe.sync = sync;
-    function isexe(path9, options, cb) {
+    function isexe(path10, options, cb) {
       if (typeof options === "function") {
         cb = options;
         options = {};
@@ -785,7 +785,7 @@ var require_isexe = __commonJS({
           throw new TypeError("callback not provided");
         }
         return new Promise(function(resolve, reject) {
-          isexe(path9, options || {}, function(er, is) {
+          isexe(path10, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
@@ -794,7 +794,7 @@ var require_isexe = __commonJS({
           });
         });
       }
-      core(path9, options || {}, function(er, is) {
+      core(path10, options || {}, function(er, is) {
         if (er) {
           if (er.code === "EACCES" || options && options.ignoreErrors) {
             er = null;
@@ -804,9 +804,9 @@ var require_isexe = __commonJS({
         cb(er, is);
       });
     }
-    function sync(path9, options) {
+    function sync(path10, options) {
       try {
-        return core.sync(path9, options || {});
+        return core.sync(path10, options || {});
       } catch (er) {
         if (options && options.ignoreErrors || er.code === "EACCES") {
           return false;
@@ -822,7 +822,7 @@ var require_isexe = __commonJS({
 var require_which = __commonJS({
   "node_modules/which/which.js"(exports2, module2) {
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path9 = require("path");
+    var path10 = require("path");
     var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
@@ -860,7 +860,7 @@ var require_which = __commonJS({
           return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path9.join(pathPart, cmd);
+        const pCmd = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         resolve(subStep(p, i, 0));
       });
@@ -887,7 +887,7 @@ var require_which = __commonJS({
       for (let i = 0; i < pathEnv.length; i++) {
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path9.join(pathPart, cmd);
+        const pCmd = path10.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
         for (let j = 0; j < pathExt.length; j++) {
           const cur = p + pathExt[j];
@@ -4537,7 +4537,7 @@ __export(index_exports, {
   formatBlameText: () => formatBlameText
 });
 module.exports = __toCommonJS(index_exports);
-var import_coc18 = require("coc.nvim");
+var import_coc19 = require("coc.nvim");
 
 // src/constants.ts
 var DEFAULT_TYPES = [
@@ -4673,12 +4673,12 @@ var Bcommits = class extends import_coc.BasicList {
     }, { tabPersist: true });
     this.addAction("view", async (item, context) => {
       let { commit, root, file } = item.data;
-      let { window: window12 } = context;
+      let { window: window13 } = context;
       let content = (await this.manager.git.exec(root, ["show", `${commit}:${file}`])).stdout;
       let lines = content.replace(/\n$/, "").split("\n");
       let name = await nvim.call("fnameescape", [`(${commit}) ${file}`]);
       nvim.pauseNotification();
-      nvim.call("win_gotoid", [window12.id], true);
+      nvim.call("win_gotoid", [window13.id], true);
       nvim.command(`tabe ${name}`, true);
       nvim.call("append", [0, lines], true);
       nvim.command("normal! Gdd", true);
@@ -5169,6 +5169,21 @@ var import_safe2 = __toESM(require_safe());
 var import_fs = __toESM(require("fs"));
 var import_path3 = __toESM(require("path"));
 
+// src/model/statusEntry.ts
+function parseStatusEntries(output) {
+  const result = [];
+  const entries = output.split("\0");
+  for (let i = 0; i < entries.length; i++) {
+    const line = entries[i];
+    if (!line) continue;
+    result.push({ index: line[0], tree: line[1], relative: line.slice(3) });
+    if (line[0] === "R" || line[0] === "C" || line[1] === "R" || line[1] === "C") {
+      i++;
+    }
+  }
+  return result;
+}
+
 // src/util.ts
 var import_child_process = require("child_process");
 var import_coc5 = require("coc.nvim");
@@ -5335,20 +5350,20 @@ function findSystemGitWin32(base, onLookup) {
   return findSpecificGit(import_path2.default.join(base, "Git", "cmd", "git.exe"), onLookup);
 }
 function findGitWin32InPath(onLookup) {
-  const whichPromise = new Promise((c, e) => (0, import_which.default)("git.exe", (err, path9) => err ? e(err) : c(path9)));
-  return whichPromise.then((path9) => findSpecificGit(path9, onLookup));
+  const whichPromise = new Promise((c, e) => (0, import_which.default)("git.exe", (err, path10) => err ? e(err) : c(path10)));
+  return whichPromise.then((path10) => findSpecificGit(path10, onLookup));
 }
 function findGitWin32(onLookup) {
   return findSystemGitWin32(process.env["ProgramW6432"], onLookup).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles(x86)"], onLookup)).then(void 0, () => findSystemGitWin32(process.env["ProgramFiles"], onLookup)).then(void 0, () => findSystemGitWin32(import_path2.default.join(process.env["LocalAppData"], "Programs"), onLookup)).then(void 0, () => findGitWin32InPath(onLookup));
 }
-function findSpecificGit(path9, onLookup) {
+function findSpecificGit(path10, onLookup) {
   return new Promise((c, e) => {
-    onLookup(path9);
+    onLookup(path10);
     const buffers = [];
-    const child = (0, import_child_process.spawn)(path9, ["--version"]);
+    const child = (0, import_child_process.spawn)(path10, ["--version"]);
     child.stdout.on("data", (b) => buffers.push(b));
     child.on("error", cpErrorHandler(e));
-    child.on("exit", (code) => code ? e(new Error("Not found")) : c({ path: path9, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
+    child.on("exit", (code) => code ? e(new Error("Not found")) : c({ path: path10, version: parseVersion(Buffer.concat(buffers).toString("utf8").trim()) }));
   });
 }
 function cpErrorHandler(cb) {
@@ -5365,9 +5380,9 @@ function findGitDarwin(onLookup) {
       if (err) {
         return e("git not found");
       }
-      const path9 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
-      if (path9 !== "/usr/bin/git") {
-        findSpecificGit(path9, onLookup).then(c, e);
+      const path10 = gitPathBuffer.toString().replace(/^\s+|\s+$/g, "");
+      if (path10 !== "/usr/bin/git") {
+        findSpecificGit(path10, onLookup).then(c, e);
         return;
       }
       (0, import_child_process.exec)("xcode-select -p", (err2) => {
@@ -5375,7 +5390,7 @@ function findGitDarwin(onLookup) {
           e("git not found");
           return;
         }
-        findSpecificGit(path9, onLookup).then(c, e);
+        findSpecificGit(path10, onLookup).then(c, e);
       });
     });
   });
@@ -5416,19 +5431,6 @@ var STATUS_MAP = {
   "?": import_safe2.default.gray("?"),
   "!": import_safe2.default.gray("!")
 };
-function parseStatusEntries(output) {
-  let result = [];
-  let entries = output.split("\0");
-  for (let i = 0; i < entries.length; i++) {
-    let line = entries[i];
-    if (!line) continue;
-    result.push({ index: line[0], tree: line[1], relative: line.slice(3) });
-    if (line[0] === "R" || line[0] === "C" || line[1] === "R" || line[1] === "C") {
-      i++;
-    }
-  }
-  return result;
-}
 var GStatus = class extends import_coc6.BasicList {
   constructor(nvim, manager) {
     super();
@@ -6136,8 +6138,10 @@ var DocumentManager = class {
       import_coc10.window.showWarningMessage(`not belongs to git repository.`);
       return null;
     }
-    let repo = this.service.getRepoFromRoot(root);
-    return repo.getDiffAll(category);
+    return this.getDiffAllForRoot(root, category);
+  }
+  async getDiffAllForRoot(root, category) {
+    return this.service.getRepoFromRoot(root).getDiffAll(category);
   }
   dispose() {
     (0, import_coc10.disposeAll)(this.disposables);
@@ -6180,13 +6184,13 @@ function parseNameStatus(output) {
     }
     if (status === "R" || status === "C") {
       const oldPath = fields[index++];
-      const path9 = fields[index++];
-      if (!oldPath || !path9) throw parserError("name-status", "missing rename/copy path");
-      result.push({ status, score, oldPath, path: path9 });
+      const path10 = fields[index++];
+      if (!oldPath || !path10) throw parserError("name-status", "missing rename/copy path");
+      result.push({ status, score, oldPath, path: path10 });
     } else {
-      const path9 = fields[index++];
-      if (!path9) throw parserError("name-status", "missing path");
-      result.push({ status, path: path9 });
+      const path10 = fields[index++];
+      if (!path10) throw parserError("name-status", "missing path");
+      result.push({ status, path: path10 });
     }
   }
   return result;
@@ -6205,7 +6209,7 @@ function parseNumstat(output) {
     }
     const additionsText = record.slice(0, firstTab);
     const deletionsText = record.slice(firstTab + 1, secondTab);
-    const path9 = record.slice(secondTab + 1);
+    const path10 = record.slice(secondTab + 1);
     const binary = additionsText === "-" || deletionsText === "-";
     if (binary && (additionsText !== "-" || deletionsText !== "-")) {
       throw parserError("numstat", "only binary records may contain -");
@@ -6213,9 +6217,9 @@ function parseNumstat(output) {
     if (!binary && (!/^\d+$/.test(additionsText) || !/^\d+$/.test(deletionsText))) {
       throw parserError("numstat", `invalid line counts in ${JSON.stringify(record)}`);
     }
-    if (path9) {
+    if (path10) {
       result.push({
-        path: path9,
+        path: path10,
         additions: binary ? void 0 : Number(additionsText),
         deletions: binary ? void 0 : Number(deletionsText),
         binary
@@ -6380,9 +6384,12 @@ function patchArguments(comparison, change) {
   return args;
 }
 function commitUri(comparison, relativePath) {
+  return revisionUri(comparison.commit.sha, relativePath);
+}
+function revisionUri(revision, relativePath) {
   return import_coc11.Uri.from({
     scheme: COMMIT_DOCUMENT_SCHEME,
-    authority: comparison.commit.sha,
+    authority: revision,
     path: `/${relativePath}`
   });
 }
@@ -6409,7 +6416,27 @@ var CommitDocumentProvider = class {
   }
   async open(root, comparison, change, targetWinId, line) {
     const uri = commitUri(comparison, change.path);
-    const resource = { uri, root, comparison, change };
+    const resource = { kind: "comparison", uri, root, comparison, change };
+    await this.openResource(resource, targetWinId, line);
+  }
+  async openRevision(root, revision, relativePath, targetWinId, line) {
+    const result = await this.git.exec(root, ["rev-parse", "--verify", "--end-of-options", `${revision}^{commit}`]);
+    const sha = result.stdout.trim();
+    if (!sha) throw new Error(`Invalid Git revision: ${revision}`);
+    const object = `${sha}:${relativePath}`;
+    const type = (await this.git.exec(root, ["cat-file", "-t", object])).stdout.trim();
+    if (type !== "blob") throw new Error(`Git path is not a file: ${relativePath}`);
+    const resource = {
+      kind: "revision",
+      uri: revisionUri(sha, relativePath),
+      root,
+      revision: sha,
+      relativePath
+    };
+    await this.openResource(resource, targetWinId, line);
+  }
+  async openResource(resource, targetWinId, line) {
+    const { uri } = resource;
     this.resources.set(uri.toString(), resource);
     const moved = await import_coc11.workspace.nvim.call("win_gotoid", [targetWinId]);
     if (!moved) await import_coc11.workspace.nvim.command("new");
@@ -6430,6 +6457,14 @@ var CommitDocumentProvider = class {
   async load(resource, token) {
     if (resource.content !== void 0 && resource.hunks) return;
     const options = token ? { cancellationToken: token } : void 0;
+    if (resource.kind === "revision") {
+      const object2 = `${resource.revision}:${resource.relativePath}`;
+      const content2 = await this.git.exec(resource.root, ["cat-file", "-p", object2], options);
+      if (token == null ? void 0 : token.isCancellationRequested) return;
+      resource.content = content2.stdout.replace(/\r?\n$/, "");
+      resource.hunks = [];
+      return;
+    }
     const object = `${resource.comparison.commit.sha}:${resource.change.path}`;
     const [content, patch] = await Promise.all([
       this.git.exec(resource.root, ["cat-file", "-p", object], options),
@@ -9328,156 +9363,552 @@ var CommitFilesController = class {
   }
 };
 
+// src/tree/statusFiles.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path9 = __toESM(require("path"));
+var import_coc18 = require("coc.nvim");
+function emptyAggregate2() {
+  return { fileCount: 0, stagedCount: 0, unstagedCount: 0, untrackedCount: 0, conflictCount: 0 };
+}
+function isUntracked(entry) {
+  return entry.index === "?" && entry.tree === "?";
+}
+function isConflict(entry) {
+  return entry.index === "U" || entry.tree === "U" || entry.index + entry.tree === "AA" || entry.index + entry.tree === "DD";
+}
+function isStaged(entry) {
+  return entry.index !== " " && entry.index !== "?" && entry.index !== "!";
+}
+function isUnstaged(entry) {
+  return entry.tree !== " " && entry.tree !== "?" && entry.tree !== "!";
+}
+function addFileAggregate2(target, entry) {
+  target.fileCount++;
+  if (isStaged(entry)) target.stagedCount++;
+  if (isUnstaged(entry)) target.unstagedCount++;
+  if (isUntracked(entry)) target.untrackedCount++;
+  if (isConflict(entry)) target.conflictCount++;
+}
+function addAggregate2(target, source) {
+  target.fileCount += source.fileCount;
+  target.stagedCount += source.stagedCount;
+  target.unstagedCount += source.unstagedCount;
+  target.untrackedCount += source.untrackedCount;
+  target.conflictCount += source.conflictCount;
+}
+function compareNodes2(left, right) {
+  if (left.kind === "directory" && right.kind !== "directory") return -1;
+  if (left.kind !== "directory" && right.kind === "directory") return 1;
+  return left.relativePath.localeCompare(right.relativePath);
+}
+function buildStatusTree(rootPath, entries) {
+  const root = {
+    ...emptyAggregate2(),
+    kind: "root",
+    id: `${rootPath}\0root`,
+    name: import_path9.default.basename(rootPath) || rootPath,
+    relativePath: "",
+    parent: void 0,
+    root: rootPath,
+    children: []
+  };
+  const directories = /* @__PURE__ */ new Map();
+  const ensureDirectory = (segments) => {
+    if (!segments.length) return root;
+    const relativePath = segments.join("/");
+    const existing = directories.get(relativePath);
+    if (existing) return existing;
+    const parent = ensureDirectory(segments.slice(0, -1));
+    const directory = {
+      ...emptyAggregate2(),
+      kind: "directory",
+      id: `${rootPath}\0directory\0${relativePath}`,
+      name: segments[segments.length - 1],
+      relativePath,
+      parent,
+      children: []
+    };
+    directories.set(relativePath, directory);
+    parent.children.push(directory);
+    return directory;
+  };
+  for (const entry of entries) {
+    const segments = entry.relative.split("/");
+    const name = segments.pop();
+    if (!name) continue;
+    const parent = ensureDirectory(segments);
+    parent.children.push({
+      kind: "file",
+      id: `${rootPath}\0file\0${entry.relative}`,
+      name,
+      relativePath: entry.relative,
+      parent,
+      entry
+    });
+  }
+  const aggregate = (node) => {
+    const own = emptyAggregate2();
+    for (const child of node.children) {
+      if (child.kind === "file") addFileAggregate2(own, child.entry);
+      else {
+        aggregate(child);
+        addAggregate2(own, child);
+      }
+    }
+    Object.assign(node, own);
+    node.children.sort(compareNodes2);
+  };
+  aggregate(root);
+  return root;
+}
+function firstFile(node) {
+  for (const child of node.children) {
+    if (child.kind === "file") return child;
+    const file = firstFile(child);
+    if (file) return file;
+  }
+  return void 0;
+}
+function escapeDisplay2(value) {
+  return value.replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+var STATUS_NAMES = {
+  M: "Modified",
+  A: "Added",
+  D: "Deleted",
+  R: "Renamed",
+  C: "Copied",
+  T: "Type changed",
+  U: "Unmerged"
+};
+function aggregateDescription(value) {
+  const parts = [`${value.fileCount} file${value.fileCount === 1 ? "" : "s"}`];
+  if (value.stagedCount) parts.push(`${value.stagedCount} staged`);
+  if (value.unstagedCount) parts.push(`${value.unstagedCount} unstaged`);
+  if (value.untrackedCount) parts.push(`${value.untrackedCount} untracked`);
+  if (value.conflictCount) parts.push(`${value.conflictCount} conflicted`);
+  return parts.join(" \xB7 ");
+}
+function fileDescription2(entry) {
+  var _a, _b;
+  const code = `[${entry.index}${entry.tree}]`;
+  if (isUntracked(entry)) return `${code} \xB7 Untracked`;
+  if (entry.index === "!" && entry.tree === "!") return `${code} \xB7 Ignored`;
+  const parts = [code];
+  if (isStaged(entry)) parts.push(`staged: ${(_a = STATUS_NAMES[entry.index]) != null ? _a : entry.index}`);
+  if (isUnstaged(entry)) parts.push(`unstaged: ${(_b = STATUS_NAMES[entry.tree]) != null ? _b : entry.tree}`);
+  if (isConflict(entry) && !parts.some((part) => part.includes("Unmerged"))) parts.push("conflicted");
+  return parts.join(" \xB7 ");
+}
+function statusIcon2(entry) {
+  if (isConflict(entry)) return { text: "!", hlGroup: "Error" };
+  if (isUntracked(entry)) return { text: "?", hlGroup: "Comment" };
+  const status = entry.tree !== " " ? entry.tree : entry.index;
+  if (status === "A" || status === "C") return { text: "+", hlGroup: "DiffAdd" };
+  if (status === "D") return { text: "-", hlGroup: "DiffDelete" };
+  if (status === "R") return { text: "R", hlGroup: "DiffChange" };
+  return { text: "~", hlGroup: "DiffChange" };
+}
+function toggleCommand(node) {
+  return { command: "git.statusFiles.toggle", title: "Toggle directory", arguments: [node] };
+}
+var StatusFilesProvider = class {
+  constructor(rootPath, entries, actions) {
+    this.actions = actions;
+    this.emitter = new import_coc18.Emitter();
+    this.onDidChangeTreeData = this.emitter.event;
+    this.root = buildStatusTree(rootPath, entries);
+  }
+  setEntries(entries) {
+    this.root = buildStatusTree(this.root.root, entries);
+    this.emitter.fire(void 0);
+  }
+  getTreeItem(element) {
+    if (element.kind === "root") {
+      const item2 = new import_coc18.TreeItem(escapeDisplay2(element.name), element.children.length ? import_coc18.TreeItemCollapsibleState.Expanded : import_coc18.TreeItemCollapsibleState.None);
+      item2.id = element.id;
+      item2.description = aggregateDescription(element);
+      item2.tooltip = escapeDisplay2(element.root);
+      item2.command = { command: "git.statusFiles.refresh", title: "Refresh Git status" };
+      return item2;
+    }
+    if (element.kind === "directory") {
+      const item2 = new import_coc18.TreeItem(escapeDisplay2(element.name), element.children.length ? import_coc18.TreeItemCollapsibleState.Expanded : import_coc18.TreeItemCollapsibleState.None);
+      item2.id = element.id;
+      item2.description = aggregateDescription(element);
+      item2.tooltip = escapeDisplay2(element.relativePath);
+      item2.command = toggleCommand(element);
+      return item2;
+    }
+    const item = new import_coc18.TreeItem(escapeDisplay2(element.name), import_coc18.TreeItemCollapsibleState.None);
+    item.id = element.id;
+    item.icon = statusIcon2(element.entry);
+    item.description = fileDescription2(element.entry);
+    item.tooltip = `${escapeDisplay2(element.relativePath)}
+${fileDescription2(element.entry)}`;
+    item.command = { command: "git.statusFiles.open", title: "Open file", arguments: [element] };
+    return item;
+  }
+  getChildren(element) {
+    if (!element) return [this.root];
+    return element.kind === "file" ? [] : element.children;
+  }
+  getParent(element) {
+    return element.parent;
+  }
+  resolveActions(_item, element) {
+    if (element.kind === "root") return [{ title: "Refresh", handler: () => this.actions.refresh() }];
+    if (element.kind === "directory") return [{ title: "Copy directory path", handler: (node) => this.actions.copyPath(node) }];
+    const actions = [
+      { title: "Open file", handler: (node) => this.actions.openFile(node) },
+      { title: "Copy relative path", handler: (node) => this.actions.copyPath(node) }
+    ];
+    const entry = element.entry;
+    if (isUntracked(entry) || isUnstaged(entry)) actions.push({ title: "Add", handler: (node) => this.actions.addFile(node) });
+    if (isStaged(entry)) actions.push({ title: "Restore staged changes", handler: (node) => this.actions.restoreStagedFile(node) });
+    if (isUnstaged(entry) && !isUntracked(entry) && !isConflict(entry)) {
+      actions.push({ title: "Restore working tree changes", handler: (node) => this.actions.restoreWorkingTreeFile(node) });
+    }
+    return actions;
+  }
+  dispose() {
+    this.emitter.dispose();
+  }
+};
+var StatusFilesController = class {
+  constructor(manager, commitDocuments) {
+    this.manager = manager;
+    this.commitDocuments = commitDocuments;
+  }
+  async open(requestedRoot) {
+    let root = requestedRoot;
+    if (!root) root = await this.manager.resolveGitRootFromBufferOrCwd(await import_coc18.workspace.nvim.call("bufnr", ["%"]));
+    if (!root) {
+      import_coc18.window.showWarningMessage("Can't resolve git repository for current buffer or cwd.");
+      return;
+    }
+    try {
+      root = await this.manager.git.getRepositoryRoot(root);
+    } catch (_e) {
+      import_coc18.window.showWarningMessage("Can't resolve git repository for current buffer or cwd.");
+      return;
+    }
+    const targetWinId = await import_coc18.workspace.nvim.call("win_getid");
+    this.disposeSession();
+    try {
+      const entries = await this.loadEntries(root);
+      const provider = new StatusFilesProvider(root, entries, this.actions);
+      const view = import_coc18.window.createTreeView("git.statusFiles", {
+        treeDataProvider: provider,
+        enableFilter: true,
+        winfixwidth: true,
+        bufhidden: "wipe",
+        canSelectMany: false,
+        autoWidth: true
+      });
+      view.title = "Git Status";
+      view.description = aggregateDescription(buildStatusTree(root, entries));
+      this.session = { root, provider, view, targetWinId };
+      await view.show(import_coc18.workspace.getConfiguration("git").get("statusTree.splitCommand", "belowright 40vs"));
+      const file = firstFile(provider.getChildren()[0]);
+      if (file) await view.reveal(file, { select: true, focus: true, expand: true });
+      view.onDidChangeVisibility((event) => {
+        var _a;
+        if (!event.visible && ((_a = this.session) == null ? void 0 : _a.view) === view) this.disposeSession();
+      });
+    } catch (e) {
+      this.disposeSession();
+      import_coc18.window.showErrorMessage(`Failed to open Git Status: ${e.message}`);
+    }
+  }
+  async toggle(node) {
+    if (!node || typeof node !== "object") return;
+    const element = node;
+    if (element.kind !== "root" && element.kind !== "directory") return;
+    const configuredKey = import_coc18.workspace.getConfiguration("tree").get("key.toggle", "t");
+    const key = configuredKey.startsWith("<") && configuredKey.endsWith(">") ? `\\${configuredKey}` : configuredKey;
+    const escaped = key.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    await import_coc18.workspace.nvim.call("eval", [`feedkeys("${escaped}", "in")`]);
+  }
+  async refresh() {
+    const session = this.session;
+    if (!session) return;
+    try {
+      const entries = await this.loadEntries(session.root);
+      if (this.session !== session) return;
+      session.provider.setEntries(entries);
+      session.view.description = aggregateDescription(buildStatusTree(session.root, entries));
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to refresh Git Status: ${e.message}`);
+    }
+  }
+  close() {
+    this.disposeSession();
+  }
+  async openFile(node) {
+    var _a, _b, _c;
+    const session = this.session;
+    if (!session) return;
+    const absolute = import_path9.default.resolve(session.root, ...node.relativePath.split("/"));
+    const relative = import_path9.default.relative(session.root, absolute);
+    if (relative.startsWith(`..${import_path9.default.sep}`) || import_path9.default.isAbsolute(relative)) {
+      import_coc18.window.showWarningMessage(`Working tree path is outside repository: ${escapeDisplay2(node.relativePath)}`);
+      return;
+    }
+    let stat;
+    try {
+      stat = await import_fs5.default.promises.stat(absolute);
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ENOTDIR") {
+        import_coc18.window.showErrorMessage(`Failed to inspect working tree path: ${escapeDisplay2(node.relativePath)}`);
+        return;
+      }
+      try {
+        await this.commitDocuments.openRevision(session.root, "HEAD", node.relativePath, session.targetWinId);
+      } catch (_error) {
+        import_coc18.window.showWarningMessage(`File not found in working tree or HEAD: ${escapeDisplay2(node.relativePath)}`);
+      }
+      return;
+    }
+    if (!stat.isFile()) {
+      import_coc18.window.showWarningMessage(`Working tree path is not a file: ${escapeDisplay2(node.relativePath)}`);
+      return;
+    }
+    let line = 1;
+    try {
+      const groups = await this.manager.getDiffAllForRoot(session.root, 0 /* All */);
+      line = Math.max(1, (_c = (_b = (_a = groups.get(node.relativePath)) == null ? void 0 : _a[0]) == null ? void 0 : _b.start) != null ? _c : 1);
+    } catch (_e) {
+    }
+    const moved = await import_coc18.workspace.nvim.call("win_gotoid", [session.targetWinId]);
+    if (!moved) await import_coc18.workspace.nvim.command("new");
+    try {
+      await import_coc18.workspace.jumpTo(import_coc18.Uri.file(absolute), import_coc18.Position.create(line - 1, 0));
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to open working tree file: ${e.message}`);
+    }
+  }
+  async addFile(node) {
+    await this.updateFile(node, ["add", "--", node.relativePath]);
+  }
+  async restoreStagedFile(node) {
+    await this.updateFile(node, ["reset", "--", node.relativePath]);
+  }
+  async restoreWorkingTreeFile(node) {
+    await this.updateFile(node, ["checkout", "--", node.relativePath]);
+  }
+  get actions() {
+    return {
+      refresh: () => this.refresh(),
+      openFile: (node) => this.openFile(node),
+      addFile: (node) => this.addFile(node),
+      restoreStagedFile: (node) => this.restoreStagedFile(node),
+      restoreWorkingTreeFile: (node) => this.restoreWorkingTreeFile(node),
+      copyPath: (node) => import_coc18.workspace.nvim.call("setreg", ["+", node.relativePath]).then(() => void 0)
+    };
+  }
+  async updateFile(node, args) {
+    const session = this.session;
+    if (!session) return;
+    try {
+      await this.manager.git.exec(session.root, args);
+      await this.refresh();
+    } catch (e) {
+      import_coc18.window.showErrorMessage(`Failed to update Git status for ${escapeDisplay2(node.relativePath)}: ${e.message}`);
+    }
+  }
+  async loadEntries(root) {
+    const result = await this.manager.git.exec(root, ["status", "--porcelain=v1", "-z", "-uall"]);
+    return parseStatusEntries(result.stdout);
+  }
+  disposeSession() {
+    const session = this.session;
+    if (!session) return;
+    this.session = void 0;
+    session.provider.dispose();
+    session.view.dispose();
+  }
+  dispose() {
+    this.close();
+  }
+};
+
 // src/index.ts
 async function activate(context) {
   var _a;
-  const config = import_coc18.workspace.getConfiguration("git");
+  const config = import_coc19.workspace.getConfiguration("git");
   const { subscriptions } = context;
   let gitInfo;
   try {
     let pathHint = config.get("command", "git");
-    gitInfo = await findGit(pathHint, (path9) => context.logger.info(`Looking for git in: ${path9}`));
+    gitInfo = await findGit(pathHint, (path10) => context.logger.info(`Looking for git in: ${path10}`));
   } catch (e) {
-    import_coc18.window.showErrorMessage("git command required for coc-git");
+    import_coc19.window.showErrorMessage("git command required for coc-git");
     return;
   }
-  const virtualTextSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-virtual");
-  const conflictSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-conflicts");
-  const commitDocumentSrcId = await import_coc18.workspace.nvim.createNamespace("coc-git-commit-document");
-  const { nvim } = import_coc18.workspace;
+  const virtualTextSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-virtual");
+  const conflictSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-conflicts");
+  const commitDocumentSrcId = await import_coc19.workspace.nvim.createNamespace("coc-git-commit-document");
+  const { nvim } = import_coc19.workspace;
   const service = new GitService(gitInfo);
   const manager = new DocumentManager(nvim, service, virtualTextSrcId, conflictSrcId);
   subscriptions.push(manager);
   const commitDocuments = new CommitDocumentProvider(service.git, commitDocumentSrcId);
   subscriptions.push(commitDocuments);
-  subscriptions.push(import_coc18.workspace.registerTextDocumentContentProvider(COMMIT_DOCUMENT_SCHEME, commitDocuments));
+  subscriptions.push(import_coc19.workspace.registerTextDocumentContentProvider(COMMIT_DOCUMENT_SCHEME, commitDocuments));
   nvim.command("highlight default link CocGitCommitAdd DiffAdd", true);
   nvim.command("highlight default link CocGitCommitDelete DiffDelete", true);
   const commitFiles = new CommitFilesController(manager);
   subscriptions.push(commitFiles);
+  const statusFiles = new StatusFilesController(manager, commitDocuments);
+  subscriptions.push(statusFiles);
   addSource(context, service);
-  subscriptions.push(import_coc18.commands.registerCommand("git.refresh", () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.refresh", () => {
     manager.refresh();
   }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusTree", async () => {
+    await statusFiles.open();
+  }));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.open", async (node) => {
+    await statusFiles.openFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.add", async (node) => {
+    await statusFiles.addFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.restoreStaged", async (node) => {
+    await statusFiles.restoreStagedFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.restoreWorkingTree", async (node) => {
+    await statusFiles.restoreWorkingTreeFile(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.refresh", async () => {
+    await statusFiles.refresh();
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.toggle", async (node) => {
+    await statusFiles.toggle(node);
+  }, void 0, true));
+  subscriptions.push(import_coc19.commands.registerCommand("git.statusFiles.close", () => {
+    statusFiles.close();
+  }, void 0, true));
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-nextchunk", async () => {
     if (!await commitDocuments.nextChunk()) await manager.nextChunk();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-prevchunk", async () => {
     if (!await commitDocuments.prevChunk()) await manager.prevChunk();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-nextconflict", async () => {
     await manager.nextConflict();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-prevconflict", async () => {
     await manager.prevConflict();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepcurrent", async () => {
     await manager.keepCurrent();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepincoming", async () => {
     await manager.keepIncoming();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-keepboth", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-keepboth", async () => {
     await manager.keepBoth();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-chunkinfo", async () => {
     await manager.chunkInfo();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-commit", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-commit", async () => {
     await manager.showCommit();
   }, { sync: false }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["n"], "git-showblamedoc", async () => {
     await manager.showBlameDoc();
   }, { sync: false }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.nextChunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.nextChunk", async () => {
     if (!await commitDocuments.nextChunk()) await manager.nextChunk();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.prevChunk", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.prevChunk", async () => {
     if (!await commitDocuments.prevChunk()) await manager.prevChunk();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepCurrent", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepCurrent", async () => {
     await manager.keepCurrent();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepIncoming", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepIncoming", async () => {
     await manager.keepIncoming();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.keepBoth", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.keepBoth", async () => {
     await manager.keepBoth();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkInfo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkInfo", async () => {
     await manager.chunkInfo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.allChunkInfo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.allChunkInfo", async () => {
     return await manager.allChunkInfo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkStage", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkStage", async () => {
     await manager.chunkStage();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkUnstage", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkUnstage", async () => {
     await manager.chunkUnstage();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.chunkUndo", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.chunkUndo", async () => {
     await manager.chunkUndo();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showCommit", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showCommit", async () => {
     await manager.showCommit();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.open", async (revision, root) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.open", async (revision, root) => {
     await commitFiles.open(revision, root);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showCommitTree", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showCommitTree", async () => {
     const current = await manager.getCurrentCommit();
     if (current) await commitFiles.open(current.sha, current.root, { showCurrentFile: true, line: current.line });
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.invoke", async (node) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.invoke", async (node) => {
     await commitFiles.invoke(node);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.toggle", async (node) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.toggle", async (node) => {
     await commitFiles.toggle(node);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.commitFiles.openDocument", async (root, comparison, change, targetWinId, line) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.commitFiles.openDocument", async (root, comparison, change, targetWinId, line) => {
     targetWinId = targetWinId != null ? targetWinId : await nvim.call("win_getid");
     await commitDocuments.open(root, comparison, change, targetWinId, line);
   }, void 0, true));
-  subscriptions.push(import_coc18.commands.registerCommand("git.browserOpen", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.browserOpen", async () => {
     await manager.browser();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.copyUrl", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.copyUrl", async (...args) => {
     await manager.browser("copy", args);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.copyPermalink", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.copyPermalink", async (...args) => {
     await manager.browser("copy", args, true);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.push", async (...args) => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.push", async (...args) => {
     await manager.push(args);
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.diffCached", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.diffCached", async () => {
     await manager.diffCached();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.toggleGutters", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.toggleGutters", async () => {
     await manager.toggleGutters();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.foldUnchanged", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.foldUnchanged", async () => {
     await manager.toggleFold();
   }));
-  subscriptions.push(import_coc18.commands.registerCommand("git.showBlameDoc", async () => {
+  subscriptions.push(import_coc19.commands.registerCommand("git.showBlameDoc", async () => {
     await manager.showBlameDoc();
   }));
-  subscriptions.push(import_coc18.listManager.registerList(new GStatus(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Branches(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Commits(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Bcommits(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new Gfiles(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new GChunks(nvim, manager)));
-  subscriptions.push(import_coc18.listManager.registerList(new GChanges(nvim, manager)));
-  subscriptions.push(import_coc18.languages.registerCompletionItemProvider("semantic-commit", "Commit", (_a = config.get("semanticCommit.filetypes")) != null ? _a : [], {
+  subscriptions.push(import_coc19.listManager.registerList(new GStatus(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Branches(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Commits(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Bcommits(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new Gfiles(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new GChunks(nvim, manager)));
+  subscriptions.push(import_coc19.listManager.registerList(new GChanges(nvim, manager)));
+  subscriptions.push(import_coc19.languages.registerCompletionItemProvider("semantic-commit", "Commit", (_a = config.get("semanticCommit.filetypes")) != null ? _a : [], {
     provideCompletionItems: async (document, position) => {
       if (position.line !== 0) {
         return [];
       }
       const text = document.getText(
-        import_coc18.Range.create(
-          import_coc18.Position.create(position.line, 0),
+        import_coc19.Range.create(
+          import_coc19.Position.create(position.line, 0),
           position
         )
       );
@@ -9487,10 +9918,10 @@ async function activate(context) {
         return DEFAULT_TYPES.map((o) => {
           return {
             label: o.value,
-            kind: import_coc18.CompletionItemKind.Snippet,
+            kind: import_coc19.CompletionItemKind.Snippet,
             documentation: { kind: "plaintext", value: o.name },
             // detail: o.name,
-            insertTextFormat: import_coc18.InsertTextFormat.Snippet,
+            insertTextFormat: import_coc19.InsertTextFormat.Snippet,
             // tslint:disable-next-line: no-invalid-template-strings
             insertText: o.value + text2 + "\n\n"
           };
@@ -9499,12 +9930,12 @@ async function activate(context) {
       return [];
     }
   }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["o", "x"], "git-chunk-inner", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["o", "x"], "git-chunk-inner", async () => {
     let diff = await manager.getCurrentChunk();
     if (!diff) return;
     await nvim.command(`normal! ${diff.start}GV${diff.end}G`);
   }, { sync: true, silent: true }));
-  subscriptions.push(import_coc18.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
+  subscriptions.push(import_coc19.workspace.registerKeymap(["o", "x"], "git-chunk-outer", async () => {
     let diff = await manager.getCurrentChunk();
     if (!diff) return;
     let total = await nvim.call("line", ["$"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-git",
-  "version": "2.7.10",
+  "version": "2.7.11",
   "description": "Git extension for coc.nvim",
   "main": "lib/index.js",
   "publisher": "chemzqm",
@@ -32,6 +32,10 @@
         "title": "Refresh git information for all buffers.",
         "command": "git.refresh"
       },
+      {
+        "title": "Open changed files from Git status in a TreeView.",
+        "command": "git.statusTree"
+      },
       {
         "title": "Navigate to the next changed chunk.",
         "command": "git.nextChunk"
@@ -420,6 +424,12 @@
           "scope": "application",
           "description": "Command used to open the changed-files TreeView for a commit."
         },
+        "git.statusTree.splitCommand": {
+          "type": "string",
+          "default": "belowright 40vs",
+          "scope": "application",
+          "description": "Command used to open the Git status TreeView."
+        },
         "git.showCommitInFloating": {
           "type": "boolean",
           "default": false,