vibe-cokit 1.5.0 → 1.5.1

package/dist/cli.js

@@ -1,63 +1,15 @@
 #!/usr/bin/env bun
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
 };
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// package.json
-var require_package = __commonJS((exports, module) => {
-  module.exports = {
-    name: "vibe-cokit",
-    version: "0.1.0",
-    description: "A toolkit for interacting with Claude Code",
-    module: "index.ts",
-    type: "module",
-    bin: {
-      "vibe-cokit": "bin/vk.cjs",
-      vk: "bin/vk.cjs"
-    },
-    files: [
-      "bin/",
-      "dist/",
-      "package.json",
-      "README.md"
-    ],
-    scripts: {
-      build: "bun build src/cli.ts --outdir dist --target bun",
-      typecheck: "bunx tsc --noEmit"
-    },
-    publishConfig: {
-      access: "public"
-    },
-    repository: {
-      type: "git",
-      url: "git+https://github.com/vibe-cokit/cli.git"
-    },
-    devDependencies: {
-      "@types/bun": "latest"
-    },
-    peerDependencies: {
-      typescript: "^5"
-    },
-    dependencies: {
-      cac: "^6.7.14"
-    }
-  };
-});
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -627,75 +579,1712 @@ class CAC extends EventEmitter {
         }
       }
     }
-    for (const key of Object.keys(parsed)) {
-      if (key !== "_") {
-        const keys = key.split(".");
-        setDotProp(options, keys, parsed[key]);
-        setByType(options, transforms);
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+}
+var cac = (name = "") => new CAC(name);
+var dist_default = cac;
+// package.json
+var version = "0.1.0";
+
+// src/commands/init.ts
+import { join as join2 } from "path";
+
+// src/utils/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { mkdir, cp, rm, stat, readdir } from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var _freeGlobal_default = freeGlobal;
+
+// node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = _freeGlobal_default || freeSelf || Function("return this")();
+var _root_default = root;
+
+// node_modules/lodash-es/_Symbol.js
+var Symbol2 = _root_default.Symbol;
+var _Symbol_default = Symbol2;
+
+// node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var _getRawTag_default = getRawTag;
+
+// node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var _objectToString_default = objectToString;
+
+// node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = _Symbol_default ? _Symbol_default.toStringTag : undefined;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? _getRawTag_default(value) : _objectToString_default(value);
+}
+var _baseGetTag_default = baseGetTag;
+
+// node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && _baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// node_modules/lodash-es/_arrayMap.js
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap_default = arrayMap;
+
+// node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0;
+var symbolProto = _Symbol_default ? _Symbol_default.prototype : undefined;
+var symbolToString = symbolProto ? symbolProto.toString : undefined;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return _arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var _baseToString_default = baseToString;
+
+// node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// node_modules/lodash-es/identity.js
+function identity(value) {
+  return value;
+}
+var identity_default = identity;
+
+// node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = _baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// node_modules/lodash-es/_coreJsData.js
+var coreJsData = _root_default["__core-js_shared__"];
+var _coreJsData_default = coreJsData;
+
+// node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(_coreJsData_default && _coreJsData_default.keys && _coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked_default = isMasked;
+
+// node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return func + "";
+    } catch (e) {}
+  }
+  return "";
+}
+var _toSource_default = toSource;
+
+// node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject_default(value) || _isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(_toSource_default(value));
+}
+var _baseIsNative_default = baseIsNative;
+
+// node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue_default = getValue;
+
+// node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = _getValue_default(object, key);
+  return _baseIsNative_default(value) ? value : undefined;
+}
+var _getNative_default = getNative;
+
+// node_modules/lodash-es/_WeakMap.js
+var WeakMap2 = _getNative_default(_root_default, "WeakMap");
+var _WeakMap_default = WeakMap2;
+
+// node_modules/lodash-es/_defineProperty.js
+var defineProperty = function() {
+  try {
+    var func = _getNative_default(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {}
+}();
+var _defineProperty_default = defineProperty;
+
+// node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex_default = isIndex;
+
+// node_modules/lodash-es/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && _defineProperty_default) {
+    _defineProperty_default(object, key, {
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var _baseAssignValue_default = baseAssignValue;
+
+// node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// node_modules/lodash-es/_isIterateeCall.js
+function isIterateeCall(value, index, object) {
+  if (!isObject_default(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike_default(object) && _isIndex_default(index, object.length) : type == "string" && (index in object)) {
+    return eq_default(object[index], value);
+  }
+  return false;
+}
+var _isIterateeCall_default = isIterateeCall;
+
+// node_modules/lodash-es/_isPrototype.js
+var objectProto4 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto4;
+  return value === proto;
+}
+var _isPrototype_default = isPrototype;
+
+// node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var _baseTimes_default = baseTimes;
+
+// node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && _baseGetTag_default(value) == argsTag;
+}
+var _baseIsArguments_default = baseIsArguments;
+
+// node_modules/lodash-es/isArguments.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty3 = objectProto5.hasOwnProperty;
+var propertyIsEnumerable = objectProto5.propertyIsEnumerable;
+var isArguments = _baseIsArguments_default(function() {
+  return arguments;
+}()) ? _baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// node_modules/lodash-es/isBuffer.js
+var exports_isBuffer = {};
+__export(exports_isBuffer, {
+  default: () => isBuffer_default
+});
+
+// node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports_isBuffer == "object" && exports_isBuffer && !exports_isBuffer.nodeType && exports_isBuffer;
+var freeModule = freeExports && typeof module_isBuffer == "object" && module_isBuffer && !module_isBuffer.nodeType && module_isBuffer;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer = moduleExports ? _root_default.Buffer : undefined;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[_baseGetTag_default(value)];
+}
+var _baseIsTypedArray_default = baseIsTypedArray;
+
+// node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary_default = baseUnary;
+
+// node_modules/lodash-es/_nodeUtil.js
+var exports__nodeUtil = {};
+__export(exports__nodeUtil, {
+  default: () => _nodeUtil_default
+});
+var freeExports2 = typeof exports__nodeUtil == "object" && exports__nodeUtil && !exports__nodeUtil.nodeType && exports__nodeUtil;
+var freeModule2 = freeExports2 && typeof module__nodeUtil == "object" && module__nodeUtil && !module__nodeUtil.nodeType && module__nodeUtil;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && _freeGlobal_default.process;
+var nodeUtil = function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {}
+}();
+var _nodeUtil_default = nodeUtil;
+
+// node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = _nodeUtil_default && _nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? _baseUnary_default(nodeIsTypedArray) : _baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto6 = Object.prototype;
+var hasOwnProperty4 = objectProto6.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? _baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty4.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || _isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _arrayLikeKeys_default = arrayLikeKeys;
+
+// node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg_default = overArg;
+
+// node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = _overArg_default(Object.keys, Object);
+var _nativeKeys_default = nativeKeys;
+
+// node_modules/lodash-es/_baseKeys.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty5 = objectProto7.hasOwnProperty;
+function baseKeys(object) {
+  if (!_isPrototype_default(object)) {
+    return _nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty5.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys_default = baseKeys;
+
+// node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? _arrayLikeKeys_default(object) : _baseKeys_default(object);
+}
+var keys_default = keys;
+
+// node_modules/lodash-es/_isKey.js
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey_default = isKey;
+
+// node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = _getNative_default(Object, "create");
+var _nativeCreate_default = nativeCreate;
+
+// node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = _nativeCreate_default ? _nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var _hashClear_default = hashClear;
+
+// node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete_default = hashDelete;
+
+// node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto8 = Object.prototype;
+var hasOwnProperty6 = objectProto8.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (_nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty6.call(data, key) ? data[key] : undefined;
+}
+var _hashGet_default = hashGet;
+
+// node_modules/lodash-es/_hashHas.js
+var objectProto9 = Object.prototype;
+var hasOwnProperty7 = objectProto9.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return _nativeCreate_default ? data[key] !== undefined : hasOwnProperty7.call(data, key);
+}
+var _hashHas_default = hashHas;
+
+// node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = _nativeCreate_default && value === undefined ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var _hashSet_default = hashSet;
+
+// node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = _hashClear_default;
+Hash.prototype["delete"] = _hashDelete_default;
+Hash.prototype.get = _hashGet_default;
+Hash.prototype.has = _hashHas_default;
+Hash.prototype.set = _hashSet_default;
+var _Hash_default = Hash;
+
+// node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear_default = listCacheClear;
+
+// node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf_default = assocIndexOf;
+
+// node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete_default = listCacheDelete;
+
+// node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet_default = listCacheGet;
+
+// node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return _assocIndexOf_default(this.__data__, key) > -1;
+}
+var _listCacheHas_default = listCacheHas;
+
+// node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = _assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet_default = listCacheSet;
+
+// node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = _listCacheClear_default;
+ListCache.prototype["delete"] = _listCacheDelete_default;
+ListCache.prototype.get = _listCacheGet_default;
+ListCache.prototype.has = _listCacheHas_default;
+ListCache.prototype.set = _listCacheSet_default;
+var _ListCache_default = ListCache;
+
+// node_modules/lodash-es/_Map.js
+var Map = _getNative_default(_root_default, "Map");
+var _Map_default = Map;
+
+// node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    hash: new _Hash_default,
+    map: new (_Map_default || _ListCache_default),
+    string: new _Hash_default
+  };
+}
+var _mapCacheClear_default = mapCacheClear;
+
+// node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable_default = isKeyable;
+
+// node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return _isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData_default = getMapData;
+
+// node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = _getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete_default = mapCacheDelete;
+
+// node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return _getMapData_default(this, key).get(key);
+}
+var _mapCacheGet_default = mapCacheGet;
+
+// node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return _getMapData_default(this, key).has(key);
+}
+var _mapCacheHas_default = mapCacheHas;
+
+// node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = _getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet_default = mapCacheSet;
+
+// node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = _mapCacheClear_default;
+MapCache.prototype["delete"] = _mapCacheDelete_default;
+MapCache.prototype.get = _mapCacheGet_default;
+MapCache.prototype.has = _mapCacheHas_default;
+MapCache.prototype.set = _mapCacheSet_default;
+var _MapCache_default = MapCache;
+
+// node_modules/lodash-es/memoize.js
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || _MapCache_default);
+  return memoized;
+}
+memoize.Cache = _MapCache_default;
+var memoize_default = memoize;
+
+// node_modules/lodash-es/_memoizeCapped.js
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped_default = memoizeCapped;
+
+// node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = _memoizeCapped_default(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var _stringToPath_default = stringToPath;
+
+// node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : _baseToString_default(value);
+}
+var toString_default = toString;
+
+// node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return _isKey_default(value, object) ? [value] : _stringToPath_default(toString_default(value));
+}
+var _castPath_default = castPath;
+
+// node_modules/lodash-es/_toKey.js
+var INFINITY2 = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var _toKey_default = toKey;
+
+// node_modules/lodash-es/_baseGet.js
+function baseGet(object, path) {
+  path = _castPath_default(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[_toKey_default(path[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+var _baseGet_default = baseGet;
+
+// node_modules/lodash-es/get.js
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : _baseGet_default(object, path);
+  return result === undefined ? defaultValue : result;
+}
+var get_default = get;
+
+// node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush_default = arrayPush;
+
+// node_modules/lodash-es/_hasUnicode.js
+var rsAstralRange = "\\ud800-\\udfff";
+var rsComboMarksRange = "\\u0300-\\u036f";
+var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+var rsVarRange = "\\ufe0e\\ufe0f";
+var rsZWJ = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+var _hasUnicode_default = hasUnicode;
+
+// node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new _ListCache_default;
+  this.size = 0;
+}
+var _stackClear_default = stackClear;
+
+// node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete_default = stackDelete;
+
+// node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var _stackGet_default = stackGet;
+
+// node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var _stackHas_default = stackHas;
+
+// node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof _ListCache_default) {
+    var pairs = data.__data__;
+    if (!_Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new _MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet_default = stackSet;
+
+// node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new _ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = _stackClear_default;
+Stack.prototype["delete"] = _stackDelete_default;
+Stack.prototype.get = _stackGet_default;
+Stack.prototype.has = _stackHas_default;
+Stack.prototype.set = _stackSet_default;
+var _Stack_default = Stack;
+
+// node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var _arrayFilter_default = arrayFilter;
+
+// node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default = stubArray;
+
+// node_modules/lodash-es/_getSymbols.js
+var objectProto10 = Object.prototype;
+var propertyIsEnumerable2 = objectProto10.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return _arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable2.call(object, symbol);
+  });
+};
+var _getSymbols_default = getSymbols;
+
+// node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : _arrayPush_default(result, symbolsFunc(object));
+}
+var _baseGetAllKeys_default = baseGetAllKeys;
+
+// node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return _baseGetAllKeys_default(object, keys_default, _getSymbols_default);
+}
+var _getAllKeys_default = getAllKeys;
+
+// node_modules/lodash-es/_DataView.js
+var DataView = _getNative_default(_root_default, "DataView");
+var _DataView_default = DataView;
+
+// node_modules/lodash-es/_Promise.js
+var Promise2 = _getNative_default(_root_default, "Promise");
+var _Promise_default = Promise2;
+
+// node_modules/lodash-es/_Set.js
+var Set = _getNative_default(_root_default, "Set");
+var _Set_default = Set;
+
+// node_modules/lodash-es/_getTag.js
+var mapTag2 = "[object Map]";
+var objectTag2 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag2 = "[object Set]";
+var weakMapTag2 = "[object WeakMap]";
+var dataViewTag2 = "[object DataView]";
+var dataViewCtorString = _toSource_default(_DataView_default);
+var mapCtorString = _toSource_default(_Map_default);
+var promiseCtorString = _toSource_default(_Promise_default);
+var setCtorString = _toSource_default(_Set_default);
+var weakMapCtorString = _toSource_default(_WeakMap_default);
+var getTag = _baseGetTag_default;
+if (_DataView_default && getTag(new _DataView_default(new ArrayBuffer(1))) != dataViewTag2 || _Map_default && getTag(new _Map_default) != mapTag2 || _Promise_default && getTag(_Promise_default.resolve()) != promiseTag || _Set_default && getTag(new _Set_default) != setTag2 || _WeakMap_default && getTag(new _WeakMap_default) != weakMapTag2) {
+  getTag = function(value) {
+    var result = _baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : undefined, ctorString = Ctor ? _toSource_default(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag2;
+        case mapCtorString:
+          return mapTag2;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag2;
+        case weakMapCtorString:
+          return weakMapTag2;
+      }
+    }
+    return result;
+  };
+}
+var _getTag_default = getTag;
+
+// node_modules/lodash-es/_Uint8Array.js
+var Uint8Array = _root_default.Uint8Array;
+var _Uint8Array_default = Uint8Array;
+
+// node_modules/lodash-es/_setCacheAdd.js
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED3);
+  return this;
+}
+var _setCacheAdd_default = setCacheAdd;
+
+// node_modules/lodash-es/_setCacheHas.js
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas_default = setCacheHas;
+
+// node_modules/lodash-es/_SetCache.js
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new _MapCache_default;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd_default;
+SetCache.prototype.has = _setCacheHas_default;
+var _SetCache_default = SetCache;
+
+// node_modules/lodash-es/_arraySome.js
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome_default = arraySome;
+
+// node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas_default = cacheHas;
+
+// node_modules/lodash-es/_equalArrays.js
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new _SetCache_default : undefined;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== undefined) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!_arraySome_default(other, function(othValue2, othIndex) {
+        if (!_cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var _equalArrays_default = equalArrays;
+
+// node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray_default = mapToArray;
+
+// node_modules/lodash-es/_setToArray.js
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray_default = setToArray;
+
+// node_modules/lodash-es/_equalByTag.js
+var COMPARE_PARTIAL_FLAG2 = 1;
+var COMPARE_UNORDERED_FLAG2 = 2;
+var boolTag2 = "[object Boolean]";
+var dateTag2 = "[object Date]";
+var errorTag2 = "[object Error]";
+var mapTag3 = "[object Map]";
+var numberTag2 = "[object Number]";
+var regexpTag2 = "[object RegExp]";
+var setTag3 = "[object Set]";
+var stringTag2 = "[object String]";
+var symbolTag2 = "[object Symbol]";
+var arrayBufferTag2 = "[object ArrayBuffer]";
+var dataViewTag3 = "[object DataView]";
+var symbolProto2 = _Symbol_default ? _Symbol_default.prototype : undefined;
+var symbolValueOf = symbolProto2 ? symbolProto2.valueOf : undefined;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag3:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag2:
+      if (object.byteLength != other.byteLength || !equalFunc(new _Uint8Array_default(object), new _Uint8Array_default(other))) {
+        return false;
+      }
+      return true;
+    case boolTag2:
+    case dateTag2:
+    case numberTag2:
+      return eq_default(+object, +other);
+    case errorTag2:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag2:
+    case stringTag2:
+      return object == other + "";
+    case mapTag3:
+      var convert = _mapToArray_default;
+    case setTag3:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      convert || (convert = _setToArray_default);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG2;
+      stack.set(object, other);
+      var result = _equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag2:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag_default = equalByTag;
+
+// node_modules/lodash-es/_equalObjects.js
+var COMPARE_PARTIAL_FLAG3 = 1;
+var objectProto11 = Object.prototype;
+var hasOwnProperty8 = objectProto11.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = _getAllKeys_default(object), objLength = objProps.length, othProps = _getAllKeys_default(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && (("constructor" in object) && ("constructor" in other)) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var _equalObjects_default = equalObjects;
+
+// node_modules/lodash-es/_baseIsEqualDeep.js
+var COMPARE_PARTIAL_FLAG4 = 1;
+var argsTag3 = "[object Arguments]";
+var arrayTag2 = "[object Array]";
+var objectTag3 = "[object Object]";
+var objectProto12 = Object.prototype;
+var hasOwnProperty9 = objectProto12.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : _getTag_default(object), othTag = othIsArr ? arrayTag2 : _getTag_default(other);
+  objTag = objTag == argsTag3 ? objectTag3 : objTag;
+  othTag = othTag == argsTag3 ? objectTag3 : othTag;
+  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new _Stack_default);
+    return objIsArr || isTypedArray_default(object) ? _equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : _equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
+    var objIsWrapped = objIsObj && hasOwnProperty9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new _Stack_default);
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new _Stack_default);
+  return _equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep_default = baseIsEqualDeep;
+
+// node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
+    return value !== value && other !== other;
+  }
+  return _baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var _baseIsEqual_default = baseIsEqual;
+
+// node_modules/lodash-es/_baseIsMatch.js
+var COMPARE_PARTIAL_FLAG5 = 1;
+var COMPARE_UNORDERED_FLAG3 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index, noCustomizer = !customizer;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (noCustomizer && data[2]) {
+      if (objValue === undefined && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new _Stack_default;
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === undefined ? _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var _baseIsMatch_default = baseIsMatch;
+
+// node_modules/lodash-es/_isStrictComparable.js
+function isStrictComparable(value) {
+  return value === value && !isObject_default(value);
+}
+var _isStrictComparable_default = isStrictComparable;
+
+// node_modules/lodash-es/_getMatchData.js
+function getMatchData(object) {
+  var result = keys_default(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, _isStrictComparable_default(value)];
+  }
+  return result;
+}
+var _getMatchData_default = getMatchData;
+
+// node_modules/lodash-es/_matchesStrictComparable.js
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== undefined || (key in Object(object)));
+  };
+}
+var _matchesStrictComparable_default = matchesStrictComparable;
+
+// node_modules/lodash-es/_baseMatches.js
+function baseMatches(source) {
+  var matchData = _getMatchData_default(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return _matchesStrictComparable_default(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || _baseIsMatch_default(object, source, matchData);
+  };
+}
+var _baseMatches_default = baseMatches;
+
+// node_modules/lodash-es/_baseHasIn.js
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn_default = baseHasIn;
+
+// node_modules/lodash-es/_hasPath.js
+function hasPath(object, path, hasFunc) {
+  path = _castPath_default(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = _toKey_default(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength_default(length) && _isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var _hasPath_default = hasPath;
+
+// node_modules/lodash-es/hasIn.js
+function hasIn(object, path) {
+  return object != null && _hasPath_default(object, path, _baseHasIn_default);
+}
+var hasIn_default = hasIn;
+
+// node_modules/lodash-es/_baseMatchesProperty.js
+var COMPARE_PARTIAL_FLAG6 = 1;
+var COMPARE_UNORDERED_FLAG4 = 2;
+function baseMatchesProperty(path, srcValue) {
+  if (_isKey_default(path) && _isStrictComparable_default(srcValue)) {
+    return _matchesStrictComparable_default(_toKey_default(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get_default(object, path);
+    return objValue === undefined && objValue === srcValue ? hasIn_default(object, path) : _baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+  };
+}
+var _baseMatchesProperty_default = baseMatchesProperty;
+
+// node_modules/lodash-es/_baseProperty.js
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? undefined : object[key];
+  };
+}
+var _baseProperty_default = baseProperty;
+
+// node_modules/lodash-es/_basePropertyDeep.js
+function basePropertyDeep(path) {
+  return function(object) {
+    return _baseGet_default(object, path);
+  };
+}
+var _basePropertyDeep_default = basePropertyDeep;
+
+// node_modules/lodash-es/property.js
+function property(path) {
+  return _isKey_default(path) ? _baseProperty_default(_toKey_default(path)) : _basePropertyDeep_default(path);
+}
+var property_default = property;
+
+// node_modules/lodash-es/_baseIteratee.js
+function baseIteratee(value) {
+  if (typeof value == "function") {
+    return value;
+  }
+  if (value == null) {
+    return identity_default;
+  }
+  if (typeof value == "object") {
+    return isArray_default(value) ? _baseMatchesProperty_default(value[0], value[1]) : _baseMatches_default(value);
+  }
+  return property_default(value);
+}
+var _baseIteratee_default = baseIteratee;
+
+// node_modules/lodash-es/_createBaseFor.js
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
+    while (length--) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+var _createBaseFor_default = createBaseFor;
+
+// node_modules/lodash-es/_baseFor.js
+var baseFor = _createBaseFor_default();
+var _baseFor_default = baseFor;
+
+// node_modules/lodash-es/_baseForOwn.js
+function baseForOwn(object, iteratee) {
+  return object && _baseFor_default(object, iteratee, keys_default);
+}
+var _baseForOwn_default = baseForOwn;
+
+// node_modules/lodash-es/_createBaseEach.js
+function createBaseEach(eachFunc, fromRight) {
+  return function(collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike_default(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
+    while (fromRight ? index-- : ++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
       }
     }
-    return {
-      args,
-      options
-    };
+    return collection;
+  };
+}
+var _createBaseEach_default = createBaseEach;
+
+// node_modules/lodash-es/_baseEach.js
+var baseEach = _createBaseEach_default(_baseForOwn_default);
+var _baseEach_default = baseEach;
+
+// node_modules/lodash-es/_baseFilter.js
+function baseFilter(collection, predicate) {
+  var result = [];
+  _baseEach_default(collection, function(value, index, collection2) {
+    if (predicate(value, index, collection2)) {
+      result.push(value);
+    }
+  });
+  return result;
+}
+var _baseFilter_default = baseFilter;
+
+// node_modules/lodash-es/filter.js
+function filter(collection, predicate) {
+  var func = isArray_default(collection) ? _arrayFilter_default : _baseFilter_default;
+  return func(collection, _baseIteratee_default(predicate, 3));
+}
+var filter_default = filter;
+// node_modules/lodash-es/_baseGt.js
+function baseGt(value, other) {
+  return value > other;
+}
+var _baseGt_default = baseGt;
+
+// node_modules/lodash-es/isString.js
+var stringTag3 = "[object String]";
+function isString(value) {
+  return typeof value == "string" || !isArray_default(value) && isObjectLike_default(value) && _baseGetTag_default(value) == stringTag3;
+}
+var isString_default = isString;
+// node_modules/lodash-es/mapValues.js
+function mapValues(object, iteratee) {
+  var result = {};
+  iteratee = _baseIteratee_default(iteratee, 3);
+  _baseForOwn_default(object, function(value, key, object2) {
+    _baseAssignValue_default(result, key, iteratee(value, key, object2));
+  });
+  return result;
+}
+var mapValues_default = mapValues;
+// node_modules/lodash-es/_baseExtremum.js
+function baseExtremum(array, iteratee, comparator) {
+  var index = -1, length = array.length;
+  while (++index < length) {
+    var value = array[index], current = iteratee(value);
+    if (current != null && (computed === undefined ? current === current && !isSymbol_default(current) : comparator(current, computed))) {
+      var computed = current, result = value;
+    }
   }
-  runMatchedCommand() {
-    const { args, options, matchedCommand: command } = this;
-    if (!command || !command.commandAction)
-      return;
-    command.checkUnknownOptions();
-    command.checkOptionValue();
-    command.checkRequiredArgs();
-    const actionArgs = [];
-    command.args.forEach((arg, index) => {
-      if (arg.variadic) {
-        actionArgs.push(args.slice(index));
-      } else {
-        actionArgs.push(args[index]);
-      }
-    });
-    actionArgs.push(options);
-    return command.commandAction.apply(this, actionArgs);
+  return result;
+}
+var _baseExtremum_default = baseExtremum;
+
+// node_modules/lodash-es/maxBy.js
+function maxBy(array, iteratee) {
+  return array && array.length ? _baseExtremum_default(array, _baseIteratee_default(iteratee, 2), _baseGt_default) : undefined;
+}
+var maxBy_default = maxBy;
+// node_modules/lodash-es/_asciiSize.js
+var asciiSize = _baseProperty_default("length");
+var _asciiSize_default = asciiSize;
+
+// node_modules/lodash-es/_unicodeSize.js
+var rsAstralRange2 = "\\ud800-\\udfff";
+var rsComboMarksRange2 = "\\u0300-\\u036f";
+var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
+var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
+var rsVarRange2 = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange2 + "]";
+var rsCombo = "[" + rsComboRange2 + "]";
+var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+var rsNonAstral = "[^" + rsAstralRange2 + "]";
+var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+var rsZWJ2 = "\\u200d";
+var reOptMod = rsModifier + "?";
+var rsOptVar = "[" + rsVarRange2 + "]?";
+var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeSize(string) {
+  var result = reUnicode.lastIndex = 0;
+  while (reUnicode.test(string)) {
+    ++result;
   }
+  return result;
 }
-var cac = (name = "") => new CAC(name);
-var dist_default = cac;
+var _unicodeSize_default = unicodeSize;
 
-// src/cli.ts
-var import__package3 = __toESM(require_package(), 1);
+// node_modules/lodash-es/_stringSize.js
+function stringSize(string) {
+  return _hasUnicode_default(string) ? _unicodeSize_default(string) : _asciiSize_default(string);
+}
+var _stringSize_default = stringSize;
 
-// src/commands/init.ts
-import { join as join2 } from "path";
+// node_modules/lodash-es/size.js
+var mapTag4 = "[object Map]";
+var setTag4 = "[object Set]";
+function size(collection) {
+  if (collection == null) {
+    return 0;
+  }
+  if (isArrayLike_default(collection)) {
+    return isString_default(collection) ? _stringSize_default(collection) : collection.length;
+  }
+  var tag = _getTag_default(collection);
+  if (tag == mapTag4 || tag == setTag4) {
+    return collection.size;
+  }
+  return _baseKeys_default(collection).length;
+}
+var size_default = size;
+// node_modules/lodash-es/_baseSome.js
+function baseSome(collection, predicate) {
+  var result;
+  _baseEach_default(collection, function(value, index, collection2) {
+    result = predicate(value, index, collection2);
+    return !result;
+  });
+  return !!result;
+}
+var _baseSome_default = baseSome;
 
-// src/utils/config.ts
-import { homedir } from "os";
-import { join } from "path";
-import { mkdir, cp, rm, stat, readdir } from "fs/promises";
+// node_modules/lodash-es/some.js
+function some(collection, predicate, guard) {
+  var func = isArray_default(collection) ? _arraySome_default : _baseSome_default;
+  if (guard && _isIterateeCall_default(collection, predicate, guard)) {
+    predicate = undefined;
+  }
+  return func(collection, _baseIteratee_default(predicate, 3));
+}
+var some_default = some;
+// src/utils/helpers.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
 var exec = promisify(execFile);
+function getErrorMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function checkBin(name) {
+  try {
+    await exec(name, ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkBinVersion(name) {
+  try {
+    const { stdout } = await exec(name, ["--version"]);
+    return stdout.trim().split(`
+`)[0] ?? null;
+  } catch {
+    return null;
+  }
+}
+function plural(count, singular, suffix = "s") {
+  return `${count} ${singular}${count > 1 ? suffix : ""}`;
+}
+function printSummary(ok, fail, label, action) {
+  console.log();
+  if (ok > 0)
+    console.log(`  \u2713 ${action} ${plural(ok, label)}`);
+  if (fail > 0)
+    console.log(`  \u2717 Failed: ${fail}`);
+  if (ok > 0)
+    console.log(`
+  Restart Claude Code to ${action === "Installed" ? "activate" : "apply"}.
+`);
+}
+function maxKeyLength(registry) {
+  return size_default(maxBy_default(keys_default(registry), (k) => k.length) ?? "");
+}
+function listRegistry(registry, header, usage) {
+  console.log(`
+${header}
+`);
+  const pad = maxKeyLength(registry) + 2;
+  for (const [key, item] of Object.entries(registry)) {
+    console.log(`  ${key.padEnd(pad)}${item.description}`);
+  }
+  console.log(`
+Usage:`);
+  for (const line of usage)
+    console.log(`  ${line}`);
+  console.log();
+}
+function validateTargets(targets, registry, errorLabel, helpCmd) {
+  const invalid = filter_default(targets, (t) => !registry[t]);
+  if (invalid.length > 0) {
+    console.error(`
+\u2717 Unknown ${errorLabel}: ${invalid.join(", ")}`);
+    console.error(`  Run '${helpCmd}' to see available ${errorLabel}.
+`);
+    process.exit(1);
+  }
+  return true;
+}
+async function requireClaude() {
+  if (!await checkBin("claude")) {
+    console.error(`
+\u2717 claude CLI not found.
+`);
+    process.exit(1);
+  }
+}
+
+// src/utils/config.ts
+var exec2 = promisify2(execFile2);
 var REPO = "vibe-cokit/claude-code";
 var SKILLS_REPO = "vibe-cokit/skills";
 var CLAUDE_DIR = join(homedir(), ".claude");
 var SKILLS_DIR = join(CLAUDE_DIR, "skills");
 var CONFIG_FOLDERS = ["agents", "commands", "hooks", "prompts", "workflows"];
 var TEMP_DIR = join(homedir(), ".vibe-cokit-tmp");
+var SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
 function log(step) {
   console.log(`  \u2192 ${step}`);
 }
 async function verifyPrerequisites() {
   try {
-    await exec("gh", ["--version"]);
+    await exec2("gh", ["--version"]);
   } catch {
     throw new Error("gh CLI not found. Install: https://cli.github.com");
   }
 }
 async function cloneRepo(tmpDir, repo = REPO) {
   try {
-    await exec("gh", ["repo", "clone", repo, tmpDir]);
+    await exec2("gh", ["repo", "clone", repo, tmpDir]);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new Error(`Failed to clone repo: ${msg}`);
+    throw new Error(`Failed to clone repo: ${getErrorMsg(err)}`);
   }
 }
 async function dirExists(path) {
@@ -734,7 +2323,7 @@ async function copyClaudeMd(srcDir) {
 }
 async function runClaudeInit() {
   try {
-    await exec("claude", ["init"]);
+    await exec2("claude", ["init"]);
     return true;
   } catch {
     console.log("  \u26A0 claude CLI not available, skipping CLAUDE.md enrichment");
@@ -742,18 +2331,22 @@ async function runClaudeInit() {
   }
 }
 async function getCommitSha(tmpDir) {
-  const { stdout } = await exec("git", ["-C", tmpDir, "rev-parse", "HEAD"]);
+  const { stdout } = await exec2("git", ["-C", tmpDir, "rev-parse", "HEAD"]);
   return stdout.trim();
 }
+async function readSettings() {
+  const file = Bun.file(SETTINGS_PATH);
+  if (await file.exists())
+    return file.json();
+  return {};
+}
+async function writeSettings(settings) {
+  await Bun.write(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
 async function updateSettings(commitSha) {
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
-  let settings = {};
-  const file = Bun.file(settingsPath);
-  if (await file.exists()) {
-    settings = await file.json();
-  }
+  const settings = await readSettings();
   settings.version = commitSha;
-  await Bun.write(settingsPath, JSON.stringify(settings, null, 2));
+  await writeSettings(settings);
 }
 async function cleanup(tmpDir) {
   try {
@@ -761,17 +2354,12 @@ async function cleanup(tmpDir) {
   } catch {}
 }
 async function getCurrentVersion() {
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
-  const file = Bun.file(settingsPath);
-  if (await file.exists()) {
-    const settings = await file.json();
-    return settings.version ?? null;
-  }
-  return null;
+  const settings = await readSettings();
+  return get_default(settings, "version", null);
 }
 async function getRemoteSha(ref, repo = REPO) {
   const target = ref ?? "HEAD";
-  const { stdout } = await exec("git", ["ls-remote", `https://github.com/${repo}.git`, target]);
+  const { stdout } = await exec2("git", ["ls-remote", `https://github.com/${repo}.git`, target]);
   const sha = stdout.trim().split("\t")[0];
   if (!sha)
     throw new Error(`Could not resolve ref: ${target}`);
@@ -790,32 +2378,24 @@ async function copySkillFolders(srcDir) {
   }
 }
 async function updateSkillsVersion(commitSha) {
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
-  let settings = {};
-  const file = Bun.file(settingsPath);
-  if (await file.exists()) {
-    settings = await file.json();
-  }
+  const settings = await readSettings();
   settings.skillsVersion = commitSha;
-  await Bun.write(settingsPath, JSON.stringify(settings, null, 2));
+  await writeSettings(settings);
 }
 async function getSkillsVersion() {
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
-  const file = Bun.file(settingsPath);
-  if (await file.exists()) {
-    const settings = await file.json();
-    return settings.skillsVersion ?? null;
-  }
-  return null;
+  const settings = await readSettings();
+  return get_default(settings, "skillsVersion", null);
 }
 async function upgradeCli() {
-  const { version: currentVersion } = await Promise.resolve().then(() => __toESM(require_package(), 1));
-  const { stdout: latestRaw } = await exec("npm", ["view", "vibe-cokit", "version"]);
+  const { stdout: installedRaw } = await exec2("bun", ["pm", "ls", "-g"]);
+  const match = installedRaw.match(/vibe-cokit@(\S+)/);
+  const currentVersion = match?.[1] ?? "0.0.0";
+  const { stdout: latestRaw } = await exec2("npm", ["view", "vibe-cokit", "version"]);
   const latestVersion = latestRaw.trim();
   if (currentVersion === latestVersion) {
     return { upgraded: false, from: currentVersion, to: latestVersion };
   }
-  await exec("bun", ["install", "-g", `vibe-cokit@${latestVersion}`]);
+  await exec2("bun", ["install", "-g", `vibe-cokit@${latestVersion}`]);
   return { upgraded: true, from: currentVersion, to: latestVersion };
 }
 
@@ -846,9 +2426,8 @@ vibe-cokit init
     console.log(`  Claude:  ./CLAUDE.md
 `);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
     console.error(`
-\u2717 Init failed: ${msg}
+\u2717 Init failed: ${getErrorMsg(err)}
 `);
     process.exit(1);
   } finally {
@@ -858,9 +2437,9 @@ vibe-cokit init
 
 // src/commands/update.ts
 import { join as join3 } from "path";
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execFile2);
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var exec3 = promisify3(execFile3);
 async function updateCommand(ref) {
   try {
     console.log(`
@@ -885,7 +2464,7 @@ vibe-cokit update
 \u2713 vibe-cokit update complete!
 `);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = getErrorMsg(err);
     console.error(`
 \u2717 Update failed: ${msg}
 `);
@@ -907,7 +2486,7 @@ async function updateConfig(ref) {
     await cloneRepo(tmpDir);
     if (ref) {
       log(`Checking out ${ref}...`);
-      await exec2("git", ["-C", tmpDir, "checkout", ref]);
+      await exec3("git", ["-C", tmpDir, "checkout", ref]);
     }
     log("Updating config folders in ~/.claude/");
     await copyConfigFolders(tmpDir);
@@ -934,7 +2513,7 @@ async function updateSkills(ref) {
     await cloneRepo(tmpDir, SKILLS_REPO);
     if (ref) {
       log(`Checking out ${ref}...`);
-      await exec2("git", ["-C", tmpDir, "checkout", ref]);
+      await exec3("git", ["-C", tmpDir, "checkout", ref]);
     }
     log("Updating skills in ~/.claude/skills/");
     await copySkillFolders(tmpDir);
@@ -949,9 +2528,9 @@ async function updateSkills(ref) {
 
 // src/commands/skills.ts
 import { join as join4 } from "path";
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var exec3 = promisify3(execFile3);
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var exec4 = promisify4(execFile4);
 async function skillsCommand(ref) {
   const tmpDir = join4(TEMP_DIR, crypto.randomUUID());
   try {
@@ -974,7 +2553,7 @@ vibe-cokit skills
     await cloneRepo(tmpDir, SKILLS_REPO);
     if (ref) {
       log(`Checking out ${ref}...`);
-      await exec3("git", ["-C", tmpDir, "checkout", ref]);
+      await exec4("git", ["-C", tmpDir, "checkout", ref]);
     }
     log("Copying skills to ~/.claude/skills/");
     await copySkillFolders(tmpDir);
@@ -989,9 +2568,8 @@ vibe-cokit skills
     console.log(`  Skills:  ~/.claude/skills/
 `);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
     console.error(`
-\u2717 Skills setup failed: ${msg}
+\u2717 Skills setup failed: ${getErrorMsg(err)}
 `);
     process.exit(1);
   } finally {
@@ -1000,9 +2578,8 @@ vibe-cokit skills
 }
 
 // src/commands/help.ts
-var import__package = __toESM(require_package(), 1);
 var HELP_TEXT = `
-vibe-cokit v${import__package.version} \u2014 A toolkit for interacting with Claude Code
+vibe-cokit v${version} \u2014 A toolkit for interacting with Claude Code
 
 USAGE
   vk <command> [options]
@@ -1067,12 +2644,11 @@ function helpCommand() {
 }
 
 // src/commands/version.ts
-var import__package2 = __toESM(require_package(), 1);
 async function versionCommand() {
   const commitSha = await getCurrentVersion();
   const skillsSha = await getSkillsVersion();
   console.log(`
-vibe-cokit v${import__package2.version}`);
+vibe-cokit v${version}`);
   if (commitSha) {
     console.log(`  Config commit:  ${commitSha.slice(0, 10)}`);
   } else {
@@ -1087,19 +2663,7 @@ vibe-cokit v${import__package2.version}`);
 }
 
 // src/commands/doctor.ts
-import { execFile as execFile4 } from "child_process";
-import { promisify as promisify4 } from "util";
 import { join as join5 } from "path";
-var exec4 = promisify4(execFile4);
-async function checkBin(name) {
-  try {
-    const { stdout } = await exec4(name, ["--version"]);
-    return stdout.trim().split(`
-`)[0] ?? null;
-  } catch {
-    return null;
-  }
-}
 async function doctorCommand() {
   console.log(`
 vibe-cokit doctor
@@ -1107,7 +2671,7 @@ vibe-cokit doctor
   let issues = 0;
   const tools = ["gh", "git", "claude"];
   for (const tool of tools) {
-    const ver = await checkBin(tool);
+    const ver = await checkBinVersion(tool);
     if (ver) {
       console.log(`  \u2713 ${tool}: ${ver}`);
     } else {
@@ -1156,7 +2720,7 @@ vibe-cokit doctor
     console.log(`  \u2713 All checks passed!
 `);
   } else {
-    console.log(`  \u26A0 ${issues} issue${issues > 1 ? "s" : ""} found
+    console.log(`  \u26A0 ${plural(issues, "issue")} found
 `);
   }
 }
@@ -1171,14 +2735,14 @@ vibe-cokit doctor fix
     log("Verifying prerequisites...");
     await verifyPrerequisites();
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
     console.error(`
-\u2717 Cannot fix: ${msg}
+\u2717 Cannot fix: ${getErrorMsg(err)}
 `);
     process.exit(1);
   }
   let fixed = 0;
-  const configMissing = !await dirExists(CLAUDE_DIR) || (await Promise.all(CONFIG_FOLDERS.map((f) => dirExists(join6(CLAUDE_DIR, f))))).some((exists) => !exists) || !await getCurrentVersion();
+  const folderChecks = await Promise.all(CONFIG_FOLDERS.map((f) => dirExists(join6(CLAUDE_DIR, f))));
+  const configMissing = !await dirExists(CLAUDE_DIR) || some_default(folderChecks, (exists) => !exists) || !await getCurrentVersion();
   const claudeMdPath = join6(process.cwd(), "CLAUDE.md");
   const claudeMdMissing = !await fileExists(claudeMdPath);
   if (configMissing || claudeMdMissing) {
@@ -1204,8 +2768,7 @@ vibe-cokit doctor fix
         log("CLAUDE.md: OK");
       }
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`  \u2717 Config/CLAUDE.md fix failed: ${msg}`);
+      console.error(`  \u2717 Config/CLAUDE.md fix failed: ${getErrorMsg(err)}`);
     } finally {
       await cleanup(tmpDir);
     }
@@ -1225,8 +2788,7 @@ vibe-cokit doctor fix
       log(`Skills installed (${sha.slice(0, 8)})`);
       fixed++;
     } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`  \u2717 Skills fix failed: ${msg}`);
+      console.error(`  \u2717 Skills fix failed: ${getErrorMsg(err)}`);
     } finally {
       await cleanup(tmpDir);
     }
@@ -1235,7 +2797,7 @@ vibe-cokit doctor fix
   }
   console.log();
   if (fixed > 0) {
-    console.log(`  \u2713 Fixed ${fixed} issue${fixed > 1 ? "s" : ""}!
+    console.log(`  \u2713 Fixed ${plural(fixed, "issue")}!
 `);
   } else {
     console.log(`  \u2713 Nothing to fix \u2014 all good!
@@ -1302,52 +2864,16 @@ var MCP_MODULES = {
     args: ["-y", "@modelcontextprotocol/server-puppeteer"]
   }
 };
-function listModules() {
-  console.log(`
-Available MCP modules:
-`);
-  const maxName = Math.max(...Object.keys(MCP_MODULES).map((k) => k.length));
-  for (const [key, mod] of Object.entries(MCP_MODULES)) {
-    console.log(`  ${key.padEnd(maxName + 2)}${mod.description}`);
-  }
-  console.log(`
-Usage:`);
-  console.log(`  vk mcp install <module> [module2 ...]`);
-  console.log(`  vk mcp install --all`);
-  console.log(`  vk mcp uninstall <module> [module2 ...]`);
-  console.log();
-}
-async function checkClaude() {
-  try {
-    await exec5("claude", ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function checkUv() {
-  try {
-    await exec5("uvx", ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function addModule(mod) {
   const config = { command: mod.command, args: mod.args };
   if (mod.env) {
-    const envConfig = {};
-    for (const [key, defaultVal] of Object.entries(mod.env)) {
-      envConfig[key] = process.env[key] || defaultVal;
-    }
-    config.env = envConfig;
+    config.env = mapValues_default(mod.env, (defaultVal, key) => process.env[key] || defaultVal);
   }
   try {
     await exec5("claude", ["mcp", "add-json", mod.name, JSON.stringify(config)]);
     return true;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`  \u2717 Failed to add ${mod.name}: ${msg}`);
+    console.error(`  \u2717 Failed to add ${mod.name}: ${getErrorMsg(err)}`);
     return false;
   }
 }
@@ -1356,7 +2882,7 @@ async function removeModule(name) {
     await exec5("claude", ["mcp", "remove", name]);
     return true;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = getErrorMsg(err);
     if (msg.includes("not found") || msg.includes("does not exist")) {
       console.log(`  \u26A0 ${name} not configured, skipping`);
       return true;
@@ -1383,28 +2909,20 @@ vk mcp \u2014 Manage MCP servers for Claude Code
 }
 async function mcpInstallCommand(modules, options) {
   if (modules.length === 0 && !options.all) {
-    listModules();
+    listRegistry(MCP_MODULES, "Available MCP modules:", [
+      "vk mcp install <module> [module2 ...]",
+      "vk mcp install --all",
+      "vk mcp uninstall <module> [module2 ...]"
+    ]);
     return;
   }
   log("Checking claude CLI...");
-  if (!await checkClaude()) {
-    console.error(`
-\u2717 claude CLI not found.
-`);
-    process.exit(1);
-  }
-  const targets = options.all ? Object.keys(MCP_MODULES) : modules;
-  const invalid = targets.filter((m) => !MCP_MODULES[m]);
-  if (invalid.length > 0) {
-    console.error(`
-\u2717 Unknown modules: ${invalid.join(", ")}`);
-    console.error(`  Run 'vk mcp install' to see available modules.
-`);
-    process.exit(1);
-  }
-  if (targets.some((m) => MCP_MODULES[m]?.requiresUv)) {
+  await requireClaude();
+  const targets = options.all ? keys_default(MCP_MODULES) : modules;
+  validateTargets(targets, MCP_MODULES, "modules", "vk mcp install");
+  if (some_default(targets, (m) => MCP_MODULES[m]?.requiresUv)) {
     log("Checking uv/uvx...");
-    if (!await checkUv()) {
+    if (!await checkBin("uvx")) {
       console.error(`
 \u2717 uvx not found (required for serena). Install: https://docs.astral.sh/uv/
 `);
@@ -1413,13 +2931,11 @@ async function mcpInstallCommand(modules, options) {
   }
   for (const name of targets) {
     const mod = MCP_MODULES[name];
-    if (!mod)
+    if (!mod?.envPrompts)
       continue;
-    if (mod.envPrompts) {
-      for (const [key, prompt] of Object.entries(mod.envPrompts)) {
-        if (!process.env[key] && mod.env && !mod.env[key]) {
-          console.log(`  \u26A0 ${name}: ${prompt} not set (env: ${key})`);
-        }
+    for (const [key, prompt] of Object.entries(mod.envPrompts)) {
+      if (!process.env[key] && mod.env && !mod.env[key]) {
+        console.log(`  \u26A0 ${name}: ${prompt} not set (env: ${key})`);
       }
     }
   }
@@ -1436,15 +2952,7 @@ async function mcpInstallCommand(modules, options) {
       fail++;
     }
   }
-  console.log();
-  if (ok > 0)
-    console.log(`  \u2713 Installed ${ok} MCP module${ok > 1 ? "s" : ""}`);
-  if (fail > 0)
-    console.log(`  \u2717 Failed: ${fail}`);
-  if (ok > 0)
-    console.log(`
-  Restart Claude Code to activate.
-`);
+  printSummary(ok, fail, "MCP module", "Installed");
 }
 async function mcpUninstallCommand(modules) {
   if (modules.length === 0) {
@@ -1454,12 +2962,7 @@ Usage: vk mcp uninstall <module> [module2 ...]
     return;
   }
   log("Checking claude CLI...");
-  if (!await checkClaude()) {
-    console.error(`
-\u2717 claude CLI not found.
-`);
-    process.exit(1);
-  }
+  await requireClaude();
   let ok = 0, fail = 0;
   for (const name of modules) {
     log(`Removing ${name}...`);
@@ -1470,15 +2973,7 @@ Usage: vk mcp uninstall <module> [module2 ...]
       fail++;
     }
   }
-  console.log();
-  if (ok > 0)
-    console.log(`  \u2713 Removed ${ok} MCP module${ok > 1 ? "s" : ""}`);
-  if (fail > 0)
-    console.log(`  \u2717 Failed: ${fail}`);
-  if (ok > 0)
-    console.log(`
-  Restart Claude Code to apply.
-`);
+  printSummary(ok, fail, "MCP module", "Removed");
 }
 
 // src/commands/plugin.ts
@@ -1557,35 +3052,12 @@ var PLUGINS = {
     marketplace: "claude-plugins-official"
   }
 };
-function listPlugins() {
-  console.log(`
-Available plugins:
-`);
-  const maxName = Math.max(...Object.keys(PLUGINS).map((k) => k.length));
-  for (const [key, plugin] of Object.entries(PLUGINS)) {
-    console.log(`  ${key.padEnd(maxName + 2)}${plugin.description}`);
-  }
-  console.log(`
-Usage:`);
-  console.log(`  vk plugin install <name> [name2 ...]`);
-  console.log(`  vk plugin install --all`);
-  console.log(`  vk plugin uninstall <name> [name2 ...]`);
-  console.log();
-}
-async function checkClaude2() {
-  try {
-    await exec6("claude", ["--version"]);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function addPlugin(plugin) {
   const fullName = `${plugin.name}@${plugin.marketplace}`;
   try {
     await exec6("claude", ["plugin", "install", fullName]);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = getErrorMsg(err);
     if (!msg.includes("already installed")) {
       console.error(`  \u2717 Failed to install ${plugin.name}: ${msg}`);
       return false;
@@ -1594,7 +3066,7 @@ async function addPlugin(plugin) {
   try {
     await exec6("claude", ["plugin", "enable", fullName]);
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = getErrorMsg(err);
     if (!msg.includes("already enabled")) {
       console.error(`  \u2717 Failed to enable ${plugin.name}: ${msg}`);
       return false;
@@ -1609,7 +3081,7 @@ async function removePlugin(name) {
     await exec6("claude", ["plugin", "uninstall", fullName]);
     return true;
   } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
+    const msg = getErrorMsg(err);
     if (msg.includes("not installed") || msg.includes("not found")) {
       console.log(`  \u26A0 ${name} not installed, skipping`);
       return true;
@@ -1636,25 +3108,17 @@ vk plugin \u2014 Manage Claude Code plugins
 }
 async function pluginInstallCommand(modules, options) {
   if (modules.length === 0 && !options.all) {
-    listPlugins();
+    listRegistry(PLUGINS, "Available plugins:", [
+      "vk plugin install <name> [name2 ...]",
+      "vk plugin install --all",
+      "vk plugin uninstall <name> [name2 ...]"
+    ]);
     return;
   }
   log("Checking claude CLI...");
-  if (!await checkClaude2()) {
-    console.error(`
-\u2717 claude CLI not found.
-`);
-    process.exit(1);
-  }
-  const targets = options.all ? Object.keys(PLUGINS) : modules;
-  const invalid = targets.filter((p) => !PLUGINS[p]);
-  if (invalid.length > 0) {
-    console.error(`
-\u2717 Unknown plugins: ${invalid.join(", ")}`);
-    console.error(`  Run 'vk plugin install' to see available plugins.
-`);
-    process.exit(1);
-  }
+  await requireClaude();
+  const targets = options.all ? keys_default(PLUGINS) : modules;
+  validateTargets(targets, PLUGINS, "plugins", "vk plugin install");
   let ok = 0, fail = 0;
   for (const name of targets) {
     const plugin = PLUGINS[name];
@@ -1668,15 +3132,7 @@ async function pluginInstallCommand(modules, options) {
       fail++;
     }
   }
-  console.log();
-  if (ok > 0)
-    console.log(`  \u2713 Installed ${ok} plugin${ok > 1 ? "s" : ""}`);
-  if (fail > 0)
-    console.log(`  \u2717 Failed: ${fail}`);
-  if (ok > 0)
-    console.log(`
-  Restart Claude Code to activate.
-`);
+  printSummary(ok, fail, "plugin", "Installed");
 }
 async function pluginUninstallCommand(modules) {
   if (modules.length === 0) {
@@ -1686,12 +3142,7 @@ Usage: vk plugin uninstall <name> [name2 ...]
     return;
   }
   log("Checking claude CLI...");
-  if (!await checkClaude2()) {
-    console.error(`
-\u2717 claude CLI not found.
-`);
-    process.exit(1);
-  }
+  await requireClaude();
   let ok = 0, fail = 0;
   for (const name of modules) {
     log(`Removing ${name}...`);
@@ -1702,15 +3153,7 @@ Usage: vk plugin uninstall <name> [name2 ...]
       fail++;
     }
   }
-  console.log();
-  if (ok > 0)
-    console.log(`  \u2713 Removed ${ok} plugin${ok > 1 ? "s" : ""}`);
-  if (fail > 0)
-    console.log(`  \u2717 Failed: ${fail}`);
-  if (ok > 0)
-    console.log(`
-  Restart Claude Code to apply.
-`);
+  printSummary(ok, fail, "plugin", "Removed");
 }
 
 // src/cli.ts
@@ -1735,5 +3178,5 @@ cli.command("plugin [action] [...plugins]", "Manage plugins (install/uninstall)"
   return pluginCommand(action, plugins, options);
 });
 cli.help();
-cli.version(import__package3.version);
+cli.version(version);
 cli.parse();