coc-vscode-loader 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# coc-vscode-loader
+
+VS Code extension → coc.nvim plugin loader with TUI package manager.
+
+Install/update/uninstall converted VS Code extensions via a floating terminal UI.
+
+## Install
+
+```bash
+cd ~/.config/coc/extensions
+npm install /path/to/coc-vscode-loader
+# or :CocInstall /path/to/coc-vscode-loader
+```
+
+## TUI Keymaps
+
+| Key | Action |
+|-----|--------|
+| `I` | Install mode (button highlight) |
+| `U` | Update all installed packages |
+| `C` | Check for remote updates (git ls-remote commit compare) |
+| `Z` | Uninstall all installed packages (with confirmation) |
+| `H` | Home (reset all state) |
+| `?` | Help |
+| `i` | Install package under cursor |
+| `u` | Update package under cursor |
+| `X` / `x` | Uninstall package under cursor |
+| `<CR>` | Toggle details (commit / type / source) or install log |
+| `/` | Search filter |
+| `q` / `<Esc>` | Close (auto `:CocRestart` if changes detected) |
+
+## Commands
+
+| Command | Action |
+|---------|--------|
+| `:CocCommand loader.open` | Open TUI |
+| `:CocCommand loader.install <name>` | Install a package |
+| `:CocCommand loader.uninstall <name>` | Uninstall a package |
+| `:CocCommand loader.update <name>` | Update a package |
+| `:CocCommand loader.uninstallAll` | Uninstall all (with confirmation) |
+| `:CocCommand loader.updateRegistry` | Fetch latest registry from remote |
+
+## Features
+
+- **Real conversion pipeline** — git clone → converter → npm install → esbuild → register to coc
+- **Incremental cache** — source/ keeps git repo, updates via git pull only
+- **Commit tracking** — records commit SHA after install, visible in detail view
+- **Update check** — `C` key compares against remote HEAD, shows `↑` when outdated
+- **Auto restart** — `:CocRestart` triggered automatically on close when changes detected
+- **Registry hot-reload** — `:CocCommand loader.updateRegistry` fetches remote registry
+- **Install logs** — real command output per step, expandable
+
+## Architecture
+
+| File | Description |
+|------|-------------|
+| `src/index.ts` | Plugin entry + 7 CocCommands |
+| `src/tui.ts` | TUI window management + rendering + key dispatch |
+| `src/state.ts` | State management (debounced rendering) |
+| `src/registry.ts` | Built-in registry + remote update cache |
+| `src/pipeline.ts` | Real install/update/uninstall flow (git + npx tsx + npm + node + cp) |
+| `src/renderer.ts` | LineBuffer render engine (inspired by lazy.nvim) |
+
+## Build
+
+```bash
+npm install
+npm run build    # esbuild → lib/index.js
+```

package/lib/index.js

@@ -0,0 +1,1078 @@
+"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_coc2 = require("coc.nvim");
+
+// src/registry.ts
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var REMOTE_REGISTRY_URL = "https://raw.githubusercontent.com/coc-plugin/coc-vscode-registry/main/registry.json";
+var CACHE_PATH = path.join(os.homedir(), ".config", "coc", "converter-cache", "registry.json");
+var BUILTIN_REGISTRY = [
+  {
+    name: "volar",
+    displayName: "Volar (Vue)",
+    description: "Vue language support \u2014 template/script/style IntelliSense",
+    type: "ts-bridge",
+    source: { type: "github", repo: "vuejs/language-tools", subdir: "extensions/vscode" },
+    url: "https://github.com/vuejs/language-tools",
+    languages: ["vue"],
+    categories: ["LSP", "TypeScript"]
+  },
+  {
+    name: "prisma",
+    displayName: "Prisma",
+    description: "Prisma schema language support \u2014 syntax highlight, lint, format",
+    type: "pure-lsp",
+    source: { type: "github", repo: "prisma/language-tools", subdir: "packages/vscode" },
+    url: "https://github.com/prisma/language-tools",
+    languages: ["prisma"],
+    categories: ["LSP"]
+  },
+  {
+    name: "html-css-support",
+    displayName: "HTML CSS Support",
+    description: "CSS class name completion for HTML attributes",
+    type: "direct-api",
+    source: { type: "github", repo: "ecmel/vscode-html-css" },
+    url: "https://github.com/ecmel/vscode-html-css",
+    languages: ["html", "css"],
+    categories: ["Completion"]
+  }
+];
+var cached = null;
+function loadCache() {
+  try {
+    if (fs.existsSync(CACHE_PATH)) {
+      return JSON.parse(fs.readFileSync(CACHE_PATH, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+async function updateRegistry() {
+  const res = await fetch(REMOTE_REGISTRY_URL);
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const data = await res.json();
+  if (!Array.isArray(data)) throw new Error("Invalid registry format");
+  fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+  fs.writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2));
+  cached = data;
+  return data.length;
+}
+function getAllPackages() {
+  if (cached) return cached;
+  cached = loadCache();
+  return cached || BUILTIN_REGISTRY;
+}
+function getPackage(name) {
+  return getAllPackages().find((p) => p.name === name);
+}
+
+// src/state.ts
+var path2 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+function isInstalled(name) {
+  return fs2.existsSync(path2.join(os2.homedir(), ".config", "coc", "extensions", "node_modules", `coc-${name}`));
+}
+function createInitialState() {
+  const packages = getAllPackages().map((info) => {
+    const installed = isInstalled(info.name);
+    let commit;
+    if (installed) {
+      try {
+        const meta = JSON.parse(
+          fs2.readFileSync(path2.join(os2.homedir(), ".config", "coc", "converter-cache", info.name, "meta.json"), "utf-8")
+        );
+        commit = meta.commit || void 0;
+      } catch {
+      }
+    }
+    return {
+      info,
+      status: installed ? "installed" : "not-installed",
+      commit,
+      progressLog: [],
+      expanded: false,
+      logExpanded: false
+    };
+  });
+  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all" };
+}
+var StateManager = class {
+  constructor(initial) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.scheduled = false;
+    this.state = initial;
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  mutate(fn) {
+    fn(this.state);
+    this.notify();
+  }
+  notify() {
+    if (this.scheduled) return;
+    this.scheduled = true;
+    const state = this.state;
+    process.nextTick(() => {
+      this.scheduled = false;
+      for (const fn of this.listeners) {
+        fn(state);
+      }
+    });
+  }
+  setPackageStatus(name, status, extra) {
+    this.mutate((s) => {
+      const pkg = s.packages.find((p) => p.info.name === name);
+      if (pkg) {
+        pkg.status = status;
+        if (extra?.progress !== void 0) pkg.progress = extra.progress;
+        if (extra?.logEntry !== void 0) pkg.progressLog.push(extra.logEntry);
+        if (extra?.appendLog && extra?.progress !== void 0) pkg.progressLog.push(extra.progress);
+        if (extra?.error !== void 0) pkg.error = extra.error;
+        if (status === "installed" || status === "not-installed") {
+          pkg.progress = void 0;
+        }
+      }
+    });
+  }
+  toggleExpand(name) {
+    this.mutate((s) => {
+      const pkg = s.packages.find((p) => p.info.name === name);
+      if (pkg) pkg.expanded = !pkg.expanded;
+    });
+  }
+  toggleLog(name) {
+    this.mutate((s) => {
+      const pkg = s.packages.find((p) => p.info.name === name);
+      if (pkg) pkg.logExpanded = !pkg.logExpanded;
+    });
+  }
+  toggleHelp() {
+    this.mutate((s) => {
+      s.showHelp = !s.showHelp;
+    });
+  }
+  setViewFilter(filter) {
+    this.mutate((s) => {
+      s.viewFilter = filter;
+    });
+  }
+  setStatusMessage(msg) {
+    this.mutate((s) => {
+      s.statusMessage = msg;
+    });
+  }
+  setDirty() {
+    this.mutate((s) => {
+      s.dirty = true;
+    });
+  }
+  setActivePill(pill) {
+    this.mutate((s) => {
+      s.activePill = pill;
+    });
+  }
+  setSearchQuery(query) {
+    this.mutate((s) => {
+      s.searchQuery = query;
+    });
+  }
+  getFilteredPackages() {
+    let pkgs = this.state.packages;
+    if (this.state.viewFilter === "not-installed") {
+      pkgs = pkgs.filter((p) => p.status === "not-installed");
+    } else if (this.state.viewFilter === "installed") {
+      pkgs = pkgs.filter((p) => p.status === "installed");
+    }
+    const q = this.state.searchQuery.toLowerCase();
+    if (!q) return pkgs;
+    return pkgs.filter(
+      (p) => p.info.name.toLowerCase().includes(q) || p.info.displayName.toLowerCase().includes(q) || p.info.description.toLowerCase().includes(q)
+    );
+  }
+  getPackage(name) {
+    return this.state.packages.find((p) => p.info.name === name);
+  }
+};
+
+// src/tui.ts
+var import_coc = require("coc.nvim");
+
+// src/pipeline.ts
+var import_child_process = require("child_process");
+var path3 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var os3 = __toESM(require("os"));
+var CACHE_ROOT = path3.join(os3.homedir(), ".config", "coc", "converter-cache");
+function cacheDir(name) {
+  return path3.join(CACHE_ROOT, name);
+}
+function sourceDir(name) {
+  return path3.join(cacheDir(name), "source");
+}
+function buildDir(name) {
+  return path3.join(cacheDir(name), "build");
+}
+function pluginDir(name) {
+  return path3.join(os3.homedir(), ".config", "coc", "extensions", "node_modules", `coc-${name}`);
+}
+function converterCliPath() {
+  const base = path3.resolve(__dirname, "..");
+  const candidates = [
+    path3.join(base, "..", "converter", "src", "cli.ts"),
+    path3.join(base, "..", "..", "converter", "src", "cli.ts"),
+    path3.join(base, "..", "..", "..", "converter", "src", "cli.ts")
+  ];
+  for (const p of candidates) {
+    if (fs3.existsSync(p)) return p;
+  }
+  throw new Error(
+    "converter CLI not found. Please set $COC_CONVERTER_PATH to the converter/ directory, or ensure it is at the same level as coc-converter/"
+  );
+}
+async function run(cmd, args, cwd, onLine) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process.spawn)(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], shell: true });
+    const lines = [];
+    const handler = (data) => {
+      const text = data.toString();
+      lines.push(text);
+      onLine(text);
+    };
+    child.stdout.on("data", handler);
+    child.stderr.on("data", handler);
+    child.on("close", (code) => {
+      if (code === 0) resolve2();
+      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+    });
+    child.on("error", reject);
+  });
+}
+async function downloadSource(info, name, onProgress) {
+  const srcDir = sourceDir(name);
+  const cache = cacheDir(name);
+  const repoUrl = `https://github.com/${info.source.repo}.git`;
+  if (fs3.existsSync(srcDir)) {
+    onProgress(1, 5, "Updating source...", `git -C ${srcDir} pull`);
+    await run("git", ["-C", srcDir, "pull"], cache, () => {
+    });
+  } else {
+    onProgress(1, 5, "Cloning repository...", `git clone --depth=1 ${repoUrl}`);
+    fs3.mkdirSync(cache, { recursive: true });
+    await run("git", ["clone", "--depth=1", repoUrl, srcDir], cache, () => {
+    });
+  }
+  return info.source.subdir ? path3.join(srcDir, info.source.subdir) : srcDir;
+}
+async function convertSource(inputDir, name, onProgress) {
+  const build = buildDir(name);
+  if (fs3.existsSync(build)) fs3.rmSync(build, { recursive: true });
+  const cli = converterCliPath();
+  onProgress(2, 5, "Converting...", `converter convert ${inputDir} -o ${build}`);
+  await run("npx", ["tsx", cli, "convert", inputDir, "-o", build], cacheDir(name), () => {
+  });
+}
+async function buildPackage(name, onProgress) {
+  const build = buildDir(name);
+  onProgress(3, 5, "Installing dependencies...", "npm install --legacy-peer-deps");
+  await run("npm", ["install", "--legacy-peer-deps"], build, () => {
+  });
+  onProgress(4, 5, "Building...", "node esbuild.mjs");
+  await run("node", ["esbuild.mjs"], build, () => {
+  });
+}
+function extensionsPkgPath() {
+  return path3.join(os3.homedir(), ".config", "coc", "extensions", "package.json");
+}
+async function installToCoc(name, onProgress) {
+  const src = buildDir(name);
+  const dest = pluginDir(name);
+  onProgress(5, 5, "Installing to coc...", `copy to ${dest} + register in extensions/package.json`);
+  if (fs3.existsSync(dest)) fs3.rmSync(dest, { recursive: true });
+  fs3.mkdirSync(path3.dirname(dest), { recursive: true });
+  fs3.cpSync(src, dest, { recursive: true });
+  const pkgPath = extensionsPkgPath();
+  const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+  const depName = `coc-${name}`;
+  if (!pkg.dependencies[depName]) {
+    pkg.dependencies[depName] = `file:${dest}`;
+    pkg.lastUpdate = Date.now();
+    fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+  }
+}
+function metaPath(name) {
+  return path3.join(cacheDir(name), "meta.json");
+}
+function saveMeta(name) {
+  const srcDir = sourceDir(name);
+  try {
+    const commit = (0, import_child_process.execSync)("git", ["-C", srcDir, "rev-parse", "--short", "HEAD"], { encoding: "utf-8" }).toString().trim();
+    fs3.writeFileSync(metaPath(name), JSON.stringify({ commit, updatedAt: Date.now() }, null, 2));
+  } catch {
+  }
+}
+async function installPackage(state, name) {
+  const info = getPackage(name);
+  if (!info) {
+    state.setPackageStatus(name, "failed", { error: `Unknown package: ${name}` });
+    return;
+  }
+  const prog = (step, total, msg, cmd) => {
+    state.setPackageStatus(name, "installing", {
+      progress: `[${step}/${total}] ${msg}`,
+      logEntry: `[${step}/${total}] ${msg}
+  $ ${cmd}`,
+      appendLog: true
+    });
+  };
+  state.setPackageStatus(name, "installing", { progress: "Starting..." });
+  try {
+    const input = await downloadSource(info, name, prog);
+    await convertSource(input, name, prog);
+    await buildPackage(name, prog);
+    await installToCoc(name, prog);
+    saveMeta(name);
+    state.setDirty();
+    state.setPackageStatus(name, "installed");
+  } catch (e) {
+    state.setPackageStatus(name, "failed", { error: e.message });
+  }
+}
+async function uninstallPackage(state, name) {
+  state.setPackageStatus(name, "uninstalling", { progress: "[1/3] Removing from coc..." });
+  try {
+    const dest = pluginDir(name);
+    if (fs3.existsSync(dest)) {
+      fs3.rmSync(dest, { recursive: true });
+    }
+    state.setPackageStatus(name, "uninstalling", { progress: "[2/3] Removing from package.json..." });
+    const pkgPath = extensionsPkgPath();
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const depName = `coc-${name}`;
+    if (pkg.dependencies[depName]) {
+      delete pkg.dependencies[depName];
+      pkg.lastUpdate = Date.now();
+      fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+    state.setPackageStatus(name, "uninstalling", { progress: "[3/3] Removing cache..." });
+    const cache = cacheDir(name);
+    if (fs3.existsSync(cache)) {
+      fs3.rmSync(cache, { recursive: true });
+    }
+    state.setPackageStatus(name, "not-installed");
+    state.setDirty();
+  } catch (e) {
+    state.setPackageStatus(name, "failed", { error: e.message });
+  }
+}
+async function updatePackage(state, name) {
+  const info = getPackage(name);
+  if (!info) {
+    state.setPackageStatus(name, "failed", { error: `Unknown package: ${name}` });
+    return;
+  }
+  const prog = (step, total, msg, cmd) => {
+    state.setPackageStatus(name, "updating", {
+      progress: `[${step}/${total}] ${msg}`,
+      logEntry: `[${step}/${total}] ${msg}
+  $ ${cmd}`,
+      appendLog: true
+    });
+  };
+  state.setPackageStatus(name, "updating", { progress: "Starting..." });
+  try {
+    const input = await downloadSource(info, name, prog);
+    await convertSource(input, name, prog);
+    await buildPackage(name, prog);
+    await installToCoc(name, prog);
+    saveMeta(name);
+    state.setDirty();
+    state.setPackageStatus(name, "installed");
+  } catch (e) {
+    state.setPackageStatus(name, "failed", { error: e.message });
+  }
+}
+async function runWithOutput(cmd, args, cwd) {
+  return new Promise((resolve2, reject) => {
+    const child = (0, import_child_process.spawn)(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], shell: true });
+    let out = "";
+    child.stdout.on("data", (d) => {
+      out += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      out += d.toString();
+    });
+    child.on("close", (code) => code === 0 ? resolve2(out.trim()) : reject(new Error(`exit ${code}`)));
+    child.on("error", reject);
+  });
+}
+async function checkUpdates(state) {
+  const s = state.getState();
+  const results = {};
+  state.setStatusMessage("Checking for updates...");
+  for (const pkg of s.packages) {
+    if (pkg.status !== "installed" || !pkg.commit) continue;
+    state.setStatusMessage(`Checking ${pkg.info.displayName}...`);
+    try {
+      const out = await runWithOutput("git", ["ls-remote", `https://github.com/${pkg.info.source.repo}.git`, "HEAD"], os3.homedir());
+      const remote = out.split("	")[0];
+      if (remote) results[pkg.info.name] = remote.substring(0, 7) !== pkg.commit;
+    } catch {
+    }
+  }
+  const updateCount = Object.values(results).filter(Boolean).length;
+  state.mutate((s2) => {
+    for (const p of s2.packages) {
+      if (results[p.info.name] !== void 0) p.hasUpdate = results[p.info.name];
+    }
+    s2.statusMessage = void 0;
+  });
+  if (updateCount > 0) {
+    state.setStatusMessage(`Found ${updateCount} package(s) with updates. Use 'u' to update.`);
+    setTimeout(() => state.setStatusMessage(), 5e3);
+  } else {
+    state.setStatusMessage("All packages up to date.");
+    setTimeout(() => state.setStatusMessage(), 3e3);
+  }
+}
+
+// src/renderer.ts
+function byteLen(s) {
+  return Buffer.from(s).length;
+}
+var LineBuffer = class {
+  constructor() {
+    this.lines = [[]];
+    this.li = 0;
+    this.patternHls = [];
+  }
+  append(text, hl) {
+    this.lines[this.li].push({ text, hl });
+    return this;
+  }
+  nl(text, hl) {
+    if (text !== void 0) this.append(text, hl);
+    this.li++;
+    this.lines[this.li] = [];
+    return this;
+  }
+  lineCount() {
+    return this.lines.length;
+  }
+  currentLine() {
+    return this.li;
+  }
+  highlight(pattern, hlGroup) {
+    const segs = this.lines[this.li];
+    let full = "";
+    for (const seg of segs) full += seg.text;
+    pattern.lastIndex = 0;
+    let m;
+    while ((m = pattern.exec(full)) !== null) {
+      const colStart = byteLen(full.slice(0, m.index));
+      const colEnd = colStart + byteLen(m[0]);
+      this.patternHls.push({ line: this.li, hlGroup, colStart, colEnd });
+    }
+    return this;
+  }
+  render(padding = 0) {
+    const lines = [];
+    const highlights = [];
+    for (let li = 0; li < this.lines.length; li++) {
+      const segs = this.lines[li];
+      let full = "";
+      for (const seg of segs) {
+        const colStart = byteLen(full) + padding;
+        full += seg.text;
+        const colEnd = byteLen(full) + padding;
+        if (seg.hl) {
+          highlights.push({ line: li, hlGroup: seg.hl, colStart, colEnd });
+        }
+      }
+      if (padding > 0 && full.length > 0) {
+        full = " ".repeat(padding) + full;
+      }
+      lines.push(full);
+    }
+    for (const h of this.patternHls) {
+      h.colStart += padding;
+      h.colEnd += padding;
+      highlights.push(h);
+    }
+    this.patternHls = [];
+    return { lines, highlights };
+  }
+};
+
+// src/tui.ts
+var HELP_TEXT = [
+  "  coc-loader \u2014 VS Code extension \u2192 coc.nvim plugin converter",
+  "",
+  "  Keymaps:",
+  "    i          Install package under cursor",
+  "    u          Update package under cursor",
+  "    U          Update all installed packages",
+  "    C          Check for updates from remote",
+  "    X          Uninstall package under cursor",
+  "    Z          Uninstall all installed packages (with confirm)",
+  "    <Enter>    Toggle expand/collapse details",
+  "    /          Search filter",
+  "    q / <Esc>  Close window",
+  "",
+  "  " + "\u2500".repeat(40),
+  "",
+  "  Plugin types:",
+  "    ts-bridge   Depends on TypeScript LSP bridge (e.g. Volar)",
+  "    pure-lsp    Standard LSP protocol (e.g. Prisma, ESLint)",
+  "    direct-api  Direct coc.nvim API calls (e.g. HTML CSS Support)"
+];
+var TUI = class {
+  constructor(state) {
+    this.bufnr = 0;
+    this.winid = 0;
+    this.ns = 0;
+    this.disposables = [];
+    this.unsubscribe = null;
+    this.pkgLineMap = /* @__PURE__ */ new Map();
+    this.logLineSet = /* @__PURE__ */ new Set();
+    this.keyMap = {
+      q: "q",
+      esc: "<Esc>",
+      question: "?",
+      slash: "/",
+      U: "U",
+      Z: "Z",
+      i: "i",
+      u: "u",
+      X: "X",
+      cr: "<CR>"
+    };
+    this.rendering = false;
+    this.state = state;
+  }
+  async open() {
+    const nvim = import_coc.workspace.nvim;
+    this.ns = await nvim.createNamespace("coc-loader");
+    await nvim.command("highlight default link CocConverterTitle Title");
+    await nvim.command("highlight default link CocConverterPill Visual");
+    await nvim.command("highlight default link CocConverterPillActive IncSearch");
+    await nvim.command("highlight CocConverterKey guifg=#569CD6 guibg=NONE ctermbg=NONE");
+    await nvim.command("highlight default link CocConverterInstalled String");
+    await nvim.command("highlight default link CocConverterAvailable Comment");
+    await nvim.command("highlight default link CocConverterType Type");
+    await nvim.command("highlight default link CocConverterSection Title");
+    await nvim.command("highlight default link CocConverterTotal Identifier");
+    const buf = await nvim.createNewBuffer(false, true);
+    this.bufnr = buf.id;
+    const editorLines = await nvim.call("nvim_get_option", ["lines"]);
+    const editorCols = await nvim.call("nvim_get_option", ["columns"]);
+    const height = Math.min(Math.floor(editorLines * 0.85), 40);
+    const width = Math.min(Math.floor(editorCols * 0.85), 120);
+    const row = Math.max(Math.floor((editorLines - height) / 2), 0);
+    const col = Math.max(Math.floor((editorCols - width) / 2), 0);
+    const win = await nvim.openFloatWindow(buf, true, {
+      relative: "editor",
+      width,
+      height,
+      row,
+      col,
+      border: "none",
+      style: "minimal"
+    });
+    this.winid = win.id;
+    await nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", false]);
+    await nvim.call("nvim_buf_set_option", [this.bufnr, "bufhidden", "wipe"]);
+    await nvim.call("nvim_buf_set_option", [this.bufnr, "buftype", "nofile"]);
+    await nvim.call("nvim_buf_set_option", [this.bufnr, "swapfile", false]);
+    await nvim.call("nvim_buf_set_option", [this.bufnr, "undolevels", -1]);
+    await nvim.call("nvim_win_set_option", [this.winid, "cursorline", true]);
+    await nvim.call("nvim_win_set_option", [this.winid, "number", false]);
+    await nvim.call("nvim_win_set_option", [this.winid, "relativenumber", false]);
+    await nvim.call("nvim_win_set_option", [this.winid, "wrap", false]);
+    await nvim.call("nvim_win_set_option", [this.winid, "signcolumn", "no"]);
+    await nvim.call("nvim_win_set_option", [this.winid, "spell", false]);
+    await nvim.call("nvim_win_set_option", [this.winid, "foldenable", false]);
+    this.unsubscribe = this.state.subscribe(() => {
+      this.render();
+    });
+    this.disposables.push(
+      import_coc.workspace.registerAutocmd({
+        event: "WinEnter",
+        request: true,
+        callback: async () => {
+          if (!this.winid) return;
+          const curWin = await nvim.call("win_getid");
+          if (curWin === this.winid) return;
+          const curBuf = await nvim.call("winbufnr", [curWin]);
+          const bt = await nvim.call("getbufvar", [curBuf, "&buftype"]);
+          if (bt !== "nofile" && bt !== "prompt") {
+            this.close();
+          }
+        }
+      })
+    );
+    const exists = await nvim.call("exists", ["*CocConverterDispatch"]);
+    if (exists === 0) {
+      await nvim.command(`
+        function! CocConverterDispatch(key) abort
+          execute 'CocCommand loader._dispatch ' . a:key
+        endfunction
+      `);
+    }
+    await this.setupKeymaps();
+    await this.render();
+  }
+  async getCursorLine0() {
+    const nvim = import_coc.workspace.nvim;
+    const cursor = await nvim.call("nvim_win_get_cursor", [this.winid]);
+    return cursor[0] - 1;
+  }
+  async handleKey(id) {
+    const line0 = await this.getCursorLine0();
+    const s = this.state.getState();
+    if (id === "q") {
+      this.close();
+      return;
+    }
+    if (id === "I") {
+      this.state.setActivePill("I");
+      return;
+    }
+    if (id === "H") {
+      this.state.setSearchQuery("");
+      this.state.setActivePill(null);
+      if (s.showHelp) this.state.toggleHelp();
+      return;
+    }
+    if (id === "esc") {
+      if (s.showHelp) {
+        this.state.toggleHelp();
+        return;
+      }
+      if (s.searchQuery) {
+        this.state.setSearchQuery("");
+        return;
+      }
+      this.close();
+      return;
+    }
+    if (id === "question") {
+      this.state.toggleHelp();
+      return;
+    }
+    if (id === "slash") {
+      try {
+        const q = await import_coc.workspace.nvim.call("input", ["Search: ", ""]);
+        if (q) this.state.setSearchQuery(q);
+      } catch {
+      }
+      return;
+    }
+    if (id === "U") {
+      const installed = s.packages.filter((p) => p.status === "installed");
+      if (installed.length === 0) return;
+      this.state.setActivePill("U");
+      await Promise.all(installed.map((p) => updatePackage(this.state, p.info.name)));
+      this.state.setActivePill(null);
+      return;
+    }
+    if (id === "Z") {
+      const installed = s.packages.filter((p) => p.status === "installed");
+      if (installed.length === 0) return;
+      const ok = await import_coc.window.showPrompt(`Uninstall all ${installed.length} packages?`);
+      if (ok) {
+        for (const pkg of installed) uninstallPackage(this.state, pkg.info.name);
+      }
+      return;
+    }
+    if (id === "C") {
+      this.state.setActivePill("C");
+      await checkUpdates(this.state);
+      this.state.setActivePill(null);
+      return;
+    }
+    const pkgName = this.pkgLineMap.get(line0);
+    if (!pkgName) return;
+    const entry = this.state.getPackage(pkgName);
+    if (!entry) return;
+    if (id === "i" && entry.status === "not-installed") {
+      await installPackage(this.state, pkgName);
+      return;
+    }
+    if (id === "u" && entry.status === "installed") {
+      await updatePackage(this.state, pkgName);
+      return;
+    }
+    if (id === "X" && entry.status === "installed") {
+      uninstallPackage(this.state, pkgName);
+      return;
+    }
+    if (id === "cr") {
+      if (this.logLineSet.has(line0)) {
+        this.state.toggleLog(pkgName);
+      } else {
+        this.state.toggleExpand(pkgName);
+      }
+      return;
+    }
+  }
+  async setupKeymaps() {
+    const buf = import_coc.workspace.nvim.createBuffer(this.bufnr);
+    const entries = [
+      ["q", "q"],
+      ["<Esc>", "esc"],
+      ["?", "question"],
+      ["/", "slash"],
+      ["U", "U"],
+      ["Z", "Z"],
+      ["C", "C"],
+      ["i", "i"],
+      ["I", "I"],
+      ["H", "H"],
+      ["u", "u"],
+      ["X", "X"],
+      ["x", "X"],
+      ["<CR>", "cr"]
+    ];
+    for (const [vimKey, id] of entries) {
+      buf.setKeymap("n", vimKey, `<Cmd>call CocConverterDispatch("${id}")<CR>`, { silent: true, nowait: true });
+    }
+  }
+  async close() {
+    const needRestart = this.state.getState().dirty;
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    for (const d of this.disposables) {
+      d.dispose();
+    }
+    this.disposables = [];
+    if (this.winid) {
+      try {
+        await import_coc.workspace.nvim.call("nvim_win_close", [this.winid, true]);
+      } catch {
+      }
+      this.winid = 0;
+    }
+    if (needRestart) {
+      import_coc.workspace.nvim.command("CocRestart", true);
+    }
+  }
+  async render() {
+    if (!this.winid || this.rendering) return;
+    this.rendering = true;
+    try {
+      const nvim = import_coc.workspace.nvim;
+      const state = this.state.getState();
+      const filtered = this.state.getFilteredPackages();
+      const result = state.showHelp ? this.renderHelp() : this.renderPackageList(state, filtered);
+      nvim.pauseNotification();
+      nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", true], true);
+      nvim.call("nvim_buf_clear_namespace", [this.bufnr, this.ns, 0, -1], true);
+      nvim.call("nvim_buf_set_lines", [this.bufnr, 0, -1, false, result.lines], true);
+      nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", false], true);
+      for (const h of result.highlights) {
+        nvim.call("nvim_buf_set_extmark", [this.bufnr, this.ns, h.line, h.colStart, {
+          end_col: h.colEnd,
+          hl_group: h.hlGroup,
+          hl_mode: "combine"
+        }], true);
+      }
+      await nvim.resumeNotification();
+      this.pkgLineMap = result.pkgLineMap;
+      this.logLineSet = result.logLines;
+    } finally {
+      this.rendering = false;
+    }
+  }
+  renderHelp() {
+    const header = [
+      "",
+      "  coc-loader v0.1",
+      "  press ? help | / search | q quit",
+      "  " + "\u2500".repeat(50),
+      ""
+    ];
+    return { lines: [...header, ...HELP_TEXT, "", "  q to return"], pkgLineMap: /* @__PURE__ */ new Map(), logLines: /* @__PURE__ */ new Set(), highlights: [] };
+  }
+  statusLabel(status) {
+    switch (status) {
+      case "installed":
+        return "[installed]";
+      case "not-installed":
+        return "[not installed]";
+      case "installing":
+        return "[installing]";
+      case "updating":
+        return "[updating]";
+      case "uninstalling":
+        return "[uninstalling]";
+      case "failed":
+        return "[failed]";
+      default:
+        return "";
+    }
+  }
+  renderPackageList(state, filtered) {
+    const pkgLineMap = /* @__PURE__ */ new Map();
+    const logSet = /* @__PURE__ */ new Set();
+    this.pkgLineMap = pkgLineMap;
+    this.logLineSet = logSet;
+    const buf = new LineBuffer();
+    buf.nl();
+    const needHome = !!(state.showHelp || state.searchQuery);
+    buf.append("coc-loader(H)", needHome ? "CocConverterPillActive" : "CocConverterTitle");
+    for (const [name, key] of [["Install", "I"], ["Update", "U"], ["Check", "C"], ["Help", "?"]]) {
+      buf.append("  ");
+      const isActive = key === "?" && state.showHelp || key === "I" && state.activePill === "I" || key === "U" && state.activePill === "U" || key === "C" && state.activePill === "C";
+      buf.append(`${name}(${key})`, isActive ? "CocConverterPillActive" : "CocConverterPill");
+    }
+    buf.highlight(/\([IU?C]\)/g, "CocConverterKey");
+    buf.nl();
+    buf.nl();
+    buf.append(`Total: ${filtered.length} packages`, "CocConverterTotal");
+    if (state.statusMessage) {
+      buf.append("  \xB7  ");
+      buf.append(state.statusMessage, "Comment");
+    }
+    buf.nl();
+    buf.nl();
+    const installed = filtered.filter((e) => e.status !== "not-installed");
+    const available = filtered.filter((e) => e.status === "not-installed");
+    const section = (title, entries) => {
+      if (entries.length === 0) return;
+      buf.nl(`${title}`);
+      for (const e of entries) {
+        this.renderEntry(buf, pkgLineMap, logSet, e);
+      }
+      buf.nl();
+      buf.nl();
+    };
+    section(`Installed (${installed.length})`, installed);
+    section(`Available (${available.length})`, available);
+    if (filtered.length === 0 && state.searchQuery) {
+      buf.nl("no matching packages");
+    }
+    const result = buf.render(2);
+    return { lines: result.lines, pkgLineMap, logLines: logSet, highlights: result.highlights };
+  }
+  renderEntry(buf, pkgLineMap, logSet, entry) {
+    const icon = entry.status === "installed" ? "\u25CF" : entry.status === "failed" ? "\u2717" : "\u25CB";
+    const iconHl = entry.status === "installed" ? "CocConverterInstalled" : entry.status === "failed" ? "ErrorMsg" : "CocConverterAvailable";
+    const pkgLine = buf.currentLine();
+    pkgLineMap.set(pkgLine, entry.info.name);
+    buf.append(" ");
+    buf.append(icon, iconHl);
+    buf.append(" ");
+    buf.append(entry.info.displayName);
+    buf.append(" ");
+    buf.append(entry.info.type, "CocConverterType");
+    if (entry.hasUpdate) {
+      buf.append("  \u2191", "CocConverterKey");
+    }
+    if (entry.expanded) {
+      buf.nl();
+      for (const text of [
+        entry.info.description,
+        `type        ${entry.info.type}`,
+        entry.commit ? `commit      ${entry.commit}` : null,
+        `source      ${sourceStr(entry.info.source)}`,
+        `languages   ${entry.info.languages.join(", ")}`,
+        `categories  ${entry.info.categories.join(", ")}`,
+        `homepage    ${entry.info.url}`
+      ].filter(Boolean)) {
+        const ln = buf.currentLine();
+        buf.nl(`     ${text}`);
+        pkgLineMap.set(ln, entry.info.name);
+      }
+    }
+    if (entry.progress) {
+      buf.nl();
+      if (entry.logExpanded) {
+        const ln = buf.currentLine();
+        buf.nl(`     \u25BC Install log:`);
+        logSet.add(ln);
+        pkgLineMap.set(ln, entry.info.name);
+        for (const log of entry.progressLog) {
+          for (const l of log.split("\n")) {
+            const ln2 = buf.currentLine();
+            buf.nl(`       ${l}`);
+            logSet.add(ln2);
+            pkgLineMap.set(ln2, entry.info.name);
+          }
+        }
+      } else {
+        const ln = buf.currentLine();
+        buf.nl(`     \u25B6 ${entry.progress}`);
+        logSet.add(ln);
+        pkgLineMap.set(ln, entry.info.name);
+      }
+    }
+    if (entry.error) {
+      buf.nl();
+      const ln = buf.currentLine();
+      buf.nl(`     \u2717 ${entry.error}`);
+      pkgLineMap.set(ln, entry.info.name);
+    }
+    buf.nl();
+  }
+  hl(line, hlGroup, colStart, colEnd) {
+    this.hlLines.push({ line, hlGroup, colStart, colEnd });
+  }
+  isOpen() {
+    return this.winid !== 0;
+  }
+};
+function sourceStr(source) {
+  if (source.type === "github") return `github:${source.repo}${source.subdir ? "/" + source.subdir : ""}`;
+  if (source.type === "npm") return `npm:${source.package}`;
+  return source.type;
+}
+
+// src/index.ts
+var currentTUI = null;
+async function activate(context) {
+  const state = new StateManager(createInitialState());
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.open", async () => {
+      if (currentTUI && currentTUI.isOpen()) {
+        await currentTUI.close();
+      }
+      currentTUI = new TUI(state);
+      await currentTUI.open();
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.install", async (name) => {
+      if (!name) {
+        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        if (!name) return;
+      }
+      const pkg = state.getPackage(name);
+      if (!pkg) {
+        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        return;
+      }
+      if (pkg.status === "installed") {
+        import_coc2.window.showInformationMessage(`${name} is already installed`);
+        return;
+      }
+      await installPackage(state, name);
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.uninstall", async (name) => {
+      if (!name) {
+        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        if (!name) return;
+      }
+      const pkg = state.getPackage(name);
+      if (!pkg) {
+        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        return;
+      }
+      if (pkg.status !== "installed") {
+        import_coc2.window.showInformationMessage(`${name} is not installed`);
+        return;
+      }
+      uninstallPackage(state, name);
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.update", async (name) => {
+      if (!name) {
+        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        if (!name) return;
+      }
+      const pkg = state.getPackage(name);
+      if (!pkg) {
+        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        return;
+      }
+      if (pkg.status !== "installed") {
+        import_coc2.window.showInformationMessage(`${name} is not installed`);
+        return;
+      }
+      await updatePackage(state, name);
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.uninstallAll", async () => {
+      const installed = state.getState().packages.filter((p) => p.status === "installed");
+      if (installed.length === 0) {
+        import_coc2.window.showInformationMessage("No packages installed");
+        return;
+      }
+      const ok = await import_coc2.window.showPrompt(`Uninstall all ${installed.length} packages?`);
+      if (ok) {
+        for (const pkg of installed) {
+          uninstallPackage(state, pkg.info.name);
+        }
+      }
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader.updateRegistry", async () => {
+      try {
+        const count = await updateRegistry();
+        import_coc2.window.showInformationMessage(`Registry updated: ${count} packages available. Restart coc to apply.`);
+      } catch (e) {
+        import_coc2.window.showErrorMessage(`Registry update failed: ${e.message}`);
+      }
+    })
+  );
+  context.subscriptions.push(
+    import_coc2.commands.registerCommand("loader._dispatch", async (key) => {
+      if (currentTUI) {
+        await currentTUI.handleKey(key);
+      }
+    })
+  );
+  import_coc2.window.showInformationMessage("coc-loader activated! Use :CocCommand loader.open");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activate
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "coc-vscode-loader",
+  "version": "1.0.0",
+  "description": "Run VS Code extensions seamlessly in coc.nvim",
+  "main": "lib/index.js",
+  "keywords": [
+    "coc.nvim",
+    "vscode",
+    "neovim",
+    "lsp",
+    "plugin-loader",
+    "vim"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coc-plugin/coc-vscode-loader.git"
+  },
+  "bugs": {
+    "url": "https://github.com/coc-plugin/coc-vscode-loader/issues"
+  },
+  "homepage": "https://github.com/coc-plugin/coc-vscode-loader",
+  "license": "MIT",
+  "engines": {
+    "coc": ">= 0.0.80"
+  },
+  "scripts": {
+    "build": "node esbuild.mjs",
+    "prepare": "node esbuild.mjs"
+  },
+  "devDependencies": {
+    "coc.nvim": "^0.0.83-next.18",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.3.3"
+  },
+  "activationEvents": [
+    "onCommand:loader.open",
+    "onCommand:loader._dispatch"
+  ],
+  "contributes": {
+    "commands": [
+      { "command": "loader.open", "title": "Open VS Code extension loader" },
+      { "command": "loader.install", "title": "Install a VS Code extension" },
+      { "command": "loader.uninstall", "title": "Uninstall a package" },
+      { "command": "loader.update", "title": "Update a package" },
+      { "command": "loader.uninstallAll", "title": "Uninstall all packages" },
+      { "command": "loader.updateRegistry", "title": "Update package registry" },
+      { "command": "loader._dispatch", "title": "" }
+    ]
+  }
+}