@statiolake/coc-git 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 statiolake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,6 @@
+# coc-git
+
+Git integration for coc.nvim: buffer signs, hunk actions, current-line blame,
+and a VS Code-style Source Control container with Changes and History views in
+the primary sidebar supplied by `@statiolake/coc-ui`. The Activity Bar switches
+to Source Control, then Changes and History remain mounted as stacked Views.

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+import { ExtensionContext } from "coc.nvim";
+export type GitFile = {
+    root: string;
+    path: string;
+    status: string;
+};
+export type GitCommit = {
+    root: string;
+    hash: string;
+    subject: string;
+    decoration: string;
+};
+export type GitHunk = {
+    header: string;
+    start: number;
+    count: number;
+    oldStart: number;
+    oldCount: number;
+    preamble: string;
+    body: string;
+    patch: string;
+};
+export interface CocGitApi {
+    repositoryRoot(filename?: string): Promise<string | undefined>;
+    changedFiles(root?: string): Promise<GitFile[]>;
+    history(root?: string, filename?: string): Promise<GitCommit[]>;
+    diff(root: string, args: string[]): Promise<string>;
+    showChanges(): Promise<void>;
+    showHistory(): Promise<void>;
+}
+export declare function activate(context: ExtensionContext): Promise<CocGitApi>;

package/lib/index.js

@@ -0,0 +1,524 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  activate: () => activate
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+var import_node_path = __toESM(require("node:path"));
+var import_coc = require("coc.nvim");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var signGroup = "CocGit";
+var GitChangesProvider = class {
+  constructor(git) {
+    this.git = git;
+  }
+  changeEmitter = new import_coc.Emitter();
+  onDidChangeTreeData = this.changeEmitter.event;
+  refresh() {
+    this.changeEmitter.fire();
+  }
+  async getChildren() {
+    return this.git.changedFiles();
+  }
+  getTreeItem(file) {
+    const item = new import_coc.TreeItem(
+      import_coc.Uri.file(import_node_path.default.join(file.root, file.path)),
+      import_coc.TreeItemCollapsibleState.None
+    );
+    item.description = file.status;
+    item.tooltip = `${file.status} ${file.path}`;
+    item.command = {
+      command: "coc-git.openFile",
+      title: "Open",
+      arguments: [file]
+    };
+    return item;
+  }
+};
+var GitHistoryProvider = class {
+  constructor(git) {
+    this.git = git;
+  }
+  changeEmitter = new import_coc.Emitter();
+  onDidChangeTreeData = this.changeEmitter.event;
+  refresh() {
+    this.changeEmitter.fire();
+  }
+  async getChildren() {
+    return this.git.history();
+  }
+  getTreeItem(commit) {
+    const item = new import_coc.TreeItem(`${commit.hash.slice(0, 10)} ${commit.subject}`);
+    item.description = commit.decoration;
+    item.tooltip = `${commit.hash}
+${commit.subject}`;
+    item.command = {
+      command: "coc-git.showCommit",
+      title: "Show Commit",
+      arguments: [commit]
+    };
+    return item;
+  }
+};
+var Git = class {
+  constructor(ui, context) {
+    this.ui = ui;
+    const container = ui.registerViewContainer({
+      id: "git",
+      title: "Source Control",
+      icon: "\uE702",
+      location: "primarySidebar",
+      order: 2
+    });
+    const changesView = ui.registerView({
+      id: "git.changes",
+      containerId: "git",
+      name: "Changes",
+      order: 1
+    });
+    const changesTree = ui.createTreeView("git.changes", {
+      treeDataProvider: this.changes
+    });
+    const historyView = ui.registerView({
+      id: "git.history",
+      containerId: "git",
+      name: "History",
+      order: 2
+    });
+    const historyTree = ui.createTreeView("git.history", {
+      treeDataProvider: this.commits
+    });
+    context.subscriptions.push(
+      container,
+      changesView,
+      changesTree,
+      historyView,
+      historyTree,
+      import_coc.commands.registerCommand("coc-git.showChanges", () => this.showChanges()),
+      import_coc.commands.registerCommand("coc-git.showHistory", () => this.showHistory()),
+      import_coc.commands.registerCommand(
+        "coc-git.refresh",
+        () => this.refreshCurrentDocument()
+      ),
+      import_coc.commands.registerCommand("coc-git.nextHunk", () => this.moveHunk(1)),
+      import_coc.commands.registerCommand("coc-git.prevHunk", () => this.moveHunk(-1)),
+      import_coc.commands.registerCommand(
+        "coc-git.stageHunk",
+        () => this.applyCurrentHunk("stage")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-git.stageSelection",
+        () => this.applySelection("stage")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-git.unstageHunk",
+        () => this.applyCurrentHunk("unstage")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-git.resetHunk",
+        () => this.applyCurrentHunk("reset")
+      ),
+      import_coc.commands.registerCommand(
+        "coc-git.resetSelection",
+        () => this.applySelection("reset")
+      ),
+      import_coc.commands.registerCommand("coc-git.stageBuffer", () => this.stageBuffer()),
+      import_coc.commands.registerCommand("coc-git.resetBuffer", () => this.resetBuffer()),
+      import_coc.commands.registerCommand("coc-git.previewHunk", () => this.previewHunk()),
+      import_coc.commands.registerCommand("coc-git.blameLine", () => this.blameLine()),
+      import_coc.commands.registerCommand("coc-git.toggleBlame", () => this.toggleBlame()),
+      import_coc.commands.registerCommand(
+        "coc-git.openFile",
+        (file) => this.openFile(file)
+      ),
+      import_coc.commands.registerCommand(
+        "coc-git.showCommit",
+        (commit) => this.showCommit(commit)
+      ),
+      import_coc.workspace.onDidOpenTextDocument(
+        (document) => this.scheduleRefresh(document.uri)
+      ),
+      import_coc.workspace.onDidSaveTextDocument(
+        (document) => this.scheduleRefresh(document.uri)
+      ),
+      import_coc.workspace.registerAutocmd({
+        event: "BufEnter",
+        callback: () => this.refreshCurrentDocument()
+      }),
+      import_coc.workspace.registerAutocmd({
+        event: "CursorHold",
+        callback: () => this.refreshBlame()
+      })
+    );
+    void this.defineSigns();
+    void this.refreshCurrentDocument();
+  }
+  changes = new GitChangesProvider(this);
+  commits = new GitHistoryProvider(this);
+  signBuffers = /* @__PURE__ */ new Set();
+  blameBuffers = /* @__PURE__ */ new Set();
+  blameNamespace;
+  refreshTimers = /* @__PURE__ */ new Map();
+  async repositoryRoot(filename) {
+    const target = filename ? import_node_path.default.dirname(filename) : import_coc.workspace.rootPath || import_coc.workspace.cwd;
+    try {
+      return (await this.git(target, ["rev-parse", "--show-toplevel"])).trim();
+    } catch {
+      return void 0;
+    }
+  }
+  async changedFiles(root) {
+    const repository = root ?? await this.repositoryRoot();
+    if (!repository) return [];
+    const output = await this.git(repository, [
+      "status",
+      "--porcelain=v1",
+      "-u"
+    ]);
+    return output.split("\n").filter(Boolean).map((line) => ({
+      root: repository,
+      status: line.slice(0, 2),
+      path: line.slice(3).split(" -> ").at(-1)
+    }));
+  }
+  async history(root, filename) {
+    const repository = root ?? await this.repositoryRoot(filename);
+    if (!repository) return [];
+    const maxEntries = Math.max(
+      1,
+      import_coc.workspace.getConfiguration("coc-git").get("history.maxEntries", 100)
+    );
+    const args = [
+      "log",
+      `--max-count=${maxEntries}`,
+      "--format=%H%x1f%D%x1f%s"
+    ];
+    if (filename) args.push("--", import_node_path.default.relative(repository, filename));
+    const output = await this.git(repository, args);
+    return output.split("\n").filter(Boolean).map((line) => {
+      const [hash, decoration, subject] = line.split("");
+      return { root: repository, hash, decoration, subject };
+    });
+  }
+  async diff(root, args) {
+    return this.git(root, args);
+  }
+  async showChanges() {
+    this.changes.refresh();
+    await this.ui.showView("git.changes");
+  }
+  async showHistory() {
+    this.commits.refresh();
+    await this.ui.showView("git.history");
+  }
+  dispose() {
+    for (const timer of this.refreshTimers.values()) clearTimeout(timer);
+    this.refreshTimers.clear();
+  }
+  async refreshCurrentDocument() {
+    const document = await import_coc.workspace.document;
+    await this.refreshDocument(document.textDocument.uri);
+  }
+  scheduleRefresh(uri) {
+    const existing = this.refreshTimers.get(uri);
+    if (existing) clearTimeout(existing);
+    this.refreshTimers.set(
+      uri,
+      setTimeout(() => void this.refreshDocument(uri), 120)
+    );
+  }
+  async refreshDocument(uri) {
+    if (!import_coc.workspace.getConfiguration("coc-git").get("enable", true))
+      return;
+    const document = import_coc.workspace.getDocument(uri);
+    const resource = document && import_coc.Uri.parse(document.textDocument.uri);
+    if (!document || !resource || resource.scheme !== "file") return;
+    const filename = resource.fsPath;
+    const root = await this.repositoryRoot(filename);
+    if (!root) return;
+    const hunks = await this.hunks(root, filename);
+    document.buffer.unplaceSign({ group: signGroup });
+    this.signBuffers.add(document.bufnr);
+    for (const [index, hunk] of hunks.entries()) {
+      document.buffer.placeSign({
+        id: index + 1,
+        group: signGroup,
+        name: signName(hunk),
+        lnum: Math.max(1, hunk.start),
+        priority: 10
+      });
+    }
+    this.changes.refresh();
+    this.commits.refresh();
+  }
+  async hunks(root, filename, cached = false) {
+    const relative = import_node_path.default.relative(root, filename);
+    const args = ["diff", "--no-ext-diff", "--unified=0"];
+    if (cached) args.push("--cached");
+    args.push("--", relative);
+    return parseHunks(await this.git(root, args));
+  }
+  async moveHunk(direction) {
+    const state = await this.currentState();
+    if (!state) return;
+    const line = await import_coc.workspace.nvim.call("line", ["."]);
+    const hunks = await this.hunks(state.root, state.filename);
+    if (!hunks.length) return;
+    const target = direction > 0 ? hunks.find((hunk) => hunk.start > line) ?? hunks[0] : [...hunks].reverse().find((hunk) => hunk.start < line) ?? hunks.at(-1);
+    await import_coc.workspace.nvim.call("cursor", [target.start, 0]);
+  }
+  async applyCurrentHunk(action) {
+    const state = await this.currentState();
+    if (!state) return;
+    const cached = action === "unstage";
+    const hunk = await this.currentHunk(state.root, state.filename, cached);
+    if (!hunk) return;
+    await this.applyHunks(action, state, [hunk]);
+  }
+  async applySelection(action) {
+    const state = await this.currentState();
+    if (!state) return;
+    const start = await import_coc.workspace.nvim.call("line", ["'<"]);
+    const end = await import_coc.workspace.nvim.call("line", ["'>"]);
+    const hunks = (await this.hunks(state.root, state.filename)).filter(
+      (hunk) => {
+        const hunkEnd = hunk.start + Math.max(1, hunk.count) - 1;
+        return hunk.start <= end && hunkEnd >= start;
+      }
+    );
+    if (!hunks.length) return;
+    await this.applyHunks(action, state, hunks);
+  }
+  async applyHunks(action, state, hunks) {
+    const args = ["apply", "--unidiff-zero"];
+    if (action === "stage" || action === "unstage") args.push("--cached");
+    if (action === "unstage" || action === "reset") args.push("--reverse");
+    await this.gitInput(
+      state.root,
+      args,
+      hunks[0].preamble + hunks.map((hunk) => hunk.body).join("")
+    );
+    await this.refreshDocument(state.uri);
+  }
+  async stageBuffer() {
+    const state = await this.currentState();
+    if (!state) return;
+    await this.git(state.root, [
+      "add",
+      "--",
+      import_node_path.default.relative(state.root, state.filename)
+    ]);
+    await this.refreshDocument(state.uri);
+  }
+  async resetBuffer() {
+    const state = await this.currentState();
+    if (!state) return;
+    const answer = await import_coc.window.showWarningMessage(
+      "Discard all unstaged changes in this file?",
+      "Discard"
+    );
+    if (answer !== "Discard") return;
+    await this.git(state.root, [
+      "restore",
+      "--worktree",
+      "--",
+      import_node_path.default.relative(state.root, state.filename)
+    ]);
+    await import_coc.workspace.nvim.command(`edit ${fnameescape(state.filename)}`);
+    await this.refreshDocument(state.uri);
+  }
+  async previewHunk() {
+    const state = await this.currentState();
+    if (!state) return;
+    const hunk = await this.currentHunk(state.root, state.filename);
+    if (!hunk) return;
+    const output = import_coc.window.createOutputChannel("Coc Git Hunk");
+    output.clear();
+    output.append(hunk.patch);
+    output.show(false);
+  }
+  async blameLine() {
+    const state = await this.currentState();
+    if (!state) return void 0;
+    const line = await import_coc.workspace.nvim.call("line", ["."]);
+    const relative = import_node_path.default.relative(state.root, state.filename);
+    const output = await this.git(state.root, [
+      "blame",
+      "--porcelain",
+      "-L",
+      `${line},${line}`,
+      "--",
+      relative
+    ]);
+    const summary = output.match(/^summary (.+)$/m)?.[1] ?? "";
+    const author = output.match(/^author (.+)$/m)?.[1] ?? "";
+    const hash = output.match(/^([0-9a-f]{40})/)?.[1]?.slice(0, 10) ?? "";
+    const message = [hash, author, summary].filter(Boolean).join(" ");
+    if (message) await import_coc.window.showInformationMessage(message);
+    return message;
+  }
+  async toggleBlame() {
+    const document = await import_coc.workspace.document;
+    const buffer = document.bufnr;
+    if (this.blameBuffers.delete(buffer)) {
+      if (this.blameNamespace != null)
+        document.buffer.clearNamespace(this.blameNamespace);
+      return;
+    }
+    this.blameBuffers.add(buffer);
+    if (this.blameNamespace == null)
+      this.blameNamespace = await import_coc.workspace.nvim.createNamespace("coc-git-blame");
+    await this.refreshBlame();
+  }
+  async refreshBlame() {
+    const document = await import_coc.workspace.document;
+    if (!this.blameBuffers.has(document.bufnr)) return;
+    const text = await this.blameLine();
+    if (!text || this.blameNamespace == null) return;
+    const position = await import_coc.window.getCursorPosition();
+    document.buffer.clearNamespace(this.blameNamespace);
+    document.buffer.setExtMark(this.blameNamespace, position.line, 0, {
+      virt_text: [[` ${text}`, "CocGitBlame"]],
+      virt_text_pos: "eol"
+    });
+  }
+  async openFile(file) {
+    await this.ui.openLocation(
+      import_coc.Uri.file(import_node_path.default.join(file.root, file.path)).toString(),
+      0,
+      0
+    );
+  }
+  async showCommit(commit) {
+    await import_coc.commands.executeCommand(
+      "coc-diffview.showCommit",
+      commit.root,
+      commit.hash
+    );
+  }
+  async currentHunk(root, filename, cached = false) {
+    const line = await import_coc.workspace.nvim.call("line", ["."]);
+    const hunks = await this.hunks(root, filename, cached);
+    return hunks.find(
+      (hunk) => line >= hunk.start && line < hunk.start + Math.max(1, hunk.count)
+    );
+  }
+  async currentState() {
+    const document = await import_coc.workspace.document;
+    const resource = import_coc.Uri.parse(document.textDocument.uri);
+    if (resource.scheme !== "file") return void 0;
+    const filename = resource.fsPath;
+    const root = await this.repositoryRoot(filename);
+    return root ? { uri: document.textDocument.uri, filename, root } : void 0;
+  }
+  async defineSigns() {
+    const config = import_coc.workspace.getConfiguration();
+    const added = config.get("vimrc.core.signs.diff.added", "+");
+    const changed = config.get("vimrc.core.signs.diff.changed", "~");
+    const removed = config.get("vimrc.core.signs.diff.removed", "_");
+    await import_coc.workspace.nvim.command(
+      `sign define CocGitAdd text=${added} texthl=DiffAdd`
+    );
+    await import_coc.workspace.nvim.command(
+      `sign define CocGitChange text=${changed} texthl=DiffChange`
+    );
+    await import_coc.workspace.nvim.command(
+      `sign define CocGitDelete text=${removed} texthl=DiffDelete`
+    );
+    await import_coc.workspace.nvim.command("highlight default link CocGitBlame Comment");
+  }
+  async git(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, {
+      cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout;
+  }
+  async gitInput(cwd, args, input) {
+    await new Promise((resolve, reject) => {
+      const child = (0, import_node_child_process.spawn)("git", args, {
+        cwd,
+        stdio: ["pipe", "ignore", "pipe"]
+      });
+      let stderr = "";
+      child.stderr.on("data", (chunk) => {
+        stderr += String(chunk);
+      });
+      child.on("error", reject);
+      child.on(
+        "close",
+        (code) => code === 0 ? resolve() : reject(new Error(stderr || `git exited with ${code}`))
+      );
+      child.stdin.end(input);
+    });
+  }
+};
+function parseHunks(diff) {
+  const matches = [
+    ...diff.matchAll(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@.*$/gm)
+  ];
+  if (!matches.length) return [];
+  const prefix = diff.slice(0, matches[0].index);
+  return matches.map((match, index) => ({
+    header: match[0],
+    oldStart: Number(match[1]),
+    oldCount: Number(match[2] ?? 1),
+    start: Number(match[3]),
+    count: Number(match[4] ?? 1),
+    preamble: prefix,
+    body: diff.slice(match.index, matches[index + 1]?.index),
+    patch: prefix + diff.slice(match.index, matches[index + 1]?.index)
+  }));
+}
+function signName(hunk) {
+  if (hunk.oldCount === 0) return "CocGitAdd";
+  if (hunk.count === 0) return "CocGitDelete";
+  return "CocGitChange";
+}
+function fnameescape(filename) {
+  return filename.replace(/([\\\s|"'])/g, "\\$1");
+}
+async function activate(context) {
+  const extension = import_coc.extensions.getExtensionById("@statiolake/coc-ui");
+  if (!extension?.exports)
+    throw new Error("@statiolake/coc-ui must be activated before coc-git");
+  const git = new Git(extension.exports, context);
+  context.subscriptions.push(git);
+  return git;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "@statiolake/coc-git",
+  "version": "0.1.0",
+  "description": "Git signs, hunk actions, and source control views for coc.nvim",
+  "author": "statiolake",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "engines": {
+    "coc": "^0.0.82"
+  },
+  "extensionDependencies": [
+    "@statiolake/coc-ui"
+  ],
+  "activationEvents": [
+    "*"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && node esbuild.mjs",
+    "prepare": "node esbuild.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "contributes": {
+    "commands": [
+      {
+        "command": "coc-git.showChanges",
+        "title": "Show Source Control Changes"
+      },
+      {
+        "command": "coc-git.showHistory",
+        "title": "Show Git History"
+      },
+      {
+        "command": "coc-git.refresh",
+        "title": "Refresh Git Decorations"
+      },
+      {
+        "command": "coc-git.nextHunk",
+        "title": "Go to Next Git Hunk"
+      },
+      {
+        "command": "coc-git.prevHunk",
+        "title": "Go to Previous Git Hunk"
+      },
+      {
+        "command": "coc-git.stageHunk",
+        "title": "Stage Git Hunk"
+      },
+      {
+        "command": "coc-git.stageSelection",
+        "title": "Stage Selected Git Hunks"
+      },
+      {
+        "command": "coc-git.unstageHunk",
+        "title": "Unstage Git Hunk"
+      },
+      {
+        "command": "coc-git.resetHunk",
+        "title": "Discard Git Hunk"
+      },
+      {
+        "command": "coc-git.resetSelection",
+        "title": "Discard Selected Git Hunks"
+      },
+      {
+        "command": "coc-git.stageBuffer",
+        "title": "Stage Current Buffer"
+      },
+      {
+        "command": "coc-git.resetBuffer",
+        "title": "Discard Current Buffer Changes"
+      },
+      {
+        "command": "coc-git.previewHunk",
+        "title": "Preview Git Hunk"
+      },
+      {
+        "command": "coc-git.blameLine",
+        "title": "Show Git Blame for Current Line"
+      },
+      {
+        "command": "coc-git.toggleBlame",
+        "title": "Toggle Current Line Git Blame"
+      },
+      {
+        "command": "coc-git.openFile",
+        "title": "Open Changed File"
+      },
+      {
+        "command": "coc-git.showCommit",
+        "title": "Show Commit"
+      }
+    ],
+    "configuration": {
+      "type": "object",
+      "title": "Coc Git",
+      "properties": {
+        "coc-git.enable": {
+          "type": "boolean",
+          "default": true
+        },
+        "coc-git.history.maxEntries": {
+          "type": "number",
+          "default": 100,
+          "minimum": 1
+        }
+      }
+    }
+  },
+  "devDependencies": {
+    "@statiolake/coc-ui": "git+https://github.com/statiolake/coc-ui.git",
+    "@types/node": "^16.18.0",
+    "coc.nvim": "^0.0.83-next.24",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.3.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/statiolake/coc-git.git"
+  },
+  "bugs": {
+    "url": "https://github.com/statiolake/coc-git/issues"
+  },
+  "homepage": "https://github.com/statiolake/coc-git#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/index.d.ts"
+  ]
+}